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.
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.
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.
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é.
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é.
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.
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.
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.
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.
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.
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.
À 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.
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.
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.
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.
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.
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 !
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.
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.
Mesh.ImportFile : associez le chemin d’accès au fichier pour importer le maillage.
Point.ByCoordinates : crée un point. Il s’agit du centre d’un arc.
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.
Code Block : créez 25 nombres compris entre 0 et 1.
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.
Curve.TangentAtParameter : connectez les mêmes entrées que le nœud précédent.
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.
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.
PolyCurve.Curves : divisez les polycourbes en fragments de courbe.
Curve.EndPoint : extrayez les points de fin de chaque courbe.
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.
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.
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.
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 !
Vous pouvez publier des nœuds et des packages personnalisés à partir de Dynamo Sandbox dans la version 2.17 et les versions ultérieures, tant qu’ils n’ont pas de dépendances de l’API hôte. Dans les versions plus anciennes, la publication de nœuds et de packages personnalisés n’est possible que dans Dynamo for Revit et Dynamo for Civil 3D.
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.
Ce dossier contient cinq nœuds personnalisés (.dyf).
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 :
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.
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.
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.).
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.
Remarque : ne suivez pas cette étape, sauf si vous publiez réellement un package de votre choix.
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.
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 !
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.
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.
fichiers .dll
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.
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.
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.
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.
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.
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.
Utilisez le nœud File From Path pour convertir le chemin d’accès au fichier en image dans l’environnement Dynamo.
Connectez le nœud File Path au nœud File.FromPath.
Pour convertir ce nœud File Path en image, utilisez le nœud Image.ReadFromFile.
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.
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.
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.
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.
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.
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.
Ajoutez un nœud SobelEdgeDetector.SobelEdgeDetector à la zone de dessin.
Connectez-le au nœud BaseUsingCopyPartialFilter.Apply et connectez l’image désaturée à l’entrée d’image de ce nœud.
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.
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.
À l’aide du nœud File Path, accédez au fichier grid.jpg dans le dossier des exercices.
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.
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.
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.
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.
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.
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.
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.
À 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).
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.
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.
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.
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).
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.
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.
Tout d’abord, accédez à Packages > Gestionnaire de package > Packages installés.
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.
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.
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.
Le dossier supplémentaire contient tous les fichiers supplémentaires, y compris les fichiers d'exemple.
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.
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.
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].
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.
À côté de DynamoUnfold, sélectionnez le menu d’options .
Une autre façon de découvrir les packages Dynamo est d’explorer le site Web du . Vous y trouverez des statistiques sur les packages et les classements des auteurs. Vous pouvez également télécharger les fichiers de package à partir du gestionnaire de package Dynamo, mais le processus de Dynamo est plus simple.
Logo/Image
Nom
