Une fois que vous avez créé quelques nœuds personnalisés, l’étape suivante consiste à les organiser et à les publier au moyen de packages, une méthode pratique pour stocker et partager vos nœuds avec la communauté Dynamo.

Les nœuds personnalisés sont construits en imbriquant d'autres nœuds et nœuds personnalisés dans un "nœud personnalisé Dynamo", que vous pouvez comparer à un conteneur. Lorsque ce nœud conteneur est exécuté dans votre graphique, tous les éléments qu'il contient sont exécutés pour vous permettre de réutiliser et de partager une combinaison utile de nœuds.

Adaptation au changement

Lorsque votre graphique contient plusieurs copies d'un nœud personnalisé, vous pouvez tous les mettre à jour en modifiant le nœud personnalisé de base. Cela vous permet de mettre à jour votre graphique de manière fluide en l'adaptant aux modifications susceptibles de se produire dans le workflow ou la conception.

Travail collaboratif

La meilleure fonctionnalité des nœuds personnalisés est sans doute leur capacité de partage de travail. Si un "utilisateur avancé" crée un graphique Dynamo complexe et le transmet à un concepteur qui débute avec Dynamo, il peut condenser le graphique en ne gardant que l'essentiel pour l'interaction. Le nœud personnalisé peut être ouvert pour modifier le graphique interne, mais le "conteneur" peut rester simple. Avec ce processus, les nœuds personnalisés permettent aux utilisateurs de Dynamo de concevoir un graphique propre et intuitif.

Les différentes méthodes de création d’un nœud

Il existe de nombreuses façons de créer des nœuds personnalisés dans Dynamo. Dans les exemples de ce chapitre, vous allez créer des nœuds personnalisés directement à partir de l’interface utilisateur de Dynamo. Si vous êtes programmeur et que vous souhaitez utiliser le formatage C# ou Zero Touch, vous pouvez consulter cette page sur le wiki Dynamo pour des informations plus approfondies.

Environnement de nœud personnalisé et création de votre premier nœud personnalisé

Passez maintenant à l'environnement de nœud personnalisé et créez un nœud simple pour calculer un pourcentage. L'environnement de nœud personnalisé est différent de l'environnement graphique Dynamo, mais l'interaction est similaire. Cela étant dit, vous allez maintenant créer votre premier nœud personnalisé.

Pour créer un nœud personnalisé à partir de zéro, lancez Dynamo et choisissez Nœud personnalisé, ou tapez Ctrl + Maj + N dans la zone de dessin.

Ajoutez un nom, une description et une catégorie dans la boîte de dialogue Propriétés du nœud personnalisé.

1. Nom : Pourcentage

2. Description : Calcule le pourcentage d’une valeur par rapport à une autre.

3. Catégorie : Math.Functions

Une zone de dessin s’ouvre avec un arrière-plan jaune, indiquant que vous travaillez dans un nœud personnalisé. Dans cette zone de dessin, vous avez accès à tous les nœuds Dynamo de base, ainsi qu'aux nœuds Input et Output, qui définissent le flux de données entrant et sortant du nœud personnalisé. Ils se trouvent sous Input > Basic.

1. Input : les nœuds Input créent des ports d’entrée sur le nœud personnalisé. La syntaxe d’un nœud d’entrée est nom_entrée : typededonnées = valeur_défaut (facultatif).

2. Outputs: semblables aux entrées, elles créent et nomment des ports de sortie sur le nœud personnalisé. Ajoutez un commentaire personnalisé aux ports d’entrée et de sortie pour indiquer les types d’entrée et de sortie. Cette opération est décrite plus en détail dans la section Création de nœuds personnalisés.

Vous pouvez enregistrer ce nœud personnalisé en tant que fichier .dyf (par opposition au fichier .dyn standard) et il sera automatiquement ajouté à votre session et aux sessions ultérieures. Le nœud personnalisé se trouve dans votre bibliothèque, dans la section Compléments.

Pour continuer

Maintenant que vous avez créé votre premier nœud personnalisé, les sections suivantes approfondiront la fonctionnalité des nœuds personnalisés et la publication de workflows génériques. Dans la section suivante, vous allez développer un nœud personnalisé qui transfère la géométrie d'une surface à une autre.

Dynamo offre de nombreuses fonctionnalités prêtes à l'emploi, stockées dans sa bibliothèque de nœuds. Les packages et nœuds personnalisés, quant à eux, constituent un excellent moyen d’étendre les fonctionnalités de Dynamo pour les adapter à vos habitudes de travail ou pour concevoir un graphique spécial que vous souhaitez partager avec la communauté.

Dynamo propose plusieurs méthodes de création de nœuds personnalisés. Vous pouvez créer des nœuds personnalisés à partir de zéro, à partir d'un graphique existant ou de façon explicite en C#. Dans cette section, vous allez découvrir comment créer un nœud personnalisé dans l'interface utilisateur de Dynamo à partir d'un graphique existant. Cette méthode est idéale pour nettoyer l'espace de travail, ainsi que pour regrouper une séquence de nœuds à réutiliser ailleurs.

Exercice : Nœuds personnalisés pour le mappage UV

Partie I : Commencer par un graphique

Dans l'image ci-dessous, un point d'une surface est mappé sur une autre surface à l'aide des coordonnées UV. Ce concept va vous permettre de créer une surface de panneaux qui référence des courbes dans le plan XY. Dans le cadre de la construction de panneaux, vous allez créer ici des panneaux quadrilatéraux. En utilisant la même logique, vous pouvez créer un grand nombre de panneaux avec le mappage UV. C’est une excellente opportunité pour le développement de nœuds personnalisés, car vous pourrez répéter un processus similaire plus facilement dans ce graphique ou dans d’autres workflows Dynamo.

Téléchargez le fichier d’exemple en cliquant sur le lien ci-dessous.

Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

1. Code Block : utilisez cette ligne pour créer une plage de 10 nombres entre -45 et 45 45..45..#10;

2. Point.ByCoordinates : connectez la sortie du nœud Code Block aux entrées « x » et « y » et définissez la liaison sur Référence croisée. Vous devez maintenant avoir une grille de points.

3. Plane.ByOriginNormal : connectez la sortie « Point » à l’entrée « origin » pour créer un plan au niveau de chacun des points. Le vecteur normal par défaut de (0,0,1) est utilisé.

4. Rectangle.ByWidthLength : connectez les plans de l’étape précédente à l’entrée « plan », puis utilisez un nœud Code Block avec une valeur de 10 pour spécifier la largeur et la longueur.

Vous devez maintenant voir une grille de rectangles. Mappez ces rectangles sur une surface cible à l’aide des coordonnées UV.

1. Polygon.Points : connectez la sortie du nœud Rectangle.ByWidthLength de l’étape précédente à l’entrée « polygon » pour extraire les points de coin de chaque rectangle. Il s’agit des points que vous allez mapper sur la surface cible.

2. Rectangle.ByWidthLength : utilisez un nœud Code Block avec une valeur de 100 pour spécifier la largeur et la longueur d’un rectangle. Il s’agit de la limite de la surface de base.

3. Surface.ByPatch : connectez le nœud Rectangle.ByWidthLength de l’étape précédente à l’entrée « closedCurve » pour créer une surface de base.

4. Surface.UVParameterAtPoint : connectez la sortie « Point » du nœud Polygon.Points et la sortie « Surface » du nœud Surface.ByPatch pour renvoyer le paramètre UV à chaque point.

Maintenant que vous avez une surface de base et un ensemble de coordonnées UV, importez une surface cible et mappez les points entre les surfaces.

1. File Path : sélectionnez le chemin d’accès au fichier de la surface à importer. Le type de fichier doit être .SAT. Cliquez sur le bouton « Parcourir… » et accédez au fichier UVmapping_srf.sat à partir du fichier .zip téléchargé ci-dessus.

2. Geometry.ImportFromSAT : connectez le chemin d’accès au fichier pour importer la surface. Vous devez voir la surface importée dans l’aperçu de la géométrie.

3. UV : connectez la sortie du paramètre UV à un nœud UV.U et à un nœud UV.V.

4. Surface.PointAtParameter : connectez la surface importée ainsi que les coordonnées u et v. Vous devez maintenant voir une grille de points 3D sur la surface cible.

La dernière étape consiste à utiliser les points 3D pour construire des corrections de surface rectangulaires.

1. PolyCurve.ByPoints : connectez les points de la surface pour construire une polycourbe à travers les points.

2. Boolean : ajoutez un nœud Boolean à l’espace de travail, connectez-le à l’entrée « connectLastToFirst » et sélectionnez True pour fermer les polycourbes. Vous devez maintenant voir des rectangles mappés sur la surface.

3. Surface.ByPatch : connectez les polycourbes à l’entrée « closedCurve » pour construire des corrections de surface.

Partie II : Du graphique au nœud personnalisé

Sélectionnez les nœuds à imbriquer dans un nœud personnalisé, en choisissant les entrées et les sorties de votre nœud. Étant donné que votre nœud personnalisé doit être aussi flexible que possible, il doit être en mesure de mapper des polygones, pas seulement des rectangles.

Sélectionnez les nœuds suivants (en commençant par le nœud Polygon.Points), cliquez avec le bouton droit de la souris sur l’espace de travail et choisissez « Créer un nœud personnalisé ».

Dans la boîte de dialogue Propriétés du nœud personnalisé, attribuez un nom, une description et une catégorie au nœud personnalisé.

1. Nom : MapPolygonsToSurface

2. Description : mapper le ou les polygones d’une surface de base à une surface cible

3. Catégorie des packages complémentaires : Geometry.Curve

Le nœud personnalisé a considérablement nettoyé l'espace de travail. Notez que les entrées et les sorties ont été nommées en fonction des nœuds d'origine. Modifiez le nœud personnalisé pour rendre les noms plus descriptifs.

Cliquez deux fois sur le nœud personnalisé pour le modifier. Un espace de travail à l’arrière-plan jaune représentant l’intérieur du nœud s’affiche.

1. Entrées : remplacez les noms d’entrée par baseSurface et targetSurface.

2. Sorties : ajoutez une sortie supplémentaire pour les polygones mappés.

Enregistrez le nœud personnalisé et revenez à l’espace de travail de base. Notez que le nœud MapPolygonsToSurface reflète les modifications apportées.

Vous pouvez également renforcer la robustesse du nœud personnalisé en ajoutant des commentaires personnalisés. Les commentaires peuvent vous aider à indiquer les types d’entrée et de sortie ou à expliquer la fonctionnalité du nœud. Des commentaires s'affichent lorsque l'utilisateur place le curseur sur une entrée ou une sortie d'un nœud personnalisé.

Cliquez deux fois sur le nœud personnalisé pour le modifier. Cette action permet de rouvrir l’espace de travail à l’arrière-plan jaune.

1. Commencez par modifier le bloc de code Input. Pour commencer un commentaire, saisissez « // » suivi du texte du commentaire. Tapez tout ce qui peut aider à clarifier le nœud : ici, c’est la surface cible qui est décrite.

2. Définissez également la valeur par défaut pour inputSurface en définissant le type d’entrée sur une valeur équivalente. Ici, la valeur par défaut est définie sur le jeu Surface.ByPatch d’origine.

Vous pouvez également appliquer les commentaires aux sorties.

Modifiez le texte dans le bloc de code Output. Saisissez « // » suivi du texte du commentaire. Ici, une description plus détaillée est ajoutée pour clarifier les sorties de Polygons et de surfacePatches.

1. Placez le curseur sur les entrées de nœud personnalisé pour afficher les commentaires.

2. Étant donné que la valeur par défaut est définie sur inputSurface, vous pouvez également exécuter la définition sans entrée de surface.

Dynamo propose de nombreux nœuds clés pour une large gamme de tâches de programmation visuelle. Parfois, la création de vos propres nœuds est une solution plus rapide, plus élégante ou plus facilement partageable. Ces nœuds peuvent être réutilisés dans différents projets, ils rendent vos graphiques plus clairs et plus propres, et ils peuvent être transférés vers le gestionnaire de packages et partagés avec la communauté Dynamo mondiale.

Dynamo offre de nombreuses méthodes de création de package en vue d'un usage personnel ou d'un partage avec la communauté Dynamo. Dans l'étude de cas ci-dessous, vous allez découvrir comment un package est configuré en déconstruisant un package existant. Cette étude de cas s'appuie sur les leçons du chapitre précédent, fournissant un ensemble de nœuds personnalisés pour la géométrie de mappage, en fonction des coordonnées UV, d'une surface Dynamo à une autre.

Package MapToSurface

Vous allez travailler avec un exemple de package qui illustre le mappage UV des points d’une surface à une autre. Vous avez déjà intégré les concepts de base de l’outil dans la section Création d’un nœud personnalisé de ce guide. Les fichiers ci-dessous montrent comment vous pouvez utiliser le concept du mappage UV et développer un jeu d’outils pour une bibliothèque publiable.

Dans cette image, un point d'une surface est mappé sur une autre surface à l'aide des coordonnées UV. Le package est fondé sur ce concept, mais avec une géométrie plus complexe.

Installation du package

Dans le chapitre précédent, vous avez étudié les méthodes de contruction de panneaux sur une surface dans Dynamo en fonction des courbes définies dans le plan XY. Cette étude de cas étend ces concepts pour davantage de cotes de géométrie. Vous allez installer ce package tel qu'il a été conçu pour montrer comment il a été développé. Dans la section suivante, vous allez découvrir comment ce package a été publié.

Dans Dynamo, cliquez sur Packages > Gestionnaire de package et recherchez le package « MapToSurface » (en un mot). Cliquez sur Installer pour lancer le téléchargement et ajouter le package à votre bibliothèque.

Une fois l’installation terminée, les nœuds personnalisés sont disponibles sous la section Compléments > DynamoPrimer.

Une fois le package installé, voyons comment il est configuré.

Nœuds personnalisés

Le package créé utilise cinq nœuds personnalisés créés pour référence. Vous découvrirez ci-dessous le fonctionnement de chaque nœud. Certains nœuds personnalisés sont créés à partir d'autres nœuds personnalisés, et la disposition des graphiques permet aux autres utilisateurs de comprendre rapidement.

Il s'agit d'un package simple de cinq nœuds personnalisés. Les étapes ci-dessous présentent brièvement la configuration de chaque nœud personnalisé.

PointsToSurface

Il s’agit d’un nœud personnalisé de base, sur lequel tous les autres nœuds de mappage reposent. Autrement dit, le nœud mappe un point à partir d'une coordonnée UV de la surface source vers l'emplacement de la coordonnée UV de la surface cible. Étant donné que les points constituent la géométrie la plus basique à partir de laquelle une géométrie plus complexe est créée, vous pouvez utiliser cette logique pour mapper une géométrie 2D, voire 3D, d’une surface à une autre.

PolygonsToSurface

La logique d’extension des points mappés de la géométrie 1D à la géométrie 2D est simplement présentée ici avec des polygones. Le nœud « PointsToSurface » est imbriqué dans ce nœud personnalisé. De cette manière, vous pouvez mapper les points de chaque polygone sur la surface, puis régénérer le polygone à partir de ces points mappés. En conservant la structure de données appropriée (une liste de listes de points), vous pouvez conserver les polygones séparés une fois réduits à un ensemble de points.

NurbsCrvtoSurface

La même logique s’applique ici, ainsi que dans le nœud « PolygonsToSurface ». Au lieu de mapper des points polygonaux, vous allez mapper les points de contrôle d’une courbe NURBS.

OffsetPointsToSurface

Ce nœud devient un peu plus complexe, mais le concept est simple. Comme le nœud « PointsToSurface », ce nœud mappe des points d’une surface à une autre. Toutefois, il prend également en compte les points qui ne sont pas sur la surface source d’origine, extrait leur distance par rapport au paramètre UV le plus proche et mappe cette distance par rapport à la normale de surface cible au niveau des coordonnées UV correspondantes. Regardez les fichiers d’exemple pour comprendre.

SampleSrf

Il s’agit d’un nœud simple qui crée une surface paramétrique à mapper de la grille source à une surface ondulée dans les fichiers d’exemple.

Fichiers d’exemple

Les fichiers d’exemple se trouvent dans le dossier racine du package. Cliquez sur Gestionnaire de package > onglet Packages installés.

En regard de MapToSurface, cliquez sur le menu des trois points verticaux > Afficher le répertoire racine.

Ensuite, ouvrez le dossier « extra », qui contient tous les fichiers du package qui ne sont pas des nœuds personnalisés. C’est là que sont stockés les fichiers d’exemple (s’ils existent) des packages Dynamo. Les captures d’écran ci-dessous décrivent les concepts présentés dans chaque fichier d’exemple.

01-PanelingWithPolygons

Ce fichier d’exemple montre comment vous pouvez utiliser « PointsToSurface » pour créer des panneaux sur une surface en fonction d’une grille de rectangles. Ce processus vous paraît sûrement familier, car un workflow similaire est présenté dans le chapitre précédent.

02-PanelingWithPolygons-II

À l’aide d’un workflow similaire, ce fichier d’exercice présente une configuration permettant de mapper des cercles (ou des polygones représentant des cercles) d’une surface à une autre. Cette option utilise le nœud PolygonsToSurface.

03-NurbsCrvsAndSurface

Ce fichier d’exemple ajoute de la complexité en exploitant le nœud « NurbsCrvToSurface ». La surface cible est décalée d'une distance donnée, et la courbe NURBS est mappée sur la surface cible d'origine et la surface décalée. À partir de là, les deux courbes mappées sont lissées pour créer une surface, qui est ensuite épaissie. Le solide qui en résulte comporte une ondulation représentative des normales de la surface cible.

04-PleatedPolysurface-OffsetPoints

Ce fichier d’exemple montre comment mapper une polysurface plissée entre une surface source et une surface cible. Les surfaces source et cible sont une surface rectangulaire qui s’étend sur la grille et une surface de révolution, respectivement.

Polysurface source mappée entre la surface source et la surface cible.

05-SVG-Import

Puisque les nœuds personnalisés sont en mesure de mapper différents types de courbes, ce dernier fichier fait référence à un fichier SVG exporté à partir d’Illustrator et mappe les courbes importées avec une surface cible.

L’analyse de la syntaxe d’un fichier .svg permet de convertir les courbes au format .xml en polycourbes Dynamo.

Les courbes importées sont mappées avec une surface cible. Cela vous permet de concevoir de manière explicite (pointer-cliquer) une contruction de panneaux dans Illustrator, de l’importer dans Dynamo et de l’appliquer à une surface cible.

Le package Dynamo Mesh Toolkit fournit des outils permettant d'importer des maillages à partir de formats de fichiers externes, de créer un maillage à partir d'objets de géométrie Dynamo et de créer manuellement des maillages à partir de leurs sommets et index. La bibliothèque fournit également des outils permettant de modifier et de réparer les maillages, ainsi que d’extraire des sections horizontales à utiliser lors de la fabrication.

Le package Dynamo Mesh Toolkit s’inscrit dans le cadre des recherches en cours d’Autodesk sur les maillages, et il continuera à évoluer au cours des prochaines années. Attendez-vous à voir apparaître fréquemment de nouvelles méthodes applicables à ce package, et n'hésitez pas à faire parvenir à l'équipe de Dynamo vos commentaires, bogues et suggestions en vue d'intégrer de nouvelles fonctionnalités.

Maillages et solides

L'exercice ci-dessous présente certaines opérations de maillage de base à l'aide de Mesh Toolkit. Dans l'exercice, nous allons entrecouper un maillage avec une série de plans, une opération qui peut s'avérer coûteuse en ressources informatiques si elle est effectuée avec des solides. Contrairement à un solide, un maillage a une « résolution » établie et n’est pas défini sur un plan mathématique, mais topologique. Cette résolution peut être définie sur la base de la tâche en cours. Pour plus d’informations sur les relations entre les maillages et les solides, reportez-vous au chapitre Géométrie pour la conception informatique de ce guide. Pour en savoir plus sur le package Mesh Toolkit, vous pouvez consulter la page wiki de Dynamo. Nous allons aborder le package dans l’exercice ci-dessous.

Installation de Mesh Toolkit

Dans Dynamo, allez dans Packages > Gestionnaire de package... dans la barre de menu supérieure. Dans le champ de recherche, tapez MeshToolkit, en un mot. Cliquez sur Installer et confirmez pour lancer le téléchargement. C’est aussi simple que ça !

Exercice : Entrecouper le maillage

Téléchargez le fichier d’exemple en cliquant sur le lien ci-dessous.

Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Dans cet exemple, nous allons examiner le nœud Intersect dans Mesh Toolkit. Nous allons importer un maillage et l'entrecouper avec une série de plans d'entrée pour créer des sections. Il s’agit du point de départ pour préparer le modèle pour la fabrication sur un découpeur au laser, une machine de coupe à jet d’eau ou une fraiseuse commandée par ordinateur.

Commencez par ouvrir Mesh-Toolkit_Intersect-Mesh.dyn dans Dynamo.

1. Chemin d’accès au fichier : recherchez le fichier de maillage à importer (stanford_bunny_tri.obj). Les types de fichiers pris en charge sont .mix et .obj.

2. Mesh.ImportFile : associez le chemin d’accès au fichier pour importer le maillage.

1. Point.ByCoordinates : crée un point. Il s’agit du centre d’un arc.

2. Arc.ByCenterPointRadiusAngle : crée un arc autour du point. Cette courbe sera utilisée pour positionner une série de plans. __ Les paramètres sont les suivants : __ radius: 40, startAngle: -90, endAngle:0

Créez une série de plans orientés le long de l’arc.

1. Code Block : créez 25 nombres compris entre 0 et 1.

2. Curve.PointAtParameter : connectez l’arc à l’entrée « curve » et le bloc de code de sortie à l’entrée « param » pour extraire une série de points le long de la courbe.

3. Curve.TangentAtParameter : connectez les mêmes entrées que le nœud précédent.

4. Plan.ByOriginNormal : connectez les points à l’entrée « origin » et les vecteurs à l’entrée « normal » pour créer une série de plans à chaque point.

Vous allez ensuite utiliser ces plans pour entrecouper le maillage.

1. Mesh.Intersect : entrecoupez les plans avec le maillage importé, ce qui crée une série de contours de polycourbe. Cliquez avec le bouton droit de la souris sur Nœud et définissez la liaison sur la plus longue.

2. PolyCurve.Curves : divisez les polycourbes en fragments de courbe.

3. Curve.EndPoint : extrayez les points de fin de chaque courbe.

4. NurbsCurve.ByPoints : utilisez les points pour construire une courbe Nurbs. Utilisez un nœud booléen défini sur Vrai (True) pour fermer les courbes.

Avant de continuer, désactivez l’aperçu de certains nœuds, tels que Mesh.ImportFile, Curve.EndPoint, Plane.ByOriginNormal et Arc.ByCenterPointRadiusAngle, pour mieux voir le résultat.

1. Surface.ByPatch : créez des corrections de surface pour chaque contour afin de créer des « sections » du maillage.

Ajoutez un deuxième jeu de sections pour un effet gaufré/alvéolé.

Vous avez peut-être remarqué que les opérations d’intersection sont calculées plus rapidement avec un maillage plutôt qu’avec un solide comparable. Les workflows tels que ceux présentés dans cet exercice se prêtent bien à l'utilisation de maillages.

Vous venez de créer un nœud personnalisé et de l'appliquer à un processus spécifique dans le graphique Dynamo. Vous souhaitez en outre conserver ce nœud dans la bibliothèque Dynamo pour établir des références à d'autres graphiques. Pour ce faire, vous allez publier le nœud localement. Cette procédure est semblable à celle utilisée pour publier un package, que vous verrez plus en détail dans le chapitre suivant.

Avec la publication locale, le nœud sera accessible dans votre bibliothèque Dynamo lorsque vous ouvrirez une nouvelle session. Si le nœud n’est pas publié, un graphique Dynamo qui fait référence à un nœud personnalisé doit également comporter ce nœud personnalisé dans son dossier (ou le nœud personnalisé doit être importé dans Dynamo à l’aide de l’option Fichier > Importer une bibliothèque).

Exercice : Publication locale d’un nœud personnalisé

Téléchargez le fichier d’exemple en cliquant sur le lien ci-dessous.

Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Nous allons avancer à l'aide du nœud personnalisé que vous avez créé dans la section précédente. Une fois le nœud PointsToSurface personnalisé ouvert, le graphique s’affiche dans l’éditeur de nœuds personnalisés Dynamo. Vous pouvez également ouvrir un nœud personnalisé en double-cliquant dessus dans l’éditeur graphique Dynamo.

Pour publier un nœud personnalisé localement, cliquez simplement avec le bouton droit de la souris sur la zone de dessin et choisissez « Publier ce nœud personnalisé… ».

Remplissez les informations pertinentes comme dans l’image ci-dessus et choisissez « Publier localement » Notez que le champ Groupe définit l’élément principal accessible à partir du menu Dynamo.

Choisissez un dossier pour héberger tous les nœuds personnalisés que vous envisagez de publier localement. Dynamo consultera ce dossier à chaque chargement. Par conséquent, assurez-vous que le dossier réside dans un emplacement permanent. Accédez à ce dossier et choisissez « Sélectionner un dossier ». Votre nœud Dynamo est désormais publié localement et restera dans votre bibliothèque Dynamo chaque fois que vous chargez le programme.

Pour vérifier l’emplacement du dossier de nœud personnalisé, accédez à Dynamo > Préférences > Paramètres de package > Chemins d’accès de nœud et de package

Cette fenêtre contient une liste de chemins.

1. Documents\DynamoCustomNodes… fait référence à l’emplacement des nœuds personnalisés publiés localement.

2. AppData\Roaming\Dynamo… fait référence à l’emplacement par défaut des packages Dynamo installés en ligne.

3. Vous pouvez déplacer le chemin du dossier local vers le bas dans l’ordre de la liste (en cliquant sur la flèche vers le bas située à gauche des noms de chemin). Le dossier racine est le chemin par défaut des installations de package. Ainsi, en conservant le chemin d'installation par défaut du package Dynamo comme dossier par défaut, les packages en ligne sont séparés des nœuds publiés localement.

Nous avons changé l’ordre des noms de chemin pour que le chemin par défaut de Dynamo devienne l’emplacement d’installation du package.

En accédant à ce dossier local, vous trouvez le nœud personnalisé d’origine dans le dossier « .dyf », qui est l’extension d’un fichier de nœud personnalisé Dynamo. Vous pouvez modifier le fichier dans ce dossier et le nœud sera mis à jour dans l’interface utilisateur. Vous pouvez également ajouter des nœuds au dossier DynamoCustomNode principal et Dynamo les ajoutera à votre bibliothèque au redémarrage.

Dynamo se charge désormais à chaque fois avec « PointsToSurface » dans le groupe « DynamoPrimer » de votre bibliothèque Dynamo.

Dynamo offre un grand nombre de fonctionnalités prêtes à l’emploi et dispose également d’une bibliothèque de packages complète qui permet d’étendre considérablement les capacités de Dynamo. Un package est un ensemble de nœuds personnalisés ou de fonctionnalités supplémentaires. Le gestionnaire de package Dynamo est un portail permettant à la communauté de télécharger tout package publié en ligne. Ces jeux d’outils sont développés par des tiers afin d’étendre les fonctionnalités clés de Dynamo, accessibles à tous, et prêts à être téléchargés en un clic.

Un projet Open Source comme Dynamo s’appuie sur ce type d’implication de la communauté. Avec ses développeurs tiers dédiés, Dynamo peut étendre sa portée aux workflows dans différents secteurs d’activité. Par conséquent, l'équipe de Dynamo a entrepris de rationaliser le développement et la publication des packages (sujets abordés plus en détail dans les sections suivantes).

Installation d’un package

La méthode la plus simple pour installer un package consiste à utiliser l’option de menu Packages de l’interface Dynamo. Passez à présent au vif du sujet et installez un package. Dans cet exemple rapide, vous allez installer un package très utilisé pour créer des panneaux quadrilatéraux sur une grille.

Dans Dynamo, accédez à Packages > Gestionnaire de package...

Dans la barre de recherche, recherchez « quadrilatères à partir de la grille rectangulaire ». Au bout de quelques instants, l'ensemble des packages correspondants à cette demande de recherche apparaissent. Sélectionnez le premier package avec le nom correspondant.

Cliquez sur Installer pour ajouter ce package à votre bibliothèque, puis acceptez la confirmation. Terminé !

Vous avez maintenant un autre groupe appelé « buildz » dans la bibliothèque Dynamo. Son nom fait référence au développeur du package. Le nœud personnalisé est placé dans ce groupe. Vous pouvez commencer à l’utiliser immédiatement.

Utilisez un nœud Code Blockpour définir rapidement une grille rectangulaire, générer le résultat sur un nœud Polygon.ByPoints, puis sur un nœud Surface.ByPatch pour afficher la liste des panneaux rectangulaires que vous venez de créer.

Installation du dossier de package – DynamoUnfold

L'exemple ci-dessus est axé sur un package avec un nœud personnalisé, mais vous utilisez le même processus pour télécharger des packages avec plusieurs nœuds personnalisés et des fichiers de données de prise en charge. Démontrez-le maintenant avec un package plus complet : Dynamo Unfold.

Comme dans l’exemple ci-dessus, commencez par sélectionner Packages > Gestionnaire de package...

Cette fois, recherchez « DynamoUnfold », en un mot. Lorsque les packages s’affichent, cliquez sur Installer pour ajouter Dynamo Unfold à votre bibliothèque Dynamo.

La bibliothèque Dynamo contient un groupe DynamoUnfold avec plusieurs catégories et nœuds personnalisés.

Examinez maintenant la structure de fichiers du package.

1. Tout d’abord, accédez à Packages > Gestionnaire de package > Packages installés.

3. Cliquez ensuite sur Afficher le répertoire racine pour ouvrir le dossier racine de ce package.

Cette action permet d’accéder au répertoire racine du package. Il contient trois dossiers et un fichier.

1. Le dossier bin contient les fichiers .dll. Ce package Dynamo a été développé à l’aide de la commande Zero Touch, de sorte que les nœuds personnalisés sont conservés dans ce dossier.

2. Le dossier dyf contient les nœuds personnalisés. Ce package n’a pas été développé à l’aide de nœuds personnalisés Dynamo. Ce dossier est donc vide pour ce package.

3. Le dossier supplémentaire contient tous les fichiers supplémentaires, y compris les fichiers d'exemple.

4. Le fichier pkg est un fichier texte de base qui définit les paramètres du package. Pour l'instant, vous pouvez l'ignorer.

Lorsque vous ouvrez le dossier "extra", vous découvrez la présence de fichiers d'exemple téléchargés lors de l'installation. Les packages ne possèdent pas tous des fichiers d'exemple, mais lorsque ces derniers font partie d'un package, ils sont enregistrés ici.

Ouvrez « SphereUnfold ».

Après avoir ouvert le fichier et cliqué sur « Exécuter » dans le solveur, vous obtenez une sphère dépliée. Les fichiers d’exemple comme ceux-ci sont utiles pour apprendre à utiliser un nouveau package Dynamo.

Parcourir et afficher les informations sur le package

Dans le gestionnaire de package, vous pouvez rechercher des packages à l’aide des options de tri et de filtrage de l’onglet Rechercher des packages. Plusieurs filtres sont disponibles pour le programme hôte, l’état (nouveau, obsolète ou non obsolète) et si le package possède des dépendances.

En triant les packages, vous pouvez identifier les packages les mieux notés ou les plus téléchargés, ou trouver les packages ayant fait l’objet de mises à jour récentes.

Vous pouvez également obtenir plus de détails sur chaque paquet en cliquant sur Afficher les détails. Cela ouvre un panneau latéral dans le Gestionnaire de package, où vous pouvez trouver des informations telles que la version et les dépendances, l’URL du site Web ou du dépôt, les informations sur la licence, etc.

Site Web du gestionnaire de package Dynamo

Où sont les fichiers de package stockés localement ?

Si vous souhaitez voir où vos fichiers de package sont conservés, dans la barre de navigation supérieure, cliquez sur Dynamo > Préférences > Paramètres de package > Emplacement des fichiers de nœuds et de packages. Vous pouvez trouver le répertoire de votre dossier racine actuel à partir d’ici.

Par défaut, les packages sont installés dans un emplacement semblable à celui du dossier suivant : C:/Utilisateurs/[nom d’utilisateur]/AppData/Itinérance/Dynamo/[Version Dynamo].

Repousser les limites des packages

La communauté Dynamo est en constante évolution. Explorez le gestionnaire de package Dynamo de temps en temps : vous y découvrirez de nouvelles avancées intéressantes. Dans les sections suivantes, vous allez examiner les packages de manière plus approfondie, du point de vue de l'utilisateur final à la création de votre propre package Dynamo.

Dans les sections précédentes, vous avez découvert en détail comment configurer le package MapToSurface avec des nœuds personnalisés et des fichiers d’exemple. Mais comment publier un package développé localement ? Cette étude de cas montre comment publier un package à partir d’un ensemble de fichiers dans un dossier local.

Il existe plusieurs façons de publier un package. Voici le processus recommandé :publier localement, développer localement, puis publier en ligne. Vous allez commencer par un dossier contenant tous les fichiers du package.

Désinstallation d'un package

Avant de commencer la publication du package MapToSurface, si vous avez installé le package à partir de la leçon précédente, désinstallez-le afin de ne pas utiliser les mêmes packages.

Commencez par aller dans Packages > Gestionnaire de package > onglet Packages installés > à côté de MapToSurface, cliquez sur le menu des points verticaux > Supprimer.

Ensuite, redémarrez Dynamo. Lors de la réouverture, vérifiez la fenêtre « Gérer les packages » : le package MapToSurface ne doit plus être présent. Vous pouvez désormais commencer !

Publication locale d’un package

Téléchargez le fichier d’exemple en cliquant sur le lien ci-dessous.

Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Il s'agit de la première soumission du package, et tous les fichiers d'exemple et les nœuds personnalisés sont placés dans un dossier unique. Maintenant que ce dossier est prêt, vous pouvez effectuer le chargement dans le gestionnaire de package Dynamo.

1. Ce dossier contient cinq nœuds personnalisés (.dyf).

2. Ce dossier contient également cinq fichiers d'exemple (.dyn) et un fichier vectoriel importé (.svg). Ces fichiers serviront d’exercices préliminaires pour montrer à l’utilisateur comment utiliser les nœuds personnalisés.

Dans Dynamo, commencez par cliquer sur l’onglet Packages > Gestionnaire de package > Publier un nouveau package.

Dans l’onglet Publier un package, remplissez les champs pertinents dans la partie gauche de la fenêtre.

Ensuite, nous allons ajouter des fichiers de package. Vous pouvez ajouter des fichiers un par un ou des dossiers entiers en sélectionnant Ajouter un répertoire (1). Pour ajouter des fichiers qui ne sont pas des fichiers .dyf, veillez à modifier le type de fichier dans la fenêtre du navigateur en « Tous les fichiers(.) ». Notez que nous ajouterons chaque fichier, nœud personnalisé (.dyf) ou fichier d’exemple (.dyn), sans distinction. Dynamo classe ces éléments lors de la publication du package.

Une fois que vous avez sélectionné le dossier MapToSurface, le gestionnaire de package vous montre le contenu du dossier. Si vous chargez votre propre package avec une structure de dossiers complexe, et que vous ne voulez pas que Dynamo apporte des changements à votre structure de dossiers, vous pouvez cocher la case « Conserver la structure des dossiers ». Cette option est destinée aux utilisateurs avancés, et si votre package n’est pas délibérément configuré d’une manière spécifique, il est préférable de laisser cette option désactivée et de permettre à Dynamo d’organiser les fichiers selon les besoins. Cliquez sur Suivant pour continuer.

Ici, vous avez la possibilité de voir comment Dynamo organisera vos fichiers de package avant de les publier. Cliquez sur Terminer pour continuer.

Publiez en cliquant sur « Publier localement » (1). Si vous suivez, veillez à cliquer sur « Publier localement » et non « Publier en ligne » pour éviter d’avoir un groupe de packages en double dans le gestionnaire de package.

Une fois la publication terminée, les nœuds personnalisés doivent être disponibles sous le groupe « DynamoPrimer » ou votre bibliothèque Dynamo.

Examinez maintenant le répertoire racine pour découvrir comment Dynamo a mis en forme le package créé. Pour ce faire, allez dans l’onglet Packages installés > à côté de MapToSurface, cliquez sur le menu des points verticaux > sélectionnez Afficher le répertoire racine.

Le répertoire racine se trouve à l’emplacement local de votre package (n’oubliez pas que vous avez publié le package « localement »). Dynamo utilise actuellement ce dossier pour lire les nœuds personnalisés. Il est donc important de publier localement le répertoire dans un emplacement permanent (par exemple, pas sur votre bureau). Voici la répartition du dossier du package Dynamo :

1. Le dossier bin contient les fichiers .dll créés avec des bibliothèques C# ou Zero Touch. Étant donné qu’il n’en existe pas pour ce package, ce dossier est vide pour cet exemple.

2. Le dossier dyf contient les nœuds personnalisés. L’ouverture de ce dossier permet d’afficher tous les nœuds personnalisés (fichiers .dyf) de ce package.

3. Le dossier supplémentaire contient tous les fichiers supplémentaires. Il est probable que ces fichiers soient des fichiers Dynamo (.dyn) ou d'autres fichiers requis (.svg, .xls, .jpeg, .sat, etc.).

4. Le fichier pkg est un fichier texte de base qui définit les paramètres du package. Cette opération est automatisée dans Dynamo, mais elle peut être modifiée si vous souhaitez obtenir des détails.

Publication d’un package en ligne

1. Lorsque vous êtes prêt à publier, dans la fenêtre Packages > Gestionnaire de package > Packages installés, sélectionnez le bouton situé à droite du package que vous souhaitez publier et choisissez Publier.

2. Si vous mettez à jour un package qui a déjà été publié, choisissez « Publier la version » et Dynamo mettra à jour votre package en ligne en fonction des nouveaux fichiers contenus dans le répertoire racine de ce package. C'est aussi simple que ça !

Version de publication…

Lorsque vous mettez à jour les fichiers dans le dossier racine de votre package publié, vous pouvez également publier une nouvelle version du package en sélectionnant « Publier la version… » dans l’onglet Mes packages. Cette méthode vous permet d’apporter les mises à jour nécessaires à votre contenu et de le partager en toute transparence avec la communauté. La version de publication fonctionne uniquement si vous êtes le gestionnaire du package.

Qu'est-ce que le Zero Touch ?

L’importation Zero Touch fait référence à une méthode pointer-cliquer simple permettant d’importer des bibliothèques C#. Dynamo lit les méthodes publiques d’un fichier .dll et les convertit en nœuds Dynamo. Vous pouvez utiliser le Zero Touch pour développer vos propres nœuds et packages personnalisés, et importer des bibliothèques externes dans l’environnement Dynamo.

1. fichiers .dll

2. Nœuds Dynamo

Le Zero Touch vous permet d'importer une bibliothèque qui n'a pas été nécessairement développée pour Dynamo, et de créer une suite de nouveaux nœuds. La fonctionnalité Zero Touch actuelle montre le caractère multi-plateforme du projet Dynamo.

Cette section explique comment utiliser le Zero Touch pour importer une bibliothèque tierce. Pour plus d’informations sur le développement de votre propre bibliothèque Zero Touch, consultez la page wiki de Dynamo.

Packages Zero Touch

Les packages Zero Touch sont un complément utile aux nœuds personnalisés définis par l'utilisateur. Le tableau ci-dessous présente quelques packages qui utilisent des bibliothèques C#. Pour plus d’informations sur les packages, consultez la section Packages de l’annexe.

Étude de cas - Importation AForge

Dans cette étude de cas, vous découvrirez comment importer la bibliothèque .dll externe AForge. AForge est une bibliothèque robuste qui offre une gamme de fonctionnalités allant du traitement d’images à l’intelligence artificielle. Vous allez utiliser la classe d'images dans AForge pour effectuer quelques exercices de traitement d'images ci-dessous.

Tout d’abord, téléchargez AForge. Sur la page de téléchargement AForge, sélectionnez [Download Installer] (Télécharger le programme d’installation). À l’issue du téléchargement, effectuez l’installation.

Dans Dynamo, créez un fichier et sélectionnez Fichier > Importer une bibliothèque

Recherchez ensuite le fichier dll.

1. Dans la fenêtre contextuelle, accédez au dossier de version de l’installation AForge. Il se trouve probablement dans un dossier semblable à celui-ci : C:\Program Files (x86)\AForge.NET\Framework\Release.

2. AForge.Imaging.dll : pour cette étude de cas, utilisez uniquement ce fichier de la bibliothèque AForge. Sélectionnez ce fichier .dll et cliquez sur « Ouvrir ».

De retour dans Dynamo, un groupe de nœuds AForge doit apparaître dans la barre d’outils de la bibliothèque. Vous avez désormais accès à la bibliothèque d’images AForge à partir du programme visuel.

Exercice 1 - Détection des arêtes

Téléchargez le fichier d’exemple en cliquant sur le lien ci-dessous.

Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Maintenant que la bibliothèque a été importée, commencez simplement par le premier exercice (01-EdgeDetection.dyn). Vous effectuerez quelques traitements d’images de base sur une image d’exemple pour découvrir comment les filtres d’images AForge sont appliqués. Vous allez utiliser le nœud « Watch Image » pour afficher les résultats et appliquer dans Dynamo des filtres semblables à ceux de Photoshop.

Pour importer une image, ajoutez un nœud File Path dans la zone de dessin et sélectionnez « soapbubbles.jpg » dans le dossier des exercices (crédit photo : flickr).

Le nœud File Path fournit simplement une chaîne du chemin d’accès à l’image sélectionnée. Vous devez ensuite le convertir en fichier image utilisable dans Dynamo.

1. Utilisez le nœud File From Path pour convertir le chemin d’accès au fichier en image dans l’environnement Dynamo.

2. Connectez le nœud File Path au nœud File.FromPath.

3. Pour convertir ce nœud File Path en image, utilisez le nœud Image.ReadFromFile.

4. Enfin, découvrez le résultat ! Déposez un nœud Watch Image sur la zone de dessin et connectez-vous à Image.ReadFromFile. Vous n’avez pas encore utilisé AForge, mais vous avez importé une image dans Dynamo.

Sous AForge.Imaging.AForge.Imaging.Filters (dans le menu de navigation), un large éventail de filtres est disponible. Vous allez utiliser l’un de ces filtres pour désaturer une image en fonction des valeurs de seuil.

1. Déposez trois curseurs sur la zone de dessin, modifiez leur intervalle pour qu’il soit compris entre 0 et 1 et leur valeur de pas pour qu’elle soit de 0.01.

2. Ajoutez le nœud Grayscale.Grayscale à la zone de dessin. Il s’agit d’un filtre AForge qui applique un filtre de nuances de gris à une image. Connectez les trois curseurs de l'étape 1 à cr, cg et cb. Définissez la valeur des curseurs supérieur et inférieur sur 1 et celle du curseur central sur 0.

3. Pour appliquer le filtre Nuances de gris, vous devez effectuer une action sur l’image. Pour ce faire, utilisez BaseFilter.Apply. Connectez l’image à l’entrée de l’image et Grayscale.Grayscale à l’entrée baseFilter.

4. Lorsque vous connectez le nœud Watch Image, vous obtenez une image désaturée.

Vous pouvez contrôler la désaturation de cette image en fonction des valeurs de seuil pour le rouge, le vert et le bleu. Ces paramètres sont définis par les entrées du nœud Grayscale.Grayscale. L’image semble assez sombre, car la valeur du vert est définie sur 0 dans le curseur.

1. Définissez la valeur des curseurs supérieur et inférieur sur 0 et celle du curseur central sur 1. De cette manière, vous obtenez une image désaturée plus lisible.

Utilisez l'image désaturée et appliquez-lui un autre filtre. Étant donné que l’image désaturée est un peu contrastée, testez la détection des arêtes.

1. Ajoutez un nœud SobelEdgeDetector.SobelEdgeDetector à la zone de dessin.

2. Connectez-le au nœud BaseUsingCopyPartialFilter.Apply et connectez l’image désaturée à l’entrée d’image de ce nœud.

3. Le filtre de détection d’arêtes Sobel a mis en surbrillance les arêtes dans une nouvelle image.

En zoomant, on constate que le filtre de détection d'arêtes a appelé les contours des bulles avec des pixels. La bibliothèque AForge contient des outils permettant de prendre des résultats similaires et de créer une géométrie Dynamo. Vous allez explorer ce point dans le prochain exercice.

Exercice 2 - Création de rectangles

Maintenant que vous avez découvert le traitement d’images de base, vous allez utiliser une image pour piloter la géométrie Dynamo. Dans le cadre d’un exercice élémentaire, réalisez un tracé en direct d’une image à l’aide d’AForge et de Dynamo. Pour rester simple, vous allez extraire des rectangles d’une image de référence. Cependant, AForge propose des outils permettant d’effectuer des opérations plus complexes. Vous allez travailler avec 02-RectangleCreation.dyn à partir des fichiers d’exercice téléchargés.

1. À l’aide du nœud File Path, accédez au fichier grid.jpg dans le dossier des exercices.

2. Connectez les séries de nœuds restantes ci-dessus pour afficher une grille paramétrique de parcours.

Dans cette étape, vous allez référencer les carrés blancs de l’image et les convertir en géométrie Dynamo réelle. AForge dispose d’un grand nombre d’outils puissants de vision par ordinateur. Ici, vous allez utiliser un outil particulièrement important pour la bibliothèque appelé BlobCounter.

1. Après avoir ajouté un outil BlobCounter à la zone de dessin, vous devez procéder au traitement de l’image (de la même façon qu’avec l’outil BaseFilter.Apply dans l’exercice précédent).

Malheureusement, le nœud « Process Image » n’est pas immédiatement visible dans la bibliothèque Dynamo. Cela est dû au fait que la fonction n'est peut-être pas visible dans le code source AForge. Pour résoudre ce problème, vous devez trouver une solution.

1. Ajoutez un nœud Python à la zone de dessin et ajoutez le code suivant au nœud Python. Ce code importe la bibliothèque AForge, puis traite l'image importée.

import sys
import clr
clr.AddReference('AForge.Imaging')
from AForge.Imaging import *

bc= BlobCounter()
bc.ProcessImage(IN[0])
OUT=bc

Lorsque vous connectez la sortie de l’image à l’entrée du nœud Python, vous obtenez un résultat AForge.Imaging.BlobCounter à partir du nœud Python.

Les étapes suivantes vous montreront quelques astuces pour vous permettre de vous familiariser avec l’API AForge Imaging. Il n’est pas nécessaire de savoir faire tout ça pour travailler sur Dynamo. Cette démonstration sert davantage à montrer l’utilisation de bibliothèques externes au sein de l’environnement Dynamo.

1. Connectez la sortie du script Python à BlobCounterBase.GetObjectRectangles. Cette opération permet de lire les objets d’une image, en fonction d’une valeur de seuil, et d’extraire les rectangles quantifiés de l’espace de pixel.

1. Ajoutez un autre nœud Python à la zone de dessin, connectez-vous à GetObjectRectangles et entrez le code ci-dessous. Cela permet de créer une liste organisée d’objets Dynamo.

OUT = []
for rec in IN[0]:
	subOUT=[]
	subOUT.append(rec.X)
	subOUT.append(rec.Y)
	subOUT.append(rec.Width)
	subOUT.append(rec.Height)
	OUT.append(subOUT)

1. Transposez la sortie du nœud Python de l’étape précédente. Cela crée 4 listes, chacune représentant X, Y, Largeur et Hauteur pour chaque rectangle.

2. À l'aide d'un bloc de code, organisez les données dans une structure qui s'adapte au nœud Rectangle.ByCornerPoints (code ci-dessous).

recData;
x0=List.GetItemAtIndex(recData,0);
y0=List.GetItemAtIndex(recData,1);
width=List.GetItemAtIndex(recData,2);
height=List.GetItemAtIndex(recData,3);
x1=x0+width;y1=y0+height;
p0=Autodesk.Point.ByCoordinates(x0,y0);
p1=Autodesk.Point.ByCoordinates(x0,y1);
p2=Autodesk.Point.ByCoordinates(x1,y1);
p3=Autodesk.Point.ByCoordinates(x1,y0);

En faisant un zoom arrière, vous obtenez un réseau de rectangles représentant les carrés blancs de l’image. Grâce à la programmation, vous avez fait quelque chose qui ressemble à un tracé en direct dans Illustrator !

Vous devez néanmoins effectuer un peu de nettoyage. En zoomant, vous pouvez voir que vous avez un petit groupe de rectangles non souhaités.

Ensuite, vous allez écrire des codes pour éliminer les rectangles indésirables.

1. Insérez un nœud Python entre le nœud GetObjectRectangles et un autre nœud Python. Le code du nœud est indiqué ci-dessous. Il supprime tous les rectangles dont la taille est inférieure à la taille définie.

rectangles=IN[0]
OUT=[]
for rec in rectangles:
 if rec.Width>8 and rec.Height>8:
  OUT.append(rec)

Après avoir supprimé les rectangles superflus, vous pouvez créer une surface à partir de ces rectangles et les extruder d’une distance basées sur leurs zones.

Enfin, définissez l’entrée both_sides sur Faux (False). Vous obtenez une extrusion dans une direction. Votre création est maintenant prête à devenir une super table de geek.

Ce sont des exemples de base, mais les concepts présentés ici sont transférables à des applications réelles passionnantes. La vision par ordinateur peut être utilisée pour une multitude de processus. En voici quelques-uns : lecteurs de codes-barres, mise en correspondance des perspectives, mappage de projection et réalité augmentée. Pour les rubriques plus avancées ayant trait à AForge dans le cadre de cet exercice, lisez cet article.