Ce guide comprend des chapitres développés avec Mode Lab. Ces chapitres portent sur les bases essentielles pour développer vos propres programmes visuels avec Dynamo et les principales connaissances sur la façon d’améliorer Dynamo.

Manuel d’utilisation du guide

Ce guide s’adresse à des lecteurs de différents milieux et niveaux de compétences. Les sections suivantes présentent de manière générale la configuration de Dynamo, l’interface utilisateur et les concepts clés. Nous recommandons aux nouveaux utilisateurs de se pencher sur les rubriques suivantes :

• Qu’est-ce que Dynamo et comment fonctionne-t-il ?

• Configuration de Dynamo

• Interface utilisateur

• Nœuds et fils

Si vous souhaitez mieux comprendre chaque élément comme un nœud spécifique et le concept de base, les fondamentaux sont abordés dans un chapitre à part.

• Nœuds et concepts essentiels

Pour découvrir la démonstration des workflows Dynamo, consultez les graphiques illustrés dans la section Exemples de workflows. Suivez les instructions ci-jointes pour créer vos propres graphiques Dynamo.

• Vase paramétrique

• Points d’attraction

Communauté

Dynamo ne serait pas ce qu’il est sans un groupe d’utilisateurs passionnés et de contributeurs actifs. Interagissez avec la communauté en suivant le blog, en ajoutant votre travail à la galerie ou en discutant de Dynamo sur le forum.

Plate-forme

Dynamo est conçu comme un outil de programmation visuelle pour les concepteurs, qui permet de créer des outils qui utilisent des bibliothèques externes ou tout produit Autodesk doté d'une API. Avec Dynamo Sandbox, vous pouvez développer des programmes dans une application de type "Sandbox", mais l’écosystème Dynamo continue de se développer.

Le code source du projet est ouvert, ce qui vous permet d'étendre ses fonctionnalités comme bon vous semble. Consultez le projet sur GitHub et parcourez les travaux en cours des utilisateurs qui personnalisent Dynamo.

Naviguez dans Dynamo, créez un fork et étendez ses fonctionnalités selon vos besoins.

Aperçu de l'interface utilisateur

L’interface utilisateur de Dynamo est organisée en cinq zones principales. Nous allons faire ici une présentation succincte et expliquer plus en détail l’espace de travail et la bibliothèque dans les sections suivantes.

1. Menus

2. Barre d'outils

3. Bibliothèque

4. Espace de travail

5. Barre d’exécution

Menus

Voici les menus des fonctionnalités de base de l’application Dynamo. Comme la plupart des logiciels Windows, les deux premiers menus concernent la gestion des fichiers, les opérations de sélection et la modification du contenu. Les autres menus sont plus spécifiques de Dynamo.

Menus Dynamo

Des informations générales et des paramètres sont disponibles dans le menu déroulant Dynamo.

1. À propos de : découvrez la version de Dynamo installée sur votre ordinateur.

2. Accord sur la collecte des données d’utilisation : permet d’accepter ou de refuser le partage de vos données utilisateur pour améliorer Dynamo.

3. Préférences : inclut des paramètres tels que la précision décimale de l’application et la qualité du rendu de la géométrie.

4. Quitter Dynamo.

Aide

Si vous êtes bloqué, consultez le menu Aide. Vous pouvez accéder à l’un des sites Web de référence Dynamo via votre navigateur Internet.

1. Mise en route : brève introduction à l’utilisation de Dynamo.

2. Guides interactifs.

3. Échantillons : fichiers d'exemple de référence.

4. Dictionnaire Dynamo : ressource avec documentation sur tous les nœuds.

5. Site Web Dynamo : affichez le projet Dynamo sur GitHub.

6. Wiki du projet Dynamo : permet de consulter le wiki pour en savoir plus sur le développement à l’aide de l’API Dynamo, qui prend en charge les bibliothèques et les outils.

7. Afficher la page de démarrage : permet de revenir à la page de démarrage de Dynamo lorsque vous vous trouvez dans un document.

8. Signaler un bogue : permet d'ouvrir un problème sur GitHub.

Barre d’outils

La barre d'outils de Dynamo contient une série de boutons permettant d'accéder rapidement aux fichiers et aux commandes Annuler [Ctrl + Z] et Rétablir [Ctrl + Y]. À l’extrémité droite se trouve un autre bouton qui permet d’exporter un cliché de l’espace de travail, ce qui est extrêmement utile pour la documentation et le partage.

Bibliothèque

La bibliothèque Dynamo est un ensemble de bibliothèques fonctionnelles, chaque bibliothèque contenant des nœuds regroupés par catégorie. Elle se compose de bibliothèques de base qui sont ajoutées lors de l’installation par défaut de Dynamo. Au fur et à mesure de la présentation de son utilisation, vous allez découvrir comment étendre la fonctionnalité de base avec des nœuds personnalisés et d’autres packages. La section Bibliothèque fournit des instructions plus détaillées sur son utilisation.

Espace de travail

L’espace de travail est l’endroit où vous composez vos programmes visuels, vous pouvez également modifier son paramètre d’aperçu pour afficher les géométries 3D à partir d’ici. Pour plus d’informations, reportez-vous à Espace de travail.

Barre d’exécution

Exécutez votre script Dynamo à partir d’ici. Cliquez sur l’icône déroulante du bouton Exécution pour passer d’un mode à l’autre.

• Automatique : exécute votre script automatiquement. Les modifications sont mises à jour en temps réel.

• Manuel : le script s’exécute uniquement lorsque vous cliquez sur le bouton « Exécuter ». Utile pour modifier des scripts complexes.

• Périodique : cette option est grisée par défaut. Disponible uniquement lorsque le nœud DateTime.Now est utilisé. Vous pouvez définir l’exécution automatique du graphique à un intervalle spécifié.

Dynamo est une application de programmation visuelle qui peut être téléchargée et exécutée en mode « Sandbox » autonome ou en tant que plug-in pour d’autres logiciels tels que Revit, FormIt ou Civil 3D.

Processus

Dynamo vous permet de travailler au sein d’un processus de programmation visuelle dans lequel vous connectez des éléments pour définir les relations et les séquences d’actions qui composent les algorithmes personnalisés. Vous pouvez utiliser vos algorithmes pour un large éventail d’applications, du traitement de données à la génération de géométries, le tout en temps réel et sans avoir à écrire une ligne de code.

Connexion de nœuds et des fils

Les nœuds et les fils sont les composants clés de Dynamo qui prennent en charge un processus de programmation visuelle. Ils permettent d’établir des relations visuelles et systémiques solides entre les parties d’une conception. Utilisez la souris pour connecter les nœuds en toute simplicité lorsque vous développez et optimisez votre workflow de conception.

Quels sont les avantages de Dynamo ?

De l’utilisation de la programmation visuelle pour des workflows de projet au développement d’outils personnalisés, Dynamo est l’aspect essentiel d’une large gamme d’applications passionnantes.

Suivez le tableau Dynamo en action sur Pinterest.

Pour Dynamo v2.13 et plus récent

Dynamo est une plate-forme de programmation visuelle open source pour les concepteurs.

Bienvenue

Vous venez d’ouvrir le guide Dynamo, un guide complet de programmation visuelle dans Autodesk Dynamo. Ce guide est un projet en cours de partage des fondamentaux de la programmation. Les rubriques suivantes concernent l'utilisation de la géométrie de calcul, les recommandations pour la conception basée sur des règles, des applications de programmation pluridisciplinaires et plus encore, avec la plate-forme Dynamo.

La puissance de Dynamo est offerte par une large gamme d'activités liées à la conception. Dynamo vous offre une liste étendue de méthodes facilement accessibles pour commencer à utiliser les logiciels suivants :

• Découvrez la programmation visuelle

• Connectez les workflows de différents logiciels

• Interagissez avec une communauté active d'utilisateurs, de contributeurs et de développeurs

• Développez une plate-forme open source pour une amélioration continue

Dans le cadre de cette activité et de l'opportunité passionnante de travailler avec Dynamo, nous avons besoin d'un document du même calibre, le guide Dynamo.

Consultez le manuel d'utilisation du guide pour découvrir en quoi consiste le guide Dynamo.

Nous améliorons constamment Dynamo, c'est pourquoi certaines fonctionnalités peuvent sembler différentes de celles représentées dans ce guide. Toutefois, toutes les modifications apportées aux fonctionnalités seront correctement représentées.

Open Source

Le projet Dynamo Primer est open source. Nous nous efforçons de fournir du contenu de qualité et prenons en compte vos commentaires. Si vous souhaitez signaler un problème à un niveau quelconque, veuillez le publier sur la page des problèmes GitHub : https://github.com/DynamoDS/DynamoPrimer/issues

Si vous souhaitez contribuer à une nouvelle section, à des modifications ou à tout autre élément de ce projet, consultez le référentiel GitHub pour commencer : https://github.com/DynamoDS/DynamoPrimer.

Le projet Dynamo Primer

Le guide Dynamo est un projet open source, initié par Matt Jezyk et l’équipe de développement Dynamo chez Autodesk.

Mode Lab a été chargé d’écrire la première édition du guide. Nous remercions l’équipe pour tous ses efforts afin d’établir cette précieuse ressource.

John Pierson de Parallax Team a été chargé de mettre à jour le guide pour qu’il contienne les révisions de Dynamo 2.0.

Matterlab a été chargé de mettre à jour le guide pour refléter les révisions de Dynamo 2.13.

Archilizer a été chargé de mettre à jour le guide pour refléter les révisions de Dynamo 2.17.

Wood Rodgers a été chargé de mettre à jour le guide avec le contenu de Dynamo for Civil 3D.

Remerciements

Un grand merci à Ian Keough pour avoir lancé et dirigé le projet Dynamo.

Merci à Matt Jezyk, Ian Keough, Zach Kron, Racel Amour et Colin McCrone pour leur collaboration enthousiaste et pour l’opportunité de participer à un large éventail de projets Dynamo.

Logiciels et ressources

Dynamo Reportez-vous aux sites suivants pour la version stable la plus récente de Dynamo.

http://dynamobim.com/download/ ou http://dynamobuilds.com

*Remarque : à partir de Revit 2020, Dynamo est fourni avec les versions de Revit, ce qui fait que l'installation manuelle n'est pas requise. Pour plus d'informations, consultez ce billet de blog.

DynamoBIM La meilleure source d'informations supplémentaires, de contenu de formation et de forums est le site Web DynamoBIM.

http://dynamobim.org

Dynamo GitHub Dynamo est un projet de développement open source sur GitHub. Pour contribuer, découvrez DynamoDS.

https://github.com/DynamoDS/Dynamo

Contact Faites-nous part de tous les problèmes rencontrés dans ce document.

Dynamo@autodesk.com

Licence

Copyright 2023 Autodesk.

Autorisé par la Licence Apache, version 2.0 (la "Licence") ; vous ne devez utiliser ce fichier que conformément à la Licence. Vous pouvez obtenir une copie de la Licence à l'adresse

http://www.apache.org/licenses/LICENSE-2.0

Sauf si cela est requis par la loi applicable ou convenu par écrit, le logiciel distribué dans le cadre de la Licence est distribué "EN L'ÉTAT", SANS GARANTIES OU CONDITIONS D'AUCUNE SORTE, expresses ou implicites. Consultez la Licence pour connaître les autorisations et les limitations existant dans une langue spécifique dans le cadre de la Licence.

Depuis sa conception en tant que complément pour la modélisation des informations du bâtiment dans Revit, Dynamo a beaucoup évolué. Il s'agit principalement d'une plate-forme qui permet aux concepteurs d'explorer la programmation visuelle, de résoudre les problèmes et de créer leurs propres outils. Commençons notre exploration de Dynamo en définissant un contexte général : à quoi sert Dynamo et comment commencer à l’utiliser ?

Dynamo en tant qu’extension et Dynamo Sandbox

Dynamo est un projet de développement open source actif. Découvrez la liste des logiciels qui prennent en charge Dynamo.

Lancement de Dynamo en tant qu’extension

Dynamo est préinstallé avec des logiciels tels que Revit3D, FormIt, Civil3D, etc.

Pour plus d’informations sur l’utilisation de Dynamo avec un logiciel spécifique, consultez les sections suivantes :

• Dynamo pour Revit

• Dynamo for Civil 3D

Si vous souhaitez utiliser Dynamo en tant qu’application autonome. Continuez à lire pour obtenir des conseils sur le téléchargement du Dynamo Sandbox.

Obtenir Dynamo Sandbox

Télécharger

L’application Dynamo est disponible sur le site Web de Dynamo. Les versions officielles, antérieures ou pré-publiées sont disponibles sur la page de téléchargement. Visitez la page Obtenir Dynamo et cliquez sur Télécharger pour obtenir la version officielle.

Si vous recherchez des versions de développement précédentes ou les toutes dernières versions de développement, toutes les versions sont disponibles dans la section inférieure de la même page.

Décompresser

Avant de lancer une version que vous avez téléchargée, vous devez décompresser le contenu dans le dossier de votre choix.

Téléchargez et installez 7zip sur votre ordinateur pour cette étape.

Cliquez avec le bouton droit de la souris sur le fichier .zip et choisissez Extraire tout…

Choisissez une destination pour décompresser tous les fichiers.

Lancement

Dans le dossier de destination, double-cliquez sur DynamoSandbox.exe pour le lancer.

L’écran de démarrage de Dynamo Sandbox s’affiche comme suit.

Félicitations, vous avez terminé la configuration de Dynamo Sandbox !

La bibliothèque contient tous les nœuds chargés, y compris les nœuds de catégorie par défaut fournis avec l’installation, ainsi que tous les autres nœuds ou packages personnalisés chargés. Les nœuds de la bibliothèque sont organisés de manière hiérarchique dans les bibliothèques, les catégories et, le cas échéant, les sous-catégories.

• Nœuds de base : fournis avec l’installation par défaut.

• Nœuds personnalisés : stockez vos routines fréquemment utilisées ou votre graphique spécial en tant que nœuds personnalisés. Vous pouvez également partager vos nœuds personnalisés avec la communauté.

• Nœuds du gestionnaire de package : collection de nœuds personnalisés publiés.

Hiérarchie de la bibliothèque pour les catégories

Parcourir ces catégories est la manière la plus rapide de comprendre la hiérarchie des éléments que vous pouvez ajouter à votre espace de travail et la meilleure façon de découvrir les nouveaux nœuds que vous n'avez pas utilisés auparavant.

Parcourez la bibliothèque en cliquant sur les menus pour développer chaque catégorie et sa sous-catégorie.

1. Bibliothèque

2. Catégorie

3. Sous-catégorie

4. Nœud

Ces menus permettent de classer les nœuds dans la même sous-catégorie selon que les nœuds créent des données, exécutent une action ou interrogent des données.

Placez le curseur de la souris sur un nœud pour afficher des informations plus détaillées que son nom et son icône. Ces informations permettent de comprendre ce que fait le nœud, ce qu’il requiert pour les entrées et ce qu’il va donner en sortie.

1. Description : description du nœud en langage simple

2. Icône : version plus grande de l'icône dans le menu de la bibliothèque

3. Entrée(s) : nom, type de données et structure de données

4. Sortie(s) : type de données et structure

Recherche rapide dans la bibliothèque

Si vous avez une idée du nœud que vous souhaitez ajouter à votre espace de travail, faites une recherche dans le champ Rechercher pour rechercher tous les nœuds correspondants.

Cliquez sur le nœud que vous souhaitez ajouter ou appuyez sur la touche Entrée pour ajouter les nœuds mis en surbrillance au centre de l’espace de travail.

Recherche par hiérarchie

Outre l’utilisation de mots-clés pour rechercher des nœuds, vous pouvez saisir la hiérarchie en la séparant par un point dans le champ de recherche ou par des nœuds Code Block (qui utilisent le langage textuel Dynamo).

La hiérarchie de chaque bibliothèque est reflétée dans le nom des nœuds ajoutés à l’espace de travail.

La saisie de différentes parties de la position du nœud dans la hiérarchie de la bibliothèque au format library.category.nodeName renvoie différents résultats :

• library.category.nodeName

• category.nodeName

• nodeName ou keyword

En règle générale, le nom du nœud dans l’espace de travail est rendu au format category.nodeName, à quelques exceptions près, notamment dans les catégories Input et View.

Attention aux nœuds ayant un nom similaire et notez la différence de catégorie :

• Les nœuds de la plupart des bibliothèques incluent le format de catégorie.

• Les nœuds Point.ByCoordinates et UV.ByCoordinates portent le même nom, mais proviennent de différentes catégories.

• Les exceptions notables incluent les fonctions intégrées : Core.Input, Core.View et Operators.

Nœuds fréquemment utilisés

Compte tenu du fait que l’installation de base de Dynamo comprend des centaines de nœuds, quels nœuds sont essentiels au développement de programmes visuels ? Concentrez-vous sur ceux qui permettent de définir les paramètres de votre programme (Input), d’afficher les résultats de l’action d’un nœud (Watch) et de définir les entrées ou les fonctionnalités par le biais d’un raccourci (Code Block).

Nœuds d’entrée

Les nœuds Input sont les principaux moyens pour que l'utilisateur de votre programme visuel, que ce soit vous-même ou quelqu'un d'autre, interagisse avec les paramètres clés. En voici quelques-uns disponibles dans la bibliothèque principale :

Watch et Watch3D

Les nœuds Watch sont essentiels pour la gestion des données qui circulent dans votre programme visuel. Vous pouvez afficher le résultat d’un nœud dans l’aperçu des données de nœud en plaçant le curseur de la souris sur le nœud.

Il sera utile de l’afficher dans un nœud Watch

Vous pouvez également afficher les résultats de la géométrie à l’aide d’un nœud Watch3D.

Ces deux nœuds sont disponibles dans la catégorie View de la bibliothèque Core.

Code Block

Les nœuds Code Block servent à définir un bloc de code avec des lignes séparées par des points-virgules. Cela peut être aussi simple que X/Y.

Voici une démonstration simple (avec des instructions) de l’utilisation du nœud Code Block dans votre script.

1. Double-cliquez pour créer un nœud Code Block.

2. Circle.ByCenterPointRadius(x,y);Type

3. Cliquez sur l’espace de travail pour effacer la sélection et ajouter automatiquement les entrées x et y.

4. Créez les nœuds Point.ByCoordinates et Number Slider, puis connectez-les aux entrées du nœud Code Block.

5. Le résultat de l’exécution du programme visuel est affiché sous forme de cercle dans l’aperçu 3D.

Géométrie dans Dynamo Sandbox

La géométrie est le langage de conception. Lorsqu’un environnement ou un langage de programmation possède un noyau de géométrie, il est possible de concevoir des modèles précis et robustes, d’automatiser des routines de conception et de générer des itérations de conception avec des algorithmes.

La compréhension des types de géométrie et de leur relation vous permettra de naviguer dans l’ensemble des nœuds de géométrie disponibles dans la bibliothèque. Les nœuds de géométrie sont organisés par ordre alphabétique et non hiérarchisé. Ici, l’affichage des nœuds est similaire à leur présentation dans l’interface Dynamo.

De plus, la création de modèles dans Dynamo et la connexion de l’aperçu de ce qui est visible dans l’aperçu en arrière-plan avec le flux de données dans le graphique devraient devenir plus intuitives au fil du temps.

1. Observez le système de coordonnées spécifique rendu par la grille et les axes de couleur.

2. Les nœuds sélectionnés génèrent le rendu de la géométrie correspondante (si le nœud crée une géométrie) à l'arrière-plan (couleur de surbrillance).

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.

Le concept de géométrie

La géométrie, au sens traditionnel, est l'étude de la forme, de la taille, de la position relative des figures et des propriétés de l'espace. Ce domaine a un riche passé qui remonte à des milliers d'années. L'avènement et la popularisation de l'ordinateur ont permis d'acquérir un outil puissant permettant de définir, d'explorer et de générer de la géométrie. Calculer le résultat d’interactions géométriques complexes est devenu extrêmement facile. Le fait même de le faire est presque transparent.

Si vous souhaitez savoir comment une géométrie complexe et diversifiée peut exploiter la puissance de votre ordinateur, recherchez « lapin de Stanford » sur le Web. Il s’agit d’un modèle canonique utilisé pour tester les algorithmes.

Les algorithmes, les calculs et la complexité peuvent entraver la compréhension de la géométrie. Toutefois, il existe quelques principes clés, et relativement simples, que vous pouvez établir comme fondamentaux pour commencer à aller vers des applications plus avancées :

1. La géométrie représente des données : pour l’ordinateur et Dynamo, un lapin n’est pas si différent d’un nombre.

2. La géométrie repose sur une abstraction : les éléments géométriques sont essentiellement décrits par des nombres, des relations et des formules dans un système de coordonnées spatiales donné.

3. La géométrie possède une hiérarchie : les points sont assemblés pour créer des lignes, des lignes pour créer des surfaces, etc.

4. La géométrie décrit simultanément la partie et l’ensemble : quand vous avez une courbe, c’est à la fois la forme et tous les points possibles le long de celle-ci.

En pratique, ces principes impliquent que nous devons être conscients de ce avec quoi nous travaillons (quel type de géométrie, comment elle a été créée, etc.) afin de pouvoir composer, décomposer et recomposer librement différentes géométries à mesure que nous développons des modèles plus complexes.

Navigation dans la hiérarchie

Prenez le temps d'observer la relation entre les descriptions abstraite et hiérarchique de la géométrie. Ces deux concepts étant liés, mais pas toujours évidents au début, vous pouvez vous heurter rapidement à un blocage conceptuel une fois que vous avez commencé à développer des workflows ou des modèles plus approfondis. Pour commencer, utilisez la cotation comme descripteur simple des "éléments" modélisés. Le nombre de cotes requises pour décrire une forme vous donne un aperçu de la façon dont la géométrie est organisée de façon hiérarchique.

1. Un point (défini par des coordonnées) ne possède pas de cotes ; il s’agit juste de nombres décrivant chaque coordonnée.

2. Une ligne (définie par deux points) possède désormais une cote : vous pouvez « déplacer » la ligne vers l’avant (direction positive) ou vers l’arrière (direction négative).

3. Un plan (défini par deux lignes) a deux cotes : vous pouvez désormais aller à gauche ou à droite.

4. Une boîte (définie par deux plans) comporte trois cotes : vous pouvez définir une position par rapport à la direction vers le haut ou vers le bas.

La cotation est un moyen pratique de commencer à catégoriser la géométrie, mais ce n’est pas nécessairement le meilleur. Après tout, vous ne modélisez pas uniquement des points, des lignes, des plans et des boîtes. Que faire si des courbes entrent en jeu ? En outre, il existe une toute autre catégorie de types géométriques complètement abstraits, c’est-à-dire qu’ils définissent des propriétés telles que l’orientation, le volume ou les relations entre les pièces. Il n’est pas réellement possible de saisir un vecteur. Comment le définir par rapport aux élément affichés l’espace ? Une catégorisation plus détaillée de la hiérarchie géométrique doit permettre de tenir compte de la différence entre les types abstraits ou les « assistants », que vous pouvez regrouper en fonction de ce qu’ils aident à faire et des types qui aident à décrire la forme des éléments du modèle.

Aller plus loin avec la géométrie

La création de modèles dans Dynamo ne se limite pas à ce que vous pouvez générer avec des nœuds. Voici quelques méthodes essentielles pour faire passer votre processus à la phase suivante avec la géométrie :

1. Dynamo vous permet d'importer des fichiers : essayez d'utiliser un fichier CSV pour les nuages de points ou SAT pour importer des surfaces.

2. Lorsque vous travaillez avec Revit, vous pouvez référencer des éléments Revit à utiliser dans Dynamo.

3. Le gestionnaire de package Dynamo offre des fonctionnalités supplémentaires pour les types de géométrie étendus et les opérations : découvrez le package Mesh Toolkit.

Vecteur, plan et système de coordonnées dans Dynamo

Vecteur

Un vecteur est une représentation de magnitude et de direction. Imaginez-vous une flèche accélérant vers une direction spécifique à une vitesse donnée. C’est un composant clé des modèles dans Dynamo. Dans la mesure où ils se trouvent dans la catégorie Abstract des « assistants », lorsque vous créez un vecteur, vous ne verrez rien dans l’aperçu en arrière-plan.

1. Vous pouvez utiliser une ligne comme support pour un aperçu vectoriel.

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.

Plan

Un plan est une surface bidimensionnelle. Imaginez-vous une surface plane qui s’étend indéfiniment. Chaque plan possède une origine, une direction X, une direction Y et une direction Z (vers le haut).

1. Bien qu’ils soient abstraits, les plans possèdent une position d’origine qui permet de les placer dans l’espace.

2. Dans Dynamo, les plans sont rendus dans l'aperçu en arrière-plan.

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.

Système de coordonnées

Le système de coordonnées est un système permettant de déterminer l’emplacement des points ou d’autres éléments géométriques. L’image ci-dessous explique à quoi il ressemble dans Dynamo et à quoi correspond chaque couleur.

1. Bien qu’ils soient abstraits, les systèmes de coordonnées possèdent également une position d’origine qui permet de les placer dans l’espace.

2. Dans Dynamo, les systèmes de coordonnées sont rendus dans l'aperçu en arrière-plan en tant que point (origine) et lignes définissant les axes (X est rouge, Y est vert et Z est bleu suivant la convention).

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.

Approfondir...

Les vecteurs, les plans et les systèmes de coordonnées constituent le groupe principal de types de géométrie abstraits. Ils vous aident à définir l'emplacement, l'orientation et le contexte spatial d'autres géométries décrivant des formes. Si vous dites que vous êtes à New York, au croisement de la 42e rue et de Broadway (système de coordonnées), debout au niveau de la rue (plan), regardant au nord (vecteur), vous venez d'utiliser ces "assistants" pour définir votre position. Il en va de même pour une coque de téléphone ou un gratte-ciel : vous avez besoin de ce contexte pour développer votre modèle.

Vecteur

Un vecteur est une quantité géométrique décrivant la direction et la magnitude. Les vecteurs sont abstraits, c’est-à-dire qu’ils représentent une quantité et non un élément géométrique. Les vecteurs peuvent être facilement confondus avec les points, car ils sont tous les deux composés d’une liste de valeurs. Il existe cependant une différence essentielle : les points décrivent une position dans un système de coordonnées donné, tandis que les vecteurs décrivent une différence par rapport à la position qui est la même que la « direction ».

Si l’idée de différence relative est déroutante, envisagez le vecteur AB sous cet angle : « Je suis au point A, et je regarde vers le point B. » La direction, d’ici (A) à là (B), est notre vecteur.

Décomposez davantage les vecteurs en parties en utilisant la même notation AB :

1. Le point de départ du vecteur est appelé base.

2. Le point d’arrivée du vecteur est appelé pointe ou sens.

3. Le vecteur AB est différent du vecteur BA, qui pointe dans la direction opposée.

Pour ajouter une touche de légèreté en ce qui concerne les vecteurs (et leur définition abstraite), impossible de ne pas mentionner la fameuse réplique de la comédie "Y a-t-il un pilote dans l'avion" :

Roger, Roger. Quel est votre vecteur, Victor ?

Plan

Les plans sont des "assistants" abstraits 2D. Plus spécifiquement, les plans sont conceptuellement "plats", s'étendant de manière infinie dans deux directions. En général, ils sont rendus sous la forme d’un rectangle plus petit près de leur origine.

Vous pensez peut-être, "Attendez ! Et l'origine ? Cela ressemble à un système de coordonnées... comme celui que j'utilise pour modéliser des éléments dans mon logiciel de CAO !"

Et vous avez raison ! La plupart des logiciels de modélisation tirent parti des plans de construction ou des « niveaux » afin de définir un contexte local bidimensionnel pour le dessin. XY, XZ, YZ ou Nord, Sud-est, le plan peut sembler plus familier. Il s'agit de tous les plans, définissant un contexte "plat" infini. Les plans n’ont pas de profondeur, mais ils permettent aussi de décrire la direction.

Système de coordonnées

Si vous maîtrisez parfaitement les plans, les systèmes de coordonnées ne vous poseront pas de difficultés. Un plan possède les mêmes composants qu'un système de coordonnées, à condition qu'il s'agisse d'un système de coordonnées "euclidiennes" ou "XYZ" standard.

Cependant, il existe d'autres systèmes de coordonnées, tels que les systèmes cylindriques ou sphériques. Comme vous le verrez dans les sections suivantes, les systèmes de coordonnées peuvent également être appliqués à d’autres types de géométrie afin de définir une position sur la géométrie en question.

Ajout de systèmes de coordonnées alternatifs : cylindrique, sphérique

Espace de travail principal

L’espace de travail de Dynamo se compose de quatre éléments principaux.

1. Tous les onglets actifs.

2. Mode aperçu

3. Commandes Zoom/Panoramique

4. Nœud dans l’espace de travail

Tous les onglets actifs

Lorsque vous ouvrez un nouveau fichier, un nouvel espace de travail d’accueil s’ouvre par défaut.

Vous pouvez créer un nœud personnalisé et l’ouvrir dans un espace de travail de nœud personnalisé.

Mode aperçu

Il existe 3 méthodes permettant de passer d’un aperçu à un autre :

a. Utilisation des icônes situées en haut à droite

b. Clic avec le bouton droit de la souris dans l’espace de travail

• Passage de l’aperçu 3D à l’aperçu du graphique

• Passage de l’aperçu du graphique à l’aperçu 3D

c. Utilisation du raccourci clavier (Ctrl+B)

Commandes Zoom/Panoramique

Vous pouvez utiliser des icônes ou la souris pour naviguer dans l’un ou l’autre des espaces de travail.

a. En mode Aperçu du graphique

• À l’aide d’icônes :
• À l’aide de la souris :

  • Clic avec le bouton gauche de la souris – Sélection

  • Clic avec le bouton gauche de la souris et glissement – Zone de sélection permettant de sélectionner plusieurs nœuds

  • Défilement vers le haut/bas au milieu – Zoom avant/arrière

  • Clic avec le bouton du milieu de la souris et glissement – Panoramique

  • Clic avec le bouton droit de la souris n’importe où dans la zone de dessin – Ouvrir la recherche dans la zone de dessin

b. En mode Aperçu 3D

• À l’aide d’icônes :
• À l’aide de la souris :

  • Défilement vers le haut/bas au milieu – Zoom avant/arrière

  • Clic avec le bouton du milieu de la souris et glissement – Panoramique

  • Clic avec le bouton droit de la souris et glissement – Orbite

Nœud dans l’espace de travail

Cliquez avec le bouton droit de la souris pour sélectionner un nœud.

Pour sélectionner plusieurs nœuds, cliquez et effectuez un glisser-déposer afin de créer une zone de sélection.

Cette section présente les nœuds essentiels disponibles dans la bibliothèque Dynamo qui vous aideront à créer votre propre programme visuel comme un pro.

Nœuds

Dans Dynamo, les nœuds sont les objets que vous connectez pour former un programme visuel. Chaque nœud effectue une opération, parfois aussi simple que le stockage d'un nombre, ou plus complexe, comme la création ou l'envoi de requêtes à une géométrie.

Anatomie d'un nœud

La plupart des nœuds de Dynamo sont composés de cinq éléments. Bien qu’il existe des exceptions, telles que les nœuds Input, l’anatomie de chaque nœud peut être décrite comme suit :

1. Nom : nom du nœud conforme à la convention d’appellation Category.Name.

2. Corps principal : corps principal du nœud. Cliquez ici avec le bouton droit de la souris pour afficher les options au niveau du nœud entier

3. Ports (entrants et sortants) : récepteurs des fils qui fournissent les données d'entrée au nœud, ainsi que les résultats de l'action du nœud

4. Valeur par défaut : cliquez avec le bouton droit de la souris sur un port d'entrée. Certains nœuds ont des valeurs par défaut qui peuvent être utilisées ou non.

Ports d'entrée/de sortie des nœuds

Les entrées et les sorties des nœuds sont appelées "ports" et servent de récepteurs pour les fils. Les données sont intégrées au nœud via des ports sur la gauche et sortent du nœud après l'exécution de son opération sur la droite.

Les ports doivent recevoir des données d'un certain type. Par exemple, la connexion d'un nombre tel que 2.75 aux ports d'un nœud Point By Coordinates permet de créer un point. Toutefois, si vous indiquez "Red" sur le même port, une erreur se produira.

1. Libellé de port

2. Info-bulle

3. Type de données

4. Valeur par défaut

États des nœuds

Dynamo donne une indication de l'état d'exécution de votre programme visuel en effectuant le rendu des nœuds avec différents schémas de couleurs en fonction de l'état de chaque nœud. La hiérarchie des états suit la séquence suivante : Erreur > Avertissement > Infos > Aperçu.

Lorsque vous placez le curseur ou cliquez avec le bouton droit de la souris sur le nom ou les ports, vous affichez des informations et des options supplémentaires.

1. Entrées satisfaites : un nœud avec des barres verticales bleues sur ses ports d’entrée est bien connecté et toutes ses entrées sont connectées.

2. Entrées non satisfaites : ces entrées doivent être connectées à un nœud avec une barre verticale rouge sur un ou plusieurs ports d'entrée.

3. Fonction : un nœud qui génère une fonction et comporte une barre verticale grise sur un port de sortie est un nœud de fonction.

4. Sélectionné : les nœuds actuellement sélectionnés ont une bordure bleue.

5. Gelé : un nœud bleu translucide est gelé, ce qui interrompt son exécution.

7. Avertissement : une barre d'état jaune située sous le nœud indique l'état d'avertissement, ce qui signifie qu'il manque au nœud des données d'entrée ou que les types de données peuvent être incorrects.

8. Erreur : une barre d'état rouge située sous le nœud indique que le nœud est en état d'erreur.

9. Infos : la barre d'état bleue située sous le nœud indique l'état Informations, qui indique des informations utiles sur les nœuds. Cet état peut être déclenché lorsque vous approchez une valeur maximale prise en charge par le nœud, lorsque vous utilisez un nœud d'une manière susceptible d'avoir un impact sur les performances, etc.

Gestion des nœuds d'erreur ou d'avertissement

1. Info-bulle d’avertissement : une valeur « Null » ou l’absence de donnée ne peut être comprise comme un double, c’est-à-dire un nombre

2. Utilisez le nœud Watch pour examiner les données d'entrée

3. En amont, le nœud Number contient "Red" et non un nombre

Gel des nœuds

Dans certaines situations, vous pouvez souhaiter empêcher l’exécution de nœuds spécifiques dans votre programme visuel. Vous pouvez le faire en « gelant » le nœud. Cette option se trouve dans le menu contextuel du nœud.

Le gel d’un nœud entraîne également le gel des nœuds situés en aval. En d’autres termes, tous les nœuds qui dépendent de la sortie d’un nœud gelé seront également gelés.

Fils

Les fils connectent les nœuds entre eux pour créer des relations et établir le flux de votre programme visuel. Vous pouvez les considérer comme des fils électriques qui transportent des données d'un objet à l'autre.

Flux de programme

Les fils connectent le port de sortie d'un nœud au port d'entrée d'un autre nœud. Cette direction établit le flux de données dans le programme visuel.

Les ports d’entrée se trouvent sur le côté gauche et les ports de sortie sur le côté droit des nœuds. Par conséquent, vous pouvez généralement dire que le flux du programme se déplace de gauche à droite.

Création de fils

Cliquez avec le bouton gauche de la souris sur un port pour créer un fil, puis cliquez avec le bouton gauche de la souris sur le port d'un autre nœud pour créer une connexion. Pendant que vous réalisez une connexion, le fil s'affiche en pointillés et devient continu lorsque la connexion est établie.

Les données passent toujours par ce fil d’une sortie à une entrée. Toutefois, vous pouvez créer le fil dans les deux directions en termes d’ordre de clic sur les ports connectés.

Modification des fils

Souvent, vous souhaitez ajuster le flux du programme dans votre programme visuel en modifiant les connexions représentées par les fils. Pour modifier un fil, cliquez avec le bouton gauche de la souris sur le port d'entrée du nœud déjà connecté. Vous pouvez ensuite procéder de l'une des manières suivantes :

• Pour définir la connexion sur un port d’entrée, cliquez avec le bouton gauche de la souris sur un autre port d’entrée.

• Pour supprimer le fil, retirez-le et cliquez avec le bouton gauche de la souris sur l’espace de travail.

• Reconnectez plusieurs fils à l’aide de la combinaison Maj+clic gauche.

• Dupliquez un fil à l’aide de la combinaison Ctrl+clic gauche.

Fils par défaut et fils en surbrillance

Par défaut, l'aperçu des fils s'affiche avec un trait gris. Lorsqu’un nœud est sélectionné, il effectue le rendu de tous les fils connectés avec la même bordure bleue que le nœud.

1. Fil en surbrillance

2. Fil par défaut

Masquage des fils par défaut

Si vous préférez masquer les fils dans le graphique, vous pouvez accéder à cette option en sélectionnant Affichage > Connecteurs > Afficher les connecteurs.

Avec ce paramètre, seuls les nœuds sélectionnés et les fils qui les rejoignent présentent une bordure bleu clair.

Masquage des fils individuels uniquement

Vous pouvez également masquer le fil sélectionné uniquement. Pour ce faire, cliquez avec le bouton droit de la souris sur la sortie Nœuds > Masquer les fils.

Cet index fournit des informations supplémentaires sur tous les nœuds utilisés dans ce guide, ainsi que sur les autres composants que vous trouverez utiles. Il s'agit juste d'une introduction de quelques-uns des 500 nœuds disponibles dans Dynamo.

Affichage

Color

Watch

Entrée

List

Logique

Math

Chaîne

Géométrie

Circle

Cuboid

Curve

Geometry Modifiers

Ligne

NurbsCurve

NurbsSurface

Plan

Point

Polycourbe

Rectangle

Sphere

Surface

UV

Vecteur

CoordinateSystem

Opérateurs

Solides dans Dynamo

Qu’est-ce qu’un solide ?

Opération booléenne pour créer un solide de balle hérisson

1. Sphere.ByCenterPointRadius : permet de créer le solide de base.

2. Topology.Faces, Face.SurfaceGeometry : permet d’envoyer des requêtes aux faces du solide et de les convertir en géométrie de surface. Dans ce cas, la sphère ne possède qu’une seule face.

3. Cone.ByPointsRadii : permet de créer des cônes en utilisant des points sur la surface.

4. Solid.UnionAll : permet d’unir les cônes et la sphère.

5. Topology.Edges : permet d’envoyer des requêtes aux arêtes du nouveau solide.

6. Solid.Fillet : permet de raccorder les arêtes de la balle hérisson.

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.

Gel

Les opérations booléennes sont complexes et peuvent être lentes à calculer. Vous pouvez utiliser la fonctionnalité Geler pour suspendre l’exécution des nœuds sélectionnés et affectés aux nœuds en aval.

1. Utilisez le menu contextuel du bouton droit de la souris pour geler l’opération d’union de solide.

2. Le nœud sélectionné et tous les nœuds en aval s’affichent en mode fantôme gris clair et les fils affectés en tant que lignes en pointillés. Le mode fantôme sera également appliqué à l'aperçu de la géométrie concernée. Vous pouvez maintenant modifier les valeurs en amont sans calculer l’union booléenne.

3. Pour dégeler les nœuds, cliquez avec le bouton droit de la souris et désactivez l’option Geler.

4. Tous les nœuds concernés et les aperçus de géométrie associés sont mis à jour et reviendront en mode d’aperçu standard.

Approfondir…

Solides

Les solides sont constitués d'une ou de plusieurs surfaces contenant un volume au moyen d'une limite fermée qui définit l'"intérieur" ou l'"extérieur". Quel que soit le nombre de surfaces, elles doivent former un volume "étanche" pour être considérées comme un solide. Vous pouvez créer des solides en joignant des surfaces ou des polysurfaces ou en utilisant des opérations telles que le lissage, le balayage et la révolution. Les primitives sphère, cube, cône et cylindre sont également des solides. Un cube dont au moins une face a été supprimée est considéré comme une polysurface qui possède des propriétés similaires, mais ce n’est pas un solide.

1. Un plan est constitué d’une surface unique et n’est pas un solide.

2. Une sphère est constituée d’une surface, mais est un solide.

3. Un cône est constitué de deux surfaces jointes pour créer un solide.

4. Un cylindre est constitué de trois surfaces jointes pour créer un solide.

5. Un cube est constitué de six surfaces jointes pour créer un solide.

Topologie

Les solides sont constitués de trois types d'éléments : sommets, arêtes et faces. Les faces sont les surfaces qui constituent le solide. Les arêtes sont des courbes qui définissent la connexion entre des faces adjacentes et les sommets sont les points de départ et d'arrivée de ces courbes. Les nœuds Topology peuvent être utilisés pour envoyer des requêtes à ces éléments.

1. Faces

2. Arêtes

3. Sommets

Opérations

Les solides peuvent être modifiés en raccordant ou en chanfreinant leurs arêtes pour éliminer les angles et les angles aigus. L’opération de chanfrein crée une surface réglée entre deux faces, tandis qu’un congé se mélange entre les faces pour maintenir la tangence.

1. Cube solide

2. Cube chanfreiné

3. Cube raccordé

Opérations booléennes

Les opérations booléennes de solide sont des méthodes pour combiner deux solides ou plus. Une opération booléenne unique implique d’effectuer quatre opérations :

1. Entrecouper au moins deux objets.

2. Les scinder aux intersections.

3. Supprimer les portions indésirables de la géométrie.

4. Rassembler le tout.

1. Union : supprimez les parties des solides qui se chevauchent et joignez-les en un seul solide.

2. Différence : soustrayez un solide à un autre. Le solide à soustraire est appelé outil. Notez que vous pouvez redéfinir quel solide est l’outil pour conserver le volume inverse.

3. Intersection : conservez uniquement le volume d’intersection des deux solides.

1. UnionAll : opération d’union avec une sphère et des cônes orientés vers l’extérieur

2. DifferenceAll : opération de différence avec une sphère et des cônes orientés vers l’intérieur

Une fois que vous serez prêt à aller plus loin dans le développement de programmes visuels, vous aurez besoin d'une meilleure compréhension des blocs de construction que vous utiliserez. Ce chapitre présente les concepts fondamentaux relatifs aux données, à savoir les éléments qui passent par les fils de votre programme Dynamo.

La logique, ou plus spécifiquement, la logique conditionnelle, vous permet de spécifier une action ou un jeu d’actions en fonction d’un test. Après avoir évalué le test, vous obtenez une valeur booléenne représentant True ou False que vous pouvez utiliser pour contrôler le flux du programme.

Valeurs booléennes

Les variables numériques peuvent stocker un intervalle entier de nombres différents. Les variables booléennes ne peuvent stocker que deux valeurs appelées True ou False, Yes ou No, 1 ou 0. Les valeurs booléennes sont rarement utilisées pour effectuer des calculs en raison de leur intervalle limité.

Instructions conditionnelles

L’instruction « If » est un concept clé de la programmation : « If » cet élément a la valeur True, voici le résultat, sinon autre chose se produit. L’action résultant de l’instruction est déterminée par une valeur booléenne. Il existe plusieurs méthodes pour définir une instruction "If" dans Dynamo :

Voici un bref exemple de chacun de ces trois nœuds en action à l’aide de l’instruction conditionnelle « If ».

Dans cette image, la valeur booléenne est définie sur True, ce qui signifie que le résultat est une chaîne indiquant : « voici le résultat si True ». Les trois nœuds qui créent l’instruction If fonctionnent de la même manière ici.

Là encore, les nœuds fonctionnent de la même façon. Si la valeur booléenne est définie sur False, le résultat est le nombre Pi, tel que défini dans l’instruction If d’origine.

Exercice : Logique et géométrie

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.

Partie I : Filtrage d’une liste

1. Utilisez la logique pour séparer une liste de nombres en une liste de nombres pairs et une liste de nombres impairs.

a. Number Range : ajoutez un intervalle de nombres dans la zone de dessin.

b. Number : ajoutez trois nœuds numériques dans la zone de dessin. La valeur de chaque nœud numérique doit être : 0.0 pour start, 10.0 pour end et 1.0 pour step.

c. Sortie : le résultat est une liste de 11 chiffres compris entre 0 et 10.

d. Module (%) : Number Range en x et 2.0 en y. Cela permet de calculer le reste pour chaque nombre de la liste divisé par 2. La sortie de cette liste vous donne une liste de valeurs alternant entre 0 et 1.

e. Test d’égalité (==) : permet d’ajouter un test d’égalité à la zone de dessin. Connectez la sortie du module à l’entrée x et 0.0 à l’entrée y.

f. Watch : la sortie du test d’égalité est une liste de valeurs alternant entre true et false. Il s’agit des valeurs utilisées pour séparer les éléments de la liste. 0 (ou true) représente des nombres pairs et 1 (ou false) des nombres impairs.

g. List.FilterByBoolMask : ce nœud filtre les valeurs dans deux listes différentes en fonction de la valeur booléenne d’entrée. Connectez le nœud Number Range d’origine à l’entrée list et la sortie du test d’égalité à l’entrée mask. La sortie in représente des valeurs True, tandis que la sortie out représente des valeurs False.

h. Watch : le résultat est une liste de nombres pairs et une liste de nombres impairs. Vous avez utilisé des opérateurs logiques pour séparer des listes en modèles.

Partie II : De la logique à la géométrie

En partant de la logique établie dans le premier exercice, appliquez cette configuration dans une opération de modélisation.

2. Partez de l’exercice précédent avec les mêmes nœuds. Les seules exceptions (outre la modification du format) sont les suivantes :

a. Utilisez un nœud Sequence avec ces valeurs d’entrée.

b. L’entrée list de List.FilterByBoolMask est déconnectée. Pour l’instant, mettez ces nœuds de côté. Vous les utiliserez plus tard dans l’exercice.

3. Commencez par créer un groupe distinct de graphiques, comme illustré dans l’image ci-dessus. Ce groupe de nœuds représente une équation paramétrique permettant de définir une courbe de ligne. Remarques :

a. Le premier nœud Number Slider représente la fréquence de l’onde. Il doit avoir une valeur minimale de 1, une valeur maximale de 4 et un pas de 0,01.

b. Le second nœud Number Slider représente l’amplitude de l’onde. Il doit avoir une valeur minimale de 0, une valeur maximale de 1 et un pas de 0,01.

c. PolyCurve.ByPoints : si vous copiez le diagramme de nœud ci-dessus, vous obtenez une courbe sinusoïdale dans la fenêtre d’aperçu Dynamo.

Méthode utilisée ici pour les entrées : utilisez des nœuds Number pour obtenir davantage de propriétés statiques et des curseurs de numérotation sur les valeurs plus flexibles. Conservez l'intervalle de nombres d'origine défini au début de cette étape. Toutefois, la courbe sinusoïdale créée ici doit garder une certaine flexibilité. Vous pouvez déplacer ces curseurs pour observer la fréquence et l’amplitude de la courbe se mettre à jour.

4. Vous allez désormais passer à la définition. Examinez le résultat final pour pouvoir référencer ce que vous obtenez. Les deux premières étapes sont effectuées séparément, mais vous devez maintenant les connecter. Utilisez la courbe sinusoïdale de base pour déterminer l’emplacement des composants de zipper, et utilisez la logique True/False pour alterner entre les petites boîtes et les grandes boîtes.

a. Math.RemapRange : à l’aide de la séquence de nombres créée à l’étape 02, créez une nouvelle série de nombres en remappant l’intervalle. Les nombres d’origine de l’étape 1 sont compris entre 0 et 100. Ces nombres sont compris entre 0 et 1, respectivement par les entrées newMin et newMax.

5. Créez un nœud Curve.PointAtParameter, puis connectez la sortie Math.RemapRange de l’étape 4 en tant qu’entrée param.

Cette étape permet de créer des points le long de la courbe. Remappez les nombres entre 0 et 1, car l’entrée param recherche les valeurs dans cet intervalle. Une valeur de 0 représente le point de départ, une valeur de 1 représente les points de fin. Tous les nombres compris entre ces valeurs sont évalués dans l’intervalle [0,1].

6. Connectez la sortie de Curve.PointAtParameter à List.FilterByBoolMask pour séparer la liste des index impairs et pairs.

a. List.FilterByBoolMask : connectez Curve.PointAtParameter de l’étape précédente à l’entrée list.

b. Watch : un nœud Watch pour in et un nœud Watch pour out indique que deux listes représentent des index pairs et des index impairs. Ces points sont ordonnés de la même façon sur la courbe, illustrée à l’étape suivante.

7. Vous allez maintenant utiliser le résultat de la sortie de List.FilterByBoolMask à l’étape 5 pour générer des géométries avec des tailles en fonction de leurs index.

Cuboid.ByLengths : recréez les connexions illustrées à l’image ci-dessus pour obtenir un zipper le long de la courbe sinusoïdale. Ici, un cuboïde ne représente qu’une boîte, et vous définissez sa taille en fonction du point de courbe au centre de la boîte. La logique de la division paire/impaire doit maintenant être claire dans le modèle.

a. Liste de cuboïdes à des index pairs.

b. Liste de cuboïdes à des index impairs.

Voilà ! Vous venez de programmer un processus de définition de cotes de géométrie en fonction de l’opération logique présentée dans cet exercice.

Maillage dans Dynamo

Qu’est-ce qu’un maillage ?

Dans le domaine de la modélisation informatique, les maillages sont l’une des formes de représentation les plus répandues de la géométrie 3D. La géométrie de maillage est généralement un ensemble de quadrilatères ou de triangles. Elle représente une alternative simple et flexible à l’utilisation des NURBS. Les maillages sont utilisés dans tous les domaines : du rendu aux visualisations, jusqu’à la fabrication numérique et à l’impression 3D.

Éléments maillage

Dynamo définit les maillages à l'aide d'une structure de données Face-Sommet. À la base, cette structure est simplement un ensemble de points regroupés en polygones. Les points d'un maillage sont appelés sommets, tandis que les polygones de surface sont appelés faces.

Pour créer un maillage, vous avez besoin d’une liste de sommets et d’un système de regroupement de ces sommets en faces appelé groupe d’index.

1. Liste de sommets

2. Liste des groupes d'index permettant de définir les faces.

Mesh Toolkit

L’installation du package Mesh Toolkit permet d’étendre les fonctionnalités de maillage de Dynamo. Le package Mesh Toolkit de Dynamo 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 selon leurs sommets et leurs index.

La bibliothèque fournit également des outils permettant de modifier les maillages, de réparer les maillages ou d’extraire des sections horizontales à utiliser lors de la fabrication.

Consultez les études de cas Mesh Toolkit pour découvrir des exemples d’utilisation de ce package.

Approfondir…

Maillage

Un maillage est un ensemble de quadrilatères et de triangles représentant une géométrie de surface ou de solide. Comme pour les solides, la structure d'un objet maillé comprend des sommets, des arêtes et des faces. Il existe d’autres propriétés qui rendent les maillages uniques, telles que les normales.

1. Sommets de maillage.

2. Arêtes de maillage. *Les arêtes avec une seule face adjacente sont appelées "nues". Toutes les autres arêtes sont "habillées".

3. Faces de maillage.

Sommets + normales de sommet

Les sommets d'un maillage sont simplement une liste de points. L'index des sommets est très important lors de la construction d'un maillage ou de l'obtention d'informations sur la structure d'un maillage. Pour chaque sommet, il existe également une normale de sommet (vecteur) correspondante qui décrit la direction moyenne des faces attachées et vous aide à comprendre l’orientation « intérieure » et « extérieure » du maillage.

1. Sommets

2. Normales de sommet

Faces

Une face est une liste ordonnée de trois ou quatre sommets. La représentation de la "surface" d'une face maillée est donc implicite en fonction de la position des sommets indexés. Étant donné que vous avez déjà la liste des sommets qui constituent le maillage, au lieu de fournir des points individuels pour définir une face, utilisez simplement l'index des sommets. Cela vous permet également d’utiliser le même sommet dans plusieurs faces.

1. Une face quadrilatérale composée des index 0, 1, 2 et 3.

2. Une face triangulaire composée des index 1, 4 et 2. Les groupes d'index peuvent être modifiés dans leur ordre : tant que la séquence est ordonnée dans le sens trigonométrique, la face est correctement définie.

Maillages et surfaces NURBS

Quelles sont les différences entre la géométrie de maillage et la géométrie NURBS ? Quand utiliseriez-vous l'une ou l'autre ?

Définition des paramètres

Dans le chapitre précédent, vous avez découvert que les surfaces NURBS sont définies par une série de courbes NURBS allant dans deux directions. Ces directions sont libellées U et V, et permettent de paramétrer une surface NURBS en fonction d’un domaine de surface 2D. Les courbes elles-mêmes sont stockées en tant qu'équations dans l'ordinateur, ce qui permet de calculer les surfaces qui en résultent dans un degré de précision arbitrairement petit. Il peut cependant être difficile de combiner plusieurs surfaces NURBS. La jonction de deux surfaces NURBS génère une polysurface, où différentes sections de la géométrie auront des définitions de courbe et des paramètres UV différents.

1. Surface

2. Courbe isoparamétrique (isoparm)

3. Point de contrôle de surface

4. Polygone de contrôle de surface

5. Point isoparamétrique

6. Cadre de surface

7. Maillage

8. Arête nue

9. Réseau de maillage

10. Arêtes de maillage

11. Normale de sommet

12. Face de maillage/Normale de face de maillage

Les maillages, en revanche, sont constitués d'un nombre distinct de sommets et de faces exactement définis. Le réseau de sommets ne peut généralement pas être défini par de simples coordonnéesUV. En effet, étant donné que les faces sont distinctes, la précision est créée dans le maillage et ne peut être modifiée qu’en affinant le maillage et en ajoutant des faces supplémentaires. L'absence de descriptions mathématiques permet aux maillages de gérer plus facilement une géométrie complexe au sein d'un maillage unique.

Influence locale et globale

Une autre différence importante est la mesure dans laquelle une modification locale de la géométrie de maillage ou NURBS affecte l'ensemble de la forme. Le déplacement d'un sommet d'un maillage affecte uniquement les faces adjacentes à ce sommet. Dans les surfaces NURBS, l'étendue de l'influence est plus complexe et dépend du degré de la surface ainsi que des poids et des noeuds des points de contrôle. En général, cependant, le déplacement d’un seul point de contrôle dans une surface NURBS crée un changement plus lisse et plus important de la géométrie.

1. Surface NURBS : le déplacement d’un point de contrôle a une influence qui s’étend sur toute la forme.

2. Géométrie de maillage : le déplacement d'un sommet a une influence uniquement sur les éléments adjacents.

Une analogie qui peut être utile consiste à comparer une image vectorielle (composée de lignes et de courbes) à une image raster (composée de pixels individuels). Si vous effectuez un zoom avant sur une image vectorielle, les courbes restent nettes et claires, tandis que si vous effectuez un zoom sur une image raster, les pixels individuels deviennent plus grands. Dans cette analogie, vous pouvez comparer les surfaces NURBS à une image vectorielle, car il existe une relation mathématique lisse, tandis qu'un maillage se comporte de la même façon qu'une image raster avec une résolution définie.

La couleur est un excellent type de donnée permettant de créer des visuels convaincants et de restituer la différence dans le résultat obtenu à partir de votre programme visuel. Lorsque vous travaillez avec des données abstraites et des nombres variables, il est parfois difficile de remarquer les changements. Cette application est idéale pour les couleurs.

Création de couleurs

Dans Dynamo, les couleurs sont créées à l’aide des entrées ARVB. Cet acronyme correspond aux canaux Alpha, Rouge, Vert et Bleu. L’alpha représente la transparence de la couleur, tandis que les trois autres couleurs sont utilisées comme couleurs primaires pour générer de concert l’ensemble du spectre de couleurs.

Interrogation des valeurs de couleur

Les couleurs du tableau ci-dessous recherchent les propriétés utilisées pour définir la couleur : Alpha, Rouge, Vert et Bleu. Étant donné que le nœud Color.Components donne les quatre sorties différentes, ce nœud est préférable pour l'interrogation des propriétés d'une couleur.

Les couleurs du tableau ci-dessous correspondent à l’espace de couleurs HSB. Diviser la couleur en teinte, en saturation et en luminosité permet probablement de l’interpréter de façon plus intuitive : quelle couleur choisir ? Quel niveau de saturation de la couleur choisir ? Et quel niveau d'intensité de la couleur choisir ? Il s'agit respectivement de la répartition de la teinte, de la saturation et de la luminosité.

Intervalles de couleurs

L’intervalle de couleurs est semblable au nœud Remap Range de l’exercice #part-ii-from-logic-to-geometry: il remappe une liste de nombres dans un autre domaine. Au lieu d’effectuer le mappage vers un domaine nombre, il mappe vers un dégradé de couleurs basé sur des numéros d’entrée allant de 0 à 1.

Le nœud actuel fonctionne bien, mais il peut être un peu délicat de tout faire fonctionner la première fois. La meilleure façon de se familiariser avec le dégradé de couleurs est de le tester de manière interactive. Vous allez faire un exercice rapide pour découvrir comment configurer un dégradé avec des couleurs de sortie correspondant aux nombres.

1. Définir trois couleurs : à l’aide d’un nœud Code Block, définissez rouge, vert et bleu en connectant les combinaisons appropriées de 0 et 255.

2. Créer une liste : fusionnez les trois couleurs dans une liste.

3. Définir les index : créez une liste pour définir les positions des poignées de chaque couleur (de 0 à 1). Notez la valeur 0.75 pour le vert. La couleur verte est ainsi placée aux trois quarts du dégradé horizontal dans le curseur de l’intervalle de couleurs.

4. Code Block : valeurs d’entrée (entre 0 et 1) pour convertir en couleurs.

Aperçu des couleurs

Le nœud Display.ByGeometry permet de colorer la géométrie dans la fenêtre Dynamo. Ce nœud est utile pour séparer différents types de géométrie, présenter un concept paramétrique ou définir une légende d’analyse pour la simulation. Les entrées sont simples : geometry et color. Pour créer un dégradé comme l’image ci-dessus, l’entrée color est connectée au nœud Color Range.

Couleur sur les surfaces

Le nœud Display.BySurfaceColors permet de mapper des données sur une surface grâce à la couleur. Cette fonctionnalité présente de nombreuses possibilités pour visualiser des données obtenues par analyse discrète, comme le soleil, l’énergie et la proximité. Dans Dynamo, l'application d'une couleur à une surface revient à appliquer une texture à un matériau dans d'autres environnements de CAO. Dans le court exercice ci-dessous, vous allez découvrir comment utiliser cet outil.

Exercice

Hélice de base avec couleurs

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.

Cet exercice est axé sur le contrôle paramétrique de la couleur parallèlement à la géométrie. La géométrie est une hélice de base, définie ci-dessous à l’aide d’un nœud Code Block. C’est une méthode simple et rapide servant à créer une fonction paramétrique. Étant donné que vous vous intéressez à la couleur (plutôt qu’à la géométrie), le bloc de code vous permet de créer efficacement l’hélice sans encombrer la zone de dessin. Vous utiliserez le bloc de code plus fréquemment lorsque le guide traitera de matériaux plus avancés.

1. Bloc de code : définissez les deux blocs de code avec les formules susmentionnées. Il s’agit d’une méthode paramétrique rapide de création d’une clothoïde.

2. Point.ByCoordinates : connectez les trois sorties du nœud Code Block aux coordonnées du nœud.

Un réseau de points est maintenant visible, créant une hélice. L’étape suivante consiste à créer une courbe passant par les points afin de pouvoir visualiser l’hélice.

1. PolyCurve.ByPoints : connectez la sortie Point.ByCoordinates à l’entrée points du nœud. Vous obtenez une courbe hélicoïdale.

2. Curve.PointAtParameter : connectez la sortie PolyCurve.ByPoints à l’entrée curve. L’objectif de cette étape est de créer un point d’attraction paramétrique qui glisse le long de la courbe. Puisque la courbe évalue un point au paramètre, vous devez entrer une valeur param comprise entre 0 et 1.

3. Number Slider : après l’ajout à la zone de dessin, remplacez la valeur min par 0.0, la valeur max par 1.0 et la valeur step par .01. Connectez la sortie du curseur à l’entrée param pour Curve.PointAtParameter. Un point apparaît désormais sur la longueur de l’hélice, représenté par un pourcentage du curseur (0 au point de départ, 1 au point d’arrivée).

Une fois le point de référence créé, vous allez maintenant comparer la distance entre le point de référence et les points d'origine définissant l'hélice. Cette valeur de distance détermine la géométrie ainsi que la couleur.

1. Geometry.DistanceTo : connectez la sortie Curve.PointAtParameter à l’entrée. Connectez Point.ByCoordinates à l’entrée geometry.

2. Watch : la sortie obtenue affiche une liste des distances entre chaque point hélicoïdal et le point de référence le long de la courbe.

L’étape suivante consiste à piloter les paramètres avec la liste des distances entre les points hélicoïdaux et le point de référence. Ces valeurs de distance permettent de définir les rayons d’une série de sphères le long de la courbe. Pour conserver une taille adaptée aux sphères, vous devez remapper les valeurs de distance.

1. Math.RemapRange : connectez la sortie Geometry.DistanceTo à l’entrée numbers.

2. Bloc de code : connectez un bloc de code avec une valeur de 0.01 à l’entrée newMin et un bloc de code avec une valeur de 1 à l’entrée newMax.

3. Watch : connectez la sortie Math.RemapRange à un nœud et la sortie Geometry.DistanceTo à un autre nœud. Comparez les résultats.

Cette étape a permis de remapper la liste de distance pour qu’elle soit plus petite. Vous pouvez modifier les valeurs newMin et newMax comme bon vous semble. Les valeurs sont remappées et auront le même rapport de distribution sur le domaine.

1. Sphere.ByCenterPointRadius : connectez la sortie Math.RemapRange à l’entrée radius et la sortie Point.ByCoordinates d’origine à l’entrée centerPoint.

Modifiez la valeur du curseur de numérotation et observez la mise à jour de la taille des sphères. Vous avez désormais un gabarit paramétrique.

La taille des sphères montre le réseau paramétrique défini par un point de référence le long de la courbe. Utilisez le même concept pour le rayon des sphères afin de contrôler leur couleur.

1. Color Range : à ajouter en haut de la zone de dessin. Lorsque vous passez le curseur sur l’entrée value, vous remarquez que les nombres demandés sont compris entre 0 et 1. Vous devez remapper les numéros de la sortie Geometry.DistanceTo afin qu’ils soient compatibles avec ce domaine.

2. Sphere.ByCenterPointRadius : pour le moment, désactivez l’aperçu sur ce nœud (cliquez avec le bouton droit de la souris > Aperçu).

1. Math.RemapRange : ce processus devrait vous sembler familier. Connectez la sortie Geometry.DistanceTo à l’entrée numbers.

2. Bloc de code : comme lors d’une étape précédente, créez une valeur de 0 pour l’entrée newMin et une valeur de 1 pour l’entrée newMax. Dans ce cas, vous pouvez définir deux sorties à partir d’un bloc de code.

3. Color Range : connectez la sortie Math.RemapRange à l’entrée value.

1. Color.ByARGB : cette action permet de créer deux couleurs. Bien que ce processus puisse paraître délicat, il est identique aux couleurs RVB d’un autre logiciel. Vous allez simplement utiliser la programmation visuelle pour le faire.

2. Bloc de code : créez deux valeurs de 0 et 255. Connectez les deux sorties aux deux entrées Color.ByARGB conformément à l’image ci-dessus (ou créez vos deux couleurs préférées).

3. Color Range : l’entrée colors demande une liste de couleurs. Vous devez créer cette liste à partir des deux couleurs créées à l’étape précédente.

4. List.Create : fusionnez les deux couleurs dans une liste. Connectez la sortie à l’entrée colors pour Color Range.

1. Display.ByGeometryColor : connectez Sphere.ByCenterPointRadius à l’entrée geometry et Color Range à l’entrée color. Vous avez maintenant un dégradé lisse sur le domaine de la courbe.

Si vous modifiez la valeur de Number Slider lors d’une étape précédente de la configuration, les couleurs et les tailles sont mises à jour. Dans ce cas, les couleurs et la taille du rayon sont directement liées : vous avez désormais un lien visuel entre deux paramètres !

Exercice - Couleur sur surfaces

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.

Tout d’abord, créez (ou référencez) une surface à utiliser comme entrée pour le nœud Display.BySurfaceColors. Dans cet exemple, vous allez effectuer un lissage entre une courbe sinus et cosinus.

1. Ce groupe de nœuds crée des points le long de l’axe Z, puis les déplace selon les fonctions de sinus et cosinus. Les deux listes de points sont ensuite utilisées pour générer des courbes NURBS.

2. Surface.ByLoft : générez une surface interpolée entre la liste des courbes NURBS.

1. File Path : sélectionnez un fichier image à échantillonner pour les données de pixel en aval.

2. Utilisez File.FromPath pour convertir le chemin d’accès au fichier en fichier, puis le transmettre à Image.ReadFromFile pour générer une image à des fins d’échantillonnage.

3. Image.Pixels : entrez une image et indiquez une valeur d’exemple à utiliser le long des dimensions x et y de l’image.

4. Curseur : fournit des valeurs d’exemple pour Image.Pixels.

5. Display.BySurfaceColors : mappez le réseau de valeurs de couleur sur la surface le long de X et Y respectivement.

Aperçu rapproché de la surface de sortie avec résolution des échantillons de 400 x 300

Utilisation des listes

Maintenant que vous avez établi une liste, il est temps de découvrir les opérations que vous pouvez effectuer sur celle-ci. Imaginez que la liste est un paquet de cartes de jeu. Un paquet est la liste et chaque carte de jeu représente un élément.

Photo de Christian Gidlöf

Query

Quelles requêtes pouvez-vous faire à partir de la liste ? Elles permettent d’accéder aux propriétés existantes.

• Nombre de cartes dans le paquet ? 52.

• Nombre de couleurs ? 4.

• Matériau ? Papier.

• Longueur ? 3,5 pouces ou 89 mm.

• Largeur ? 2,5 pouces ou 64 mm.

Action

Quelles actions pouvez-vous effectuer dans la liste ? Elles permettent de modifier la liste en fonction d’une opération donnée.

• Vous pouvez mélanger le paquet.

• Vous pouvez trier le paquet par valeur.

• Vous pouvez trier le paquet par couleur.

• Vous pouvez diviser le paquet.

• Vous pouvez diviser le paquet en distribuant les mains individuelles.

• Vous pouvez sélectionner une carte spécifique dans le paquet.

Toutes les opérations répertoriées ci-dessus possèdent des nœuds Dynamo similaires qui permettent de travailler avec des listes de données génériques. Les leçons ci-dessous présentent certaines des opérations fondamentales que vous pouvez effectuer sur des listes.

Exercice

Opérations de liste

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.

L’image ci-dessous est le graphique de base sur lequel vous dessinez des lignes entre deux cercles pour représenter les opérations de liste de base. Vous allez découvrir comment gérer les données dans une liste et afficher les résultats visuels à travers les actions de liste ci-dessous.

1. Commencez par un nœud Code Block avec une valeur de 500;.

2. Connectez-le à l’entrée x d’un nœud Point.ByCoordinates.

3. Connectez le nœud de l’étape précédente à l’entrée d’origine d’un nœud Plane.ByOriginNormal.

4. À l’aide d’un nœud Cercle.ByPlaneRadius, connectez le nœud de l’étape précédente à l’entrée plane.

5. À l’aide d’un nœud Code Block, désignez une valeur de 50; pour le rayon. Il s’agit du premier cercle créé.

6. À l’aide d’un nœud Geometry.Translate, déplacez le cercle de 100 unités vers le haut dans la direction Z.

7. À l’aide d’un nœud Code Block, définissez un intervalle de dix nombres entre 0 et 1 avec la ligne de code suivante : 0..1..#10;

8. Connectez le bloc de code de l’étape précédente à l’entrée param de deux nœuds Curve.PointAtParameter. Connectez Circle.ByPlaneRadius à l’entrée curve du nœud supérieur, puis Geometry.Translate à l’entrée curve du nœud situé en dessous.

9. À l’aide d’un nœud Line.ByStartPointEndPoint, connectez les deux nœuds Curve.PointAtParameter.

List.Count

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.

Le nœud List.Count est simple : il compte le nombre de valeurs dans une liste et renvoie ce nombre. Ce nœud devient plus subtil lorsque vous travaillez avec des listes de listes, mais vous le découvrirez dans les sections suivantes.

1. Le nœud **List.Count ****** renvoie le nombre de lignes dans le nœud Line.ByStartPointEndPoint. Dans ce cas, la valeur est de 10, ce qui correspond au nombre de points créés à partir du nœud Code Block d’origine.

List.GetItemAtIndex

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.

List.GetItemAtIndex est une méthode fondamentale pour interroger un élément de la liste.

1. Tout d’abord, cliquez avec le bouton droit sur le nœud Line.ByStartPointEndPoint pour désactiver son aperçu.

2. À l’aide du nœud List.GetItemAtIndex, sélectionnez l’index « 0 » ou le premier élément de la liste de lignes.

Modifiez la valeur du curseur entre 0 et 9 pour sélectionner un autre élément à l’aide de List.GetItemAtIndex.

List.Reverse

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.

List.Reverse inverse l’ordre de tous les éléments d’une liste.

1. Pour visualiser correctement la liste inversée des lignes, créez plus de lignes en remplaçant le nœud Code Block par 0..1..#50;.

2. Dupliquez le nœud Line.ByStartPointEndPoint, insérez un nœud List.Reverse entre Curve.PointAtParameter et le deuxième nœud Line.ByStartPointEndPoint.

3. Utilisez les nœuds Watch3D pour afficher un aperçu de deux résultats différents. Le premier affiche le résultat sans liste inversée. Les lignes se connectent verticalement aux points voisins. Toutefois, la liste inversée connecte tous les points à l’ordre opposé dans l’autre liste.

List.ShiftIndices

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.

List.ShiftIndices est un bon outil pour créer des torsions ou des motifs hélicoïdaux, ou toute autre manipulation de données similaire. Ce nœud déplace les éléments d’une liste d’un certain nombre d’index.

1. Dans le même processus que la liste inversée, insérez un nœud List.ShiftIndices dans les nœuds Curve.PointAtParameter et Line.ByStartPointEndPoint.

2. À l’aide d’un nœud Code Block, définissez une valeur de « 1 » pour déplacer la liste d’un index.

3. Le changement est subtil, mais toutes les lignes du nœud Watch3D inférieur se sont déplacées d’un index lors de la connexion à l’autre jeu de points.

En remplaçant la valeur du nœud Code Block par une valeur plus élevée, « 30 » par exemple, vous pouvez observer une différence significative dans les lignes diagonales. Le décalage fonctionne comme l’objectif d’une caméra dans ce cas, créant une torsion dans la forme cylindrique d’origine.

List.FilterByBooleanMask

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.

List.FilterByBooleanMask supprime certains éléments en fonction d’une liste de valeurs booléennes ou les valeurs « true » ou « false ».

Pour créer une liste de valeurs « true » ou « false », vous devez travailler un peu plus…

1. À l’aide d’un nœud Code Block, définissez une expression avec la syntaxe : 0..List.Count(list);. Connectez le nœud Curve.PointAtParameter à l’entrée list. Vous allez découvrir davantage cette configuration dans le chapitre relatif aux blocs de code, mais la ligne de code dans ce cas présente une liste représentant chaque index du nœud Curve.PointAtParameter.

2. À l’aide d’un nœud %** (module)**, connectez la sortie du nœud Code Block à l’entrée x, et une valeur de 4 à l’entrée y. Vous obtiendrez ainsi le reste lors de la division de la liste d’index par 4. Le module est un nœud très utile pour la création de réseaux. Toutes les valeurs sont lues comme étant les restes possibles de 4 : 0, 1, 2, 3.

3. Grâce au nœud %** (module)**, vous savez qu’une valeur de 0 signifie que l’index est divisible par 4 (0, 4, 8, etc.). À l’aide d’un nœud ==, vous pouvez tester la visibilité en effectuant un test sur une valeur de « 0 ».

4. Le nœud Watch montre que vous avez un motif true/false qui indique : true,false,false,false….

5. À l’aide de ce motif true/false, connectez-vous à l’entrée mask de deux nœuds List.FilterByBooleanMask.

6. Connectez le nœud Curve.PointAtParameter à chaque entrée list de List.FilterByBooleanMask.

7. La sortie de Filter.ByBooleanMask indique « in » et « out ». L’expression « in » représente les valeurs qui avaient une valeur de masque « true » et l’expression « out » représente les valeurs qui avaient la valeur « false ». En connectant les sorties « in » aux entrées startPoint et endPoint d’un nœud Line.ByStartPointEndPoint, vous avez créé une liste filtrée de lignes.

8. Le nœud Watch3D indique que vous avez moins de lignes que de points. Vous n’avez sélectionné que 25 % des nœuds en filtrant uniquement les valeurs réelles.

Si la forme de données la plus simple est le nombre, la méthode la plus simple pour lier ces nombres est d'utiliser les mathématiques. Des opérateurs simples, tels que la division, aux fonctions trigonométriques et aux formules plus complexes, Math est un excellent moyen de commencer à explorer les relations numériques et les motifs.

Opérateurs arithmétiques

Les opérateurs sont un ensemble de composants qui utilisent des fonctions algébriques avec deux valeurs numériques d'entrée, ce qui génère une valeur de sortie unique (addition, soustraction, multiplication, division, etc.). Ces commandes sont disponibles sous Opérateurs > Actions.

Exercice : Formule de la clothoïde dorée

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.

Partie I : Formule paramétrique

Combinez les opérateurs et les variables pour créer une relation plus complexe à l’aide de formules. Utilisez les curseurs pour créer une formule qui peut être contrôlée à l’aide des paramètres d’entrée.

1. Créez une séquence de nombres qui représente le « t » dans l’équation paramétrique. Vous devez donc utiliser une liste suffisamment grande pour définir une clothoïde.

Number Sequence : définissez une séquence de nombres reposant sur les trois entrées start, amount et step.

2. L’étape ci-dessus a permis de créer une liste de nombres pour définir le domaine paramétrique. Ensuite, créez un groupe de nœuds représentant l’équation de la clothoïde dorée.

La clothoïde dorée est définie comme l’équation suivante :

L’image ci-dessous représente la spirale dorée sous forme de programmation visuelle. Lorsque vous parcourez le groupe de nœuds, essayez de faire le parallèle entre le programme visuel et l’équation écrite.

a. Number Slider : ajoutez deux curseurs de numérotation dans la zone de dessin. Ces curseurs représentent les variables a et b de l’équation paramétrique. Elles représentent une constante flexible, ou des paramètres que vous pouvez ajuster afin d’obtenir le résultat souhaité.

b. Multiplication (*) : le nœud de multiplication est représenté par un astérisque. Vous utiliserez ce nœud à plusieurs reprises pour connecter des variables de multiplication.

c. Math.RadiansToDegrees : les valeurs « t » doivent être converties en degrés pour être évaluées dans les fonctions trigonométriques. N’oubliez pas que Dynamo utilise par défaut les degrés pour évaluer ces fonctions.

d. Math.Pow : la fonction de « t » et le numéro « e » permettent de créer la séquence Fibonacci.

e. Math.Cos et Math.Sin : ces deux fonctions trigonométriques différencient respectivement la coordonnée x et la coordonnée y de chaque point paramétrique.

f. Watch : le résultat obtenu se compose de deux listes. Elles représentent les coordonnées x et y des points utilisés pour générer la clothoïde.

Partie II : De la formule à la géométrie

Point.ByCoordinates : connectez le nœud de multiplication supérieur à l’entrée « x » et le nœud inférieur à l’entrée « y ». Une clothoïde paramétrique de points apparaît à l’écran.

Polycurve.ByPoints : connectez Point.ByCoordinates de l’étape précédente à points. Vous pouvez laisser connectLastToFirst sans entrée, car vous ne créez pas de courbe fermée. Cela permet de créer une spirale qui passe par chaque point défini à l’étape précédente.

La clothoïde de Fibonacci est désormais terminée. Vous allez désormais effectuer deux exercices distincts, appelés Nautilus et Tournesol. Ce sont des abstractions de systèmes naturels, mais qui représentent bien les deux applications différentes de la clothoïde de Fibonacci.

Partie III : De la clothoïde au Nautilus

Circle.ByCenterPointRadius : utilisez un nœud circulaire avec les mêmes entrées que celles de l’étape précédente. Étant donné que la valeur du rayon par défaut est de 1,0, un réseau de cercles apparaît immédiatement. La façon dont les points divergent à partir du point d’origine est immédiatement lisible.

Number Sequence : réseau d’origine de « t ». Si vous connectez ceci à la valeur du rayon de Circle.ByCenterPointRadius, les centres des cercles divergent davantage à partir de l’origine, mais le rayon des cercles augmente, créant ainsi un super graphique circulaire de Fibonacci.

Et c’est encore mieux en 3D !

Partie IV : Du Nautilus à la phyllotaxie

Comme point de départ, commencez par la même étape qu’à l’exercice précédent : la création d’un réseau de points en forme de spirale avec le nœud Point.ByCoordinates.


Ensuite, suivez ces courtes étapes pour générer une série de clothoïdes à différentes rotations.

a. Geometry.Rotate : il existe plusieurs options Geometry.Rotate. Assurez-vous d’avoir choisi le nœud avec les entrées geometry, basePlane et degrees. Connectez Point.ByCoordinates à l’entrée geometry. Cliquez avec le bouton droit de la souris sur ce nœud et assurez-vous que la combinaison est définie sur « Produit vectoriel ».

b. Plane.XY : connexion à l’entrée basePlane. Vous allez effectuer une rotation autour de l’origine, servant également de base pour la clothoïde.

c. Number Range : pour la saisie des degrés, vous devez créer plusieurs rotations. Pour ce faire, il suffit d’utiliser un composant Number Range. Connectez-le à l’entrée degrees.

d. Number : pour définir l’intervalle de nombres, ajoutez trois nœuds Number à la zone de dessin dans l’ordre vertical. De haut en bas, affectez respectivement les valeurs 0.0, 360.0 et 120.0. Elles pilotent la rotation de la clothoïde. Après avoir connecté les trois nœuds Number au nœud Range, observez les sorties du nœud Number Range.

Le résultat obtenu commence à ressembler à un tourbillon. Ajustez certains paramètres de Number Range et observez le changement des résultats.

Modifiez la taille du pas du nœud Number Range de 120.0 à 36.0. Cette action crée davantage de rotations et permet donc d’obtenir une grille plus dense.

Modifiez la taille du pas du nœud Number Range de 36.0 à 3.6. Vous obtenez une grille beaucoup plus dense, et la direction de la clothoïde n’est pas claire. Bravo, vous avez créé un tournesol.

Les dictionnaires représentent un ensemble de données liées à un autre élément de données appelé clé. Les dictionnaires permettent de rechercher, de supprimer et d'insérer des données dans une collection.

En fait, nous pouvons considérer un dictionnaire comme une manière vraiment intelligente de rechercher quelque chose.

Bien que la fonctionnalité de dictionnaire soit disponible dans Dynamo depuis un certain temps déjà, Dynamo 2.0 propose une nouvelle méthode de gestion de ce type de données.

Pour compliquer la tâche, vous allez ajouter encore plus de niveaux à la hiérarchie. La structure des données peut s'étendre au-delà d'une liste bidimensionnelle de listes. Étant donné que les listes sont des éléments dans Dynamo, vous pouvez créer des données avec autant de dimensions que possible.

L'analogie utilisée ici est celle des poupées russes. Chaque liste peut être considérée comme un conteneur contenant plusieurs éléments. Chaque liste possède ses propres propriétés et est considérée comme son propre objet.

L’ensemble de poupées russes (photo de Zeta) est une analogie pour les listes dimensionnelles. Chaque couche représente une liste et chaque liste contient des éléments. Dans le cas de Dynamo, chaque conteneur peut contenir plusieurs conteneurs (représentant les éléments de chaque liste).

Les listes à n dimensions sont difficiles à expliquer visuellement, mais vous allez découvrir dans ce chapitre quelques exercices axés sur des listes de plus de deux dimensions.

Mappage et combinaisons

Le mappage est sans doute la partie la plus complexe de la gestion des données dans Dynamo, et est particulièrement utile lorsque vous travaillez avec des hiérarchies de listes complexes. Grâce à la série d’exercices ci-dessous, vous allez découvrir quand utiliser le mappage et les combinaisons à mesure que les données deviennent multidimensionnelles.

Les nœuds List.Map et List.Combine sont présentés dans la section précédente. Dans le dernier exercice ci-dessous, vous allez utiliser ces nœuds sur une structure de données complexe.

Exercice - Listes 2D - Basique

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.

Cet exercice est le premier d'une série de trois exercices axés sur l'articulation de la géométrie importée. Chaque partie de cette série d’exercices va accroître la complexité de la structure des données.

1. Commencez par le fichier .sat dans le dossier des fichiers d’exercice. Vous pouvez sélectionner ce fichier à l’aide du nœud File Path.

2. Avec Geometry.ImportFromSAT, la géométrie est importée dans l’aperçu Dynamo en tant que deux surfaces.

Dans le cadre de cet exercice, utilisez l’une des surfaces pour faire simple.

1. Sélectionnez l’index de 1 pour sélectionner la surface supérieure. Pour ce faire, utilisez le nœud List.GetItemAtIndex.

2. Désactivez l’aperçu de la géométrie à partir de l’aperçu de Geometry.ImportFromSAT.

L’étape suivante consiste à diviser la surface en une grille de points.

1. À l’aide d’un nœud Code Block, insérez les deux lignes de code suivantes : 0..1..#10; 0..1..#5;

2. Avec le nœud Surface.PointAtParameter, connectez les deux valeurs de Code Block à u et v. Définissez la combinaison de ce nœud sur « Produit vectoriel ».

3. La sortie révèle la structure des données, également visible dans l’aperçu Dynamo.

Ensuite, utilisez les points de la dernière étape pour générer dix courbes le long de la surface.

1. Pour voir comment la structure de données est organisée, connectez un nœud NurbsCurve.ByPoints à la sortie de Surface.PointAtParameter.

2. Vous pouvez désactiver l’aperçu du nœud List.GetItemAtIndex pour obtenir un résultat plus clair.

1. Un nœud List.Transpose de base permet d’inverser les colonnes et les lignes d’une liste de listes.

2. Lorsque vous connectez la sortie de List.Transpose à NurbsCurve.ByPoints, vous obtenez cinq courbes placées horizontalement sur la surface.

3. Vous pouvez désactiver l’aperçu du nœud NurbsCurve.ByPoints à l’étape précédente pour obtenir le même résultat dans l’image.

Exercice - Listes 2D - Avancé

Passons aux choses sérieuses. Imaginez que vous souhaitiez effectuer une opération sur les courbes créées lors de l'exercice précédent. Vous devrez peut-être lier ces courbes à une autre surface et effectuer un lissage entre elles. Pour ce faire, il convient d’accorder une plus grande attention à la structure des données, même si la logique sous-jacente est la même.

1. Commencez par une étape de l’exercice précédent : isolez la surface supérieure de la géométrie importée grâce au nœud List.GetItemAtIndex.

1. À l’aide du nœud Surface.Offset, décalez la surface par une valeur de 10.

1. De la même façon que dans l’exercice précédent, définissez un nœud Code Block avec les deux lignes de code suivantes : 0..1..#10; 0..1..#5;

2. Connectez ces sorties à deux nœuds Surface.PointAtParameter dont la combinaison est définie sur « Produit vectoriel ». L’un de ces nœuds est connecté à la surface d’origine, tandis que l’autre est connecté à la surface décalée.

1. Désactivez l’aperçu de ces surfaces.

2. Comme dans l’exercice précédent, connectez les sorties à deux nœuds NurbsCurve.ByPoints. Le résultat affiche les courbes correspondant à deux surfaces.

1. Le nœud List.Create vous permet de combiner les deux jeux de courbes en une liste de listes.

2. La sortie affiche deux listes contenant chacune dix éléments, représentant chaque ensemble de connexions de courbes NURBS.

3. Grâce au nœud Surface.ByLoft, vous pouvez visualiser cette structure de données. Le nœud lisse toutes les courbes de chaque sous-liste.

1. Désactivez l’aperçu du nœud Surface.ByLoft à l’étape précédente.

2. Si vous utilisez le nœud List.Transpose, n’oubliez pas qu’il permet de retourner toutes les colonnes et les lignes. Ce nœud convertit deux listes de dix courbes en dix listes de deux courbes. Chaque courbe NURBS est désormais liée à la courbe voisine sur l’autre surface.

3. Le nœud Surface.ByLoft vous permet d’obtenir une structure nervurée.

Vous allez ensuite découvrir un autre processus pour atteindre ce résultat.

1. Avant de commencer, désactivez l’aperçu de Surface.ByLoft à l’étape précédente pour éviter toute confusion.

2. Le nœud List.Combine constitue une alternative au nœud List.Transpose. Il exécute un « combinateur » sur chaque sous-liste.

3. Dans ce cas, vous utilisez List.Create en tant que « combinateur » qui va créer une liste de chaque élément dans les sous-listes.

4. Le nœud Surface.ByLoft vous permet d’obtenir les mêmes surfaces que lors de l’étape précédente. L’option Transposer est plus facile à utiliser dans ce cas, mais lorsque la structure de données devient encore plus complexe, le nœud List.Combine s’avère plus fiable.