À propos

Guide Dynamo
Pour Dynamo v2.0
Téléchargez le guide Dynamo v1.3 ici

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.

Il 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. Voici ce que vous pouvez attendre de ce guide :

Contexte : qu'est-ce que la "programmation visuelle" et quels sont les concepts à comprendre pour explorer Dynamo ?
Mise en route : comment obtenir Dynamo et créer un premier programme ?
Qu'est-ce qu'un programme : quelles sont les fonctionnalités de Dynamo et comment les utiliser ?
Blocs de construction : que sont les données et quels en sont les types fondamentaux à utiliser dans mes programmes ?
Géométrie pour la conception : comment utiliser les éléments géométriques dans Dynamo ?
Listes, listes, listes : comment gérer et coordonner les structures de données ?
Code dans les nœuds : comment commencer à étendre Dynamo avec son propre code ?
Solution informatique BIM : comment utiliser Dynamo avec un modèle Revit ?
Nœuds personnalisés : comment créer ses propres nœuds ?
Packages : comment partager ses outils avec la communauté ?

C'est une occasion passionnante de découvrir Dynamo, de travailler avec Dynamo et de faire du développement pour Dynamo. C'est parti !

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 : [Link]

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 : [Link]

Le projet Dynamo Primer

Dynamo Primer 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.
Table of Contents
1. À propos 0
2. Introduction 1
1. Qu'est-ce que la programmation visuelle ? 1.1
2. Définition de Dynamo 1.2
3. Dynamo en action 1.3
3. Bonjour Dynamo ! 2
1. Installation et lancement de Dynamo 2.1
2. Interface utilisateur 2.2
3. L'espace de travail 2.3
4. Prise en main 2.4
4. Anatomie d'un programme visuel 3
1. Nœuds 3.1
2. Fils 3.2
3. Bibliothèque 3.3
4. Gestion de votre programme 3.4
5. Blocs de construction des programmes 4
1. Données 4.1
2. Math 4.2
3. Logique 4.3
4. Chaînes 4.4
5. Couleur 4.5
6. Géométrie pour la conception informatique 5
1. Présentation de la géométrie 5.1
2. Vecteurs 5.2
3. Points 5.3
4. Courbes 5.4
5. Surfaces 5.5
6. Solides 5.6
7. Maillages 5.7
8. Importation de géométrie 5.8
7. Conception avec des listes 6
1. Qu'est-ce qu'une liste 6.1
2. Utilisation des listes 6.2
3. Listes de listes 6.3
4. Listes à n dimensions 6.4
8. Blocs de code et DesignScript 7
1. Qu'est-ce qu'un bloc de code ? 7.1
2. Syntaxe DesignScript 7.2
3. Raccourci 7.3
4. Fonctions 7.4
9. Dynamo for Revit 8
1. La connexion Revit 8.1
2. Sélection 8.2
3. Modification 8.3
4. Création 8.4
5. Personnalisation 8.5
6. Documentation 8.6
10. Dictionnaires dans Dynamo 9
1. Qu'est-ce qu'un dictionnaire ? 9.1
2. Utilisations des nœuds 9.2
3. Utilisations des blocs de code 9.3
4. Cas d'utilisation 9.4
11. Nœuds personnalisés 10
1. Présentation des nœuds personnalisés 10.1
2. Création d'un nœud personnalisé 10.2
3. Publication dans votre bibliothèque 10.3
4. Nœuds Python 10.4
5. Python et Revit 10.5
6. Gabarits Python dans Dynamo 2.0 10.6
12. Packages 11
1. Présentation des packages 11.1
2. Étude de cas de package – Mesh Toolkit 11.2
3. Développement d'un module 11.3
4. Publication d'un package 11.4
5. Importation Zero-Touch 11.5
13. Géométrie avec DesignScript 12
1. Concepts de base de la géométrie DesignScript 12.1
2. Primitives géométriques 12.2
3. Calcul vectoriel 12.3
4. Courbes : points de contrôle et interpolés 12.4
5. Conversion, rotation et autres transformations 12.5
6. Surfaces : interpolation, points de contrôle, lissage, révolution 12.6
7. Définition des paramètres géométriques 12.7
8. Intersection et ajustement 12.8
9. Opérations booléennes géométriques 12.9
10. Générateurs de points Python 12.10
14. Pratiques recommandées 13
1. Stratégies de graphiques 13.1
 2. Stratégies de script 13.2
3. Références concernant la création et la gestion des scripts 13.3
15. Annexe 14
1. Ressources 14.1
2. Index des nœuds 14.2
3. Packages utiles 14.3
4. Fichiers d'exemple 14.4
John Pierson de Parallax Team a été chargé de mettre à jour le guide pour qu’il contienne les révisions de Dynamo 2.0.

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

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

Logiciels et ressources
Dynamo La version stable* actuelle de Dynamo est la version 2.1.0

[Link] ou [Link]

*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.

[Link]

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

[Link]

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

Dynamo@[Link]

Licence
Copyright 2019 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

[Link]

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.
Introduction
Introduction
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 ?
Qu'est-ce que la programmation visuelle ?
Qu'est-ce que la programmation visuelle ?

L'activité de conception implique souvent l'établissement de relations visuelles, systémiques ou géométriques entre les différentes parties d'une conception.
La plupart du temps, ces relations sont développées par des workflows qui permettent de passer du concept au résultat grâce à des règles. Sans le savoir,
vous travaillez par le biais d'algorithmes, c'est-à-dire en définissant un ensemble d'actions progressives qui suivent une logique de base d'entrée, de
traitement et de sortie. La programmation permet de travailler de cette façon, mais tout en appliquant des algorithmes.

Présentation des algorithmes

Même s'il offre de puissantes opportunités, le terme algorithme peut véhiculer quelques idées fausses. Les algorithmes peuvent générer des éléments
inattendus, imprévisibles ou sympas, mais ils ne sont pas magiques. Ils sont en réalité assez simples, tels qu'ils sont. Prenez un exemple concret comme une
grue en origami. Tout d'abord, prenez une feuille de papier carrée (entrée), puis suivez une série d'étapes de pliage (actions de traitement) afin d'obtenir une
grue (sortie).

Où est l'algorithme ? Il s'agit de l'ensemble d'étapes abstrait qu'il est possible de représenter de deux façons : textuellement ou graphiquement.

Instructions textuelles :

1. Tout d'abord, prenez une feuille de papier carrée, la partie colorée vers le haut. Pliez la feuille en deux et ouvrez-la. Ensuite, pliez la feuille en deux
de l'autre côté.
2. Retournez la feuille, côté blanc vers le haut. Pliez la feuille en deux, marquez bien le pli et ouvrez la feuille, puis repliez-la dans l'autre sens.
3. En utilisant les plis que vous avez faits, placez les 3 coins supérieurs du modèle vers le bas. Aplanissez le modèle.
4. Pliez les rabats triangulaires supérieurs au centre, puis dépliez-lez.
5. Pliez la partie supérieure du modèle vers le bas, marquez bien le pli et dépliez.
6. Ouvrez le rabat supérieur du modèle en le ramenant vers le haut et en appuyant simultanément sur les côtés du modèle vers l'intérieur. Aplanissez et
marquez bien le pli.
7. Retournez le modèle et répétez les étapes 4 à 6 de l'autre côté.
8. Pliez les rabats supérieurs vers le centre.
9. Répétez l'opération de l'autre côté.
10. Pliez les deux "jambes" du modèle vers le haut, marquez bien les plis, puis dépliez.
11. Ramenez les "jambes" vers l'intérieur le long des plis que vous venez de faire.
12. Ramenez les pointes à l'intérieur afin de créer une tête, puis pliez les ailes.
13. Vous obtenez une grue.

Instructions graphiques :
Programmation définie

Ces séries d'instructions permettent toutes les deux de créer une grue, et si vous avez correctement suivi les étapes, vous avez appliqué un algorithme. La
seule différence est la façon dont vous lisez l'application de cet ensemble d'instructions qui conduit à la programmation. La programmation, terme
couramment employé pour la programmation informatique, consiste à formaliser le traitement d'une série d'actions dans un programme exécutable. Si vous
écrivez les instructions susmentionnées (permettant de créer une grue) dans un format que votre ordinateur peut lire et exécuter, vous faites de la
programmation.

La clé, mais aussi le premier obstacle de la programmation, est de s'appuyer sur une forme abstraite afin de communiquer efficacement avec son ordinateur.
Cela prend la forme de n'importe quel langage de programmation, tel que JavaScript, Python ou C. Si vous pouvez écrire un ensemble d'instructions
reproductibles, comme pour la grue en origami, vous n'avez besoin de le traduire que pour l'ordinateur. Vous êtes en passe de configurer l'ordinateur pour
que ce dernier puisse créer une grue ou même une multitude de grues différentes où chacune varie légèrement. C'est la puissance de la programmation :
l'ordinateur exécute plusieurs fois les tâches, ou ensembles de tâches, que vous lui affectez, sans délai ni erreur humaine.

Programmation visuelle définie

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : Visual
Programming - Circle Through [Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Si vous étiez chargé d'écrire des instructions de pliage afin de créer une grue en origami, comment procéderiez-vous ? Voulez-vous les créer sous forme de
graphiques, de texte ou une combinaison des deux ?

Si votre réponse contenait des graphiques, alors la programmation visuelle est certainement pour vous. Le processus est pratiquement le même pour la
programmation que pour la programmation visuelle. Elles utilisent le même cadre d'application ; cependant, vous définissez les instructions et les relations
de votre programme par le biais d'une interface utilisateur graphique (ou "visuelle"). Au lieu de taper du texte lié par syntaxe, vous connectez des nœuds
pré-intégrés ensemble. Voici une comparaison de l'algorithme "dessiner un cercle par point" programmé avec des nœuds ou du code :

Programme visuel :

Programme textuel :
myPoint = [Link](0.0,0.0,0.0);
x = 5.6;
y = 11.5;
attractorPoint = [Link](x,y,0.0);
dist = [Link](attractorPoint);
myCircle = [Link](myPoint,dist);

Résultats de l'algorithme :

La caractéristique visuelle de la programmation permet de réduire les obstacles à l'entrée et de communiquer fréquemment avec les concepteurs. Dynamo
est intégré dans le paradigme de la programmation visuelle, mais vous verrez plus tard qu'il est également possible d'utiliser la programmation textuelle dans
l'application.
Définition de Dynamo
Définition de Dynamo
Dynamo est, pour ainsi dire, ce que vous en faites. Travailler avec Dynamo peut impliquer l'utilisation de l'application, en relation ou non avec d'autres
logiciels Autodesk, la mise en place d'un processus de programmation visuelle ou la participation à une vaste communauté d'utilisateurs et de contributeurs.

Application

L'application Dynamo est un logiciel qui peut être téléchargé et exécuté en mode "Sandbox" autonome ou en tant que plug-in pour d'autres logiciels tels que
Revit ou Maya. Elle est décrite comme suit :

Dynamo est un outil de programmation visuel dont l'intérêt vient de son accessibilité auprès des utilisateurs, qu'ils soient programmateurs ou non.
Ceux-ci ont la possibilité de rédiger visuellement le script de comportement, de définir des éléments de logique personnalisés ainsi que de rédiger du
script à l'aide de divers langages de programmation textuelle.

1. Voir Dynamo en action avec Revit

2. Télécharger le programme d'installation

Processus
Une fois l'application installée, 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.

Ajoutez des éléments, connectez-les et vous serez prêts pour la création de programmes visuels.
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.
Dynamo en action
DYNAMO EN ACTION
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.

Bonjour Dynamo !
BONJOUR DYNAMO !
Dynamo est une plate-forme de programmation visuelle. Il s'agit d'un outil de conception flexible et extensible. Étant donné qu'il peut fonctionner en tant
qu'application autonome ou en tant que complément à d'autres logiciels de conception, vous pouvez l'utiliser pour développer une large gamme de
workflows créatifs. Installez Dynamo et commencez par examiner les principales fonctionnalités de l'interface.
Installation et lancement de Dynamo
Installation et lancement de Dynamo
Dynamo est un projet de développement open source actif avec des programmes d'installation téléchargeables pour les versions officielles et préliminaires,
c'est-à-dire pour les versions quotidiennes. Téléchargez la version officielle pour commencer ou contribuez à la transformation de Dynamo grâce aux
versions quotidiennes ou au projet GitHub.

Téléchargement

Pour télécharger la version officielle de Dynamo, rendez-vous sur le site Web de Dynamo. Lancez le téléchargement immédiatement en cliquant sur la page
d'accueil ou accédez à la page de téléchargement dédiée.

1. Regardez la vidéo sur la conception informatique avec Dynamo for Architecture.

2. Ou accédez à la page de téléchargement.

Ici, vous pouvez télécharger les toutes dernières versions de développement ou accéder au projet Dynamo Github.
 1. Téléchargez le programme d'installation de la version officielle.
2. Téléchargez les programmes d'installation de build quotidiens.
3. Découvrez les packages personnalisés d'une communauté de développeurs.
4. Participez au développement de Dynamo sur GitHub.

Installation

Accédez au répertoire du programme d'installation téléchargé et lancez le fichier exécutable. Au cours de l'installation, le programme vous permet de
personnaliser les composants qui seront installés.

1. Choisissez les composants à installer.

Ici, vous devez décider si vous voulez inclure les composants qui font le lien entre Dynamo et d'autres applications installées, telles que Revit. Pour plus
d'informations sur la plate-forme Dynamo, reportez-vous au chapitre 1.2.

Lancement

Pour lancer Dynamo, accédez au dossier \Program Files\Dynamo\Dynamo Revit\x.y, puis choisissez [Link]. Cette action permet d'ouvrir la
version autonome et de présenter la page de démarrage de Dynamo. Sur cette page, vous pouvez voir les menus et barres d'outils standard, ainsi qu'un
ensemble de raccourcis qui vous permettent d'accéder aux fonctionnalités des fichiers ou à des ressources supplémentaires.

1. Fichiers : permet de démarrer un nouveau fichier ou d'ouvrir un fichier existant

2. Récent : permet de faire défiler les fichiers récents
3. Sauvegarde : permet d'accéder à vos sauvegardes
4. Demander : permet d'accéder directement au forum des utilisateurs ou au site Web de Dynamo
5. Référence : permet d'accéder à d'autres ressources de formation
6. Code : permet de participer au projet de développement open source
7. Exemples : permet de voir les exemples fournis avec l'installation
Ouvrez le premier fichier d'exemple pour ouvrir votre premier espace de travail et confirmer que Dynamo fonctionne correctement. Cliquez sur Exemples >
Outils de base > Basics_Basic01.dyn.

1. Vérifiez que la barre d'exécution indique "Automatique" ou cliquez sur Exécuter.

2. Suivez les instructions et connectez le nœud Number au nœud +.
3. Vérifiez que ce nœud Watch affiche un résultat.

Si ce fichier se charge correctement, vous devriez pouvoir exécuter votre premier programme visuel avec Dynamo.
Interface utilisateur
Interface utilisateur de Dynamo
L'interface utilisateur de Dynamo est organisée en cinq zones principales, la plus grande étant l'espace de travail dans lequel vous créez les programmes
visuels.

1. Menus
2. Barre d'outils
3. Bibliothèque
4. Espace de travail
5. Barre d'exécution

Explorons l'interface utilisateur, ainsi que les fonctionnalités de chaque zone.

Menus

Les menus déroulants permettent de trouver rapidement certaines des fonctionnalités de base de l'application Dynamo. Comme la plupart des logiciels
Windows, les deux premiers menus proposent des actions relatives à la gestion des fichiers et des opérations de sélection et de modification du contenu. Les
autres menus sont plus spécifiques de Dynamo.
 1. Fichier
2. Modifier
3. Affichage
4. Packages
5. Paramètres
6. Aide
7. Notifications

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.
 1. Nouveau : permet de créer un fichier .dyn.
2. Ouvrir : permet d'ouvrir un fichier .dyn (espace de travail) ou .dyf (nœud personnalisé) existant.
3. Enregistrer/Enregistrer sous : permet d'enregistrer votre fichier .dyn ou .dyf actif.
4. Annuler : permet d'annuler la dernière action.
5. Rétablir : permet de rétablir la prochaine action.
6. Exporter l'espace de travail en tant qu'image : permet d'exporter l'espace de travail visible en tant que fichier PNG.

Bibliothèque

La bibliothèque contient tous les nœuds chargés, y compris les nœuds 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 selon que les nœuds créent des données, exécutent une action ou interrogent des données.

Navigation

Par défaut, la bibliothèque contient huit catégories de nœuds. Core et Geometry sont d'excellents menus à explorer en premier, car ils contiennent la plus
grande quantité de nœuds. 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.

Passez maintenant à l'ensemble de nœuds par défaut. Notez que nous étendrons ultérieurement cette bibliothèque avec des nœuds personnalisés, des
bibliothèques supplémentaires et le gestionnaire de package.
 1. Dictionnaire
2. Afficher
3. Geometry
4. ImportExport
5. Entrée
6. Liste
7. Correspondances
8. Revit
9. Script
10. Chaîne
11. Compléments

Parcourez la bibliothèque en cliquant sur les menus. Cliquez sur Geometry > Curves > Circle. Une nouvelle partie du menu et notamment les libellés Créer
et Requête s'affichent.

1. Bibliothèque
2. Catégorie
3. Sous-catégorie : Create/Actions/Query
4. Nœud
5. Description du nœud et propriétés : cet encadré s'affiche lorsque vous placez le curseur sur l'icône du nœud.
Dans le même menu Circle, placez le curseur de la souris sur ByCenterPointRadius. La fenêtre affiche des informations plus détaillées sur le nœud, en
plus de son nom et de 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

Si vous avez une idée du nœud que vous souhaitez ajouter à votre espace de travail, le champ Rechercher est votre meilleur ami. Lorsque vous ne modifiez
pas les paramètres ni ne spécifiez de valeurs dans l'espace de travail, le curseur est toujours présent dans ce champ. Si vous commencez à taper, la
bibliothèque Dynamo affiche la meilleure correspondance sélectionnée (avec les chemins de navigation afin de savoir où elle se trouve dans les catégories
de nœud) et une liste d'autres correspondances avec la recherche. Lorsque vous appuyez sur Entrée ou cliquez sur l'article dans le navigateur tronqué, le
nœud mis en surbrillance est ajouté au centre de l'espace de travail.

1. Champ de recherche
2. Meilleur résultat/Sélection
3. Autres correspondances
Paramètres

Ces options, de la géométrie aux paramètres utilisateur, sont disponibles dans le menu Paramètres. Vous pouvez choisir d'activer ou de désactiver le
partage des données utilisateur dans le but d'améliorer Dynamo et de définir la précision décimale de l'application et la qualité du rendu de la géométrie.

1. Activation de la génération de rapports : options de partage des données utilisateur permettant d'améliorer Dynamo.
2. Afficher l'aperçu d'exécution : permet d'afficher un aperçu de l'état d'exécution du graphique. Les nœuds programmés pour l'exécution sont mis
en surbrillance dans le graphique.
3. Options de format de nombre : permet de modifier les paramètres du document concernant les décimales.
4. Précision du rendu : permet d'augmenter ou de réduire la qualité du rendu du document.
5. Mise à l'échelle de géométrie : permet de sélectionner la plage de géométrie sur laquelle vous travaillez.
6. Isoler la géométrie sélectionnée : géométrie d'arrière-plan isolée fondée sur votre sélection de nœuds.
7. Afficher/masquer les arêtes de géométrie : permet d'activer ou de désactiver les arêtes de géométrie 3D.
8. Afficher/masquer les bulles d'aperçu : permet d'activer ou de désactiver les bulles d'aperçu des données sous les nœuds.
9. Gérer les chemins de nœud et de package : permet de gérer les chemins d'accès aux fichiers pour que les nœuds et les packages s'affichent dans
la bibliothèque.
10. Activation des fonctionnalités expérimentales : utilisez les nouvelles fonctionnalités bêta de Dynamo.

Aide

Si vous êtes bloqué, consultez le menu Aide. Vous pouvez trouver ici les fichiers d'exemple fournis avec votre installation, et accéder à l'un des sites Web
de référence Dynamo via votre navigateur Internet. Si nécessaire, vérifiez la version de Dynamo installée et si elle est à jour via l'option À propos de.
1. Mise en route : brève introduction à l'utilisation de Dynamo.
2. Exemples : fichiers d'exemple de référence.
3. Ouvrir le dictionnaire Dynamo : ressource avec documentation sur tous les nœuds.
4. Signaler un bogue : permet d'ouvrir un problème sur GitHub.
5. Accéder au site Web du projet : permet d'afficher le projet Dynamo sur GitHub.
6. Accéder au wiki du projet : 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. À propos : données relatives à la version de Dynamo.
L'espace de travail
L'espace de travail
L'espace de travail Dynamo permet de développer des programmes visuels, mais également d'afficher un aperçu de la géométrie obtenue. Que vous
travailliez dans un espace de travail d'accueil ou un nœud personnalisé, utilisez la souris ou les boutons situés en haut à droite pour naviguer dans l'interface.
Basculer entre les modes situés en bas à droite permet de basculer entre les différents aperçus que vous naviguez.

Remarque : étant donné que les nœuds et la géométrie ont un ordre de tracé, vous pouvez avoir des objets rendus les uns sur les autres. Cela peut être
difficile lorsque vous ajoutez plusieurs nœuds dans l'ordre, car ils peuvent être rendus dans la même position dans l'espace de travail.

1. Onglets
2. Boutons Zoom/Panoramique
3. Mode aperçu
4. Double-clic sur l'espace de travail

Onglets
L'onglet Espace de travail actif vous permet de parcourir et de modifier votre programme. Lorsque vous ouvrez un nouveau fichier, vous ouvrez par défaut
un nouvel espace de travail d'accueil. Vous pouvez également ouvrir un nouvel espace de travail Nœud personnalisé à partir du menu Fichier ou de l'option
Nouveau nœud de la sélection accessible par un clic droit lorsque les nœuds sont sélectionnés (plus d'informations sur cette fonctionnalité ultérieurement).
 Remarque : il se peut que vous n'ayez qu'un seul espace de travail d'accueil ouvert à la fois. Toutefois, plusieurs espaces de travail de nœud
personnalisés peuvent être ouverts dans d'autres onglets.

Navigation entre le graphique et l'aperçu 3D

Dans Dynamo, le graphique et les résultats 3D du graphique (dans le cas de la création de la géométrie) sont rendus dans l'espace de travail. Par défaut,
l'aperçu actif est le graphique. Par conséquent, l'utilisation des boutons de navigation ou de la molette de la souris pour effectuer un panoramique et un zoom
vous permet de vous déplacer dans le graphique. Vous pouvez basculer entre les aperçus actifs de trois façons différentes :

1. Boutons d'option d'aperçu dans l'espace de travail

2. Cliquez avec le bouton droit de la souris dans l'espace de travail et sélectionnez Passez à une vue...
3. Raccourci clavier (Ctrl + B)

Le mode de navigation de l'aperçu 3D permet également de manipuler directement les points, comme illustré dans la rubrique Mise en route.

Zoom pour recentrer

En mode de navigation de l'aperçu 3D, vous pouvez facilement effectuer des panoramiques, des zooms et des rotations autour des modèles. Toutefois, pour
effectuer un zoom spécifique sur un objet créé par un nœud de géométrie, utilisez l'icône Zoom tout avec un seul nœud sélectionné.
 1. Sélectionnez le nœud correspondant à la géométrie qui permet de centrer la vue.
2. Passez à la navigation de l'aperçu 3D.

1. Cliquez sur l'icône Zoom tout située dans la partie supérieure droite.
2. La géométrie sélectionnée est centrée dans la vue.

Bonjour, souris !
En fonction du mode d'aperçu actif, les boutons de la souris permettent d'effectuer différentes actions. En général, le clic gauche de la souris permet de
sélectionner et de spécifier les entrées, le clic droit permet d'accéder aux options et le clic sur la molette permet de naviguer dans l'espace de travail. Le clic
droit permet d'afficher des options basées sur le contexte de sélection.
 1. Cliquez avec le bouton droit sur l'espace de travail.
2. Cliquez avec le bouton droit sur un nœud.
3. Cliquez avec le bouton droit sur une note.

Voici un tableau des interactions de la souris par aperçu :

Action de la souris Aperçu du graphique Aperçu 3D

Clic avec le bouton gauche Sélectionner N/A
Clic avec le bouton droit Menu contextuel Options de zoom
Clic sur la molette Panoramique Faire un panoramique
Défilement Zoom avant/arrière Zoom avant/arrière
Double-clic Créer un bloc de code N/A

Recherche dans la zone de dessin

La fonctionnalité "Recherche dans la zone de dessin" vous permet d'accélérer le workflow Dynamo en vous offrant un accès aux descriptions des nœuds et
aux info-bulles sans vous déplacer dans le graphique ! En cliquant avec le bouton droit de la souris, vous pouvez accéder à toutes les fonctionnalités utiles
de la "recherche de bibliothèques", où que vous soyez dans la zone de dessin.

1. Cliquez avec le bouton droit de la souris n'importe où dans la zone de dessin afin d'afficher la fonction de recherche. Lorsque la barre de
recherche est vide, la liste déroulante est un menu d'aperçu.
2. Lorsque vous saisissez du texte dans la barre de recherche, le menu déroulant est mis à jour en continu et affiche les résultats de recherche les
plus pertinents.
3. Placez le curseur sur les résultats de la recherche afin d'afficher les descriptions et les info-bulles correspondantes.

Arrangement de l'affichage des nœuds

L'organisation de votre zone de dessin Dynamo devient de plus en plus importante à mesure que vos fichiers se complexifient. Bien que l'outil Aligner la
sélection soit disponible pour de petites quantités de nœuds sélectionnées, Dynamo comprend également l'outil Arranger l'affichage des nœuds qui permet
de faciliter le nettoyage global des fichiers.

Avant l'arrangement des nœuds

1. Sélectionnez les nœuds à organiser automatiquement ou laissez-les tous désélectionnés pour tous les nettoyer du fichier.
2. La fonction Arranger l'affichage des nœuds se trouve sous l'onglet Modifier.

Après l'arrangement des nœuds

1. Les nœuds sont automatiquement répartis et alignés. Les nœuds décalés ou se chevauchant sont réarrangés et alignés avec les nœuds voisins.
Prise en main
MISE EN ROUTE
Maintenant que vous vous êtes familiarisés avec la présentation de l'interface et la navigation dans l'espace de travail, l'étape suivante consiste à comprendre
le workflow classique afin de développer un graphique dans Dynamo. Commencez par créer un cercle de taille dynamique, puis créez un réseau de cercles
de rayon variable.

Définition des objectifs et des relations

Avant d'ajouter quoi que ce soit à l'espace de travail Dynamo, il est essentiel de bien comprendre votre objectif et les relations importantes utilisées.
N'oubliez pas que chaque fois que vous connectez deux nœuds, vous créez un lien explicite entre eux. Vous pouvez modifier le flux de données
ultérieurement, mais une fois la connexion établie, cette relation est engagée. Dans cet exercice, vous allez créer un cercle (objectif) dans lequel l'entrée
radius est définie par une distance par rapport à un point situé à proximité (relation).

Un point qui définit une relation basée sur la distance est généralement appelé "point d'attraction". Ici, la distance jusqu'au point d'attraction est utilisée
pour spécifier la taille du cercle.

Ajout de nœuds à l'espace de travail

Maintenant que vos objectifs et relations sont schématisés, vous pouvez commencer à créer votre graphique. Vous avez besoin des nœuds qui représentent
la séquence d'actions exécutée par Dynamo. Étant donné que vous essayez de créer un cercle, commencez par localiser un nœud qui effectue cette action. À
l'aide du champ de recherche ou de la bibliothèque, vous pouvez remarquer qu'il existe plusieurs méthodes permettant de créer un cercle.
 1. Accédez à Geometry > Curves > Circle > [Link]
2. Rechercher > "ByCenterPointRadius..."

Cliquez sur le nœud [Link] afin de l'ajouter à l'espace de travail. Le nœud doit apparaître au centre de l'espace de travail.

1. Nœud [Link] dans la bibliothèque.

2. Cliquez sur le nœud dans la bibliothèque afin de l'ajouter à l'espace de travail.

Vous avez également besoin des nœuds [Link], Number Input et Number Slider.
 1. Geometry > Points > Point > [Link]
2. Geometry > Geometry > DistanceTo
3. Input > Basic > Number
4. Input > Basic > Number Slider

Connexion de nœuds avec des fils

Maintenant que vous avez quelques nœuds, connectez les ports des nœuds avec des fils. Ces connexions définissent le flux de données.

1. Number avec [Link]

2. Number Sliders avec [Link]
3. [Link] (2) avec DistanceTo
4. [Link] et DistanceTo avec [Link]

Exécution du programme
Lorsque le flux de programme a été défini, il suffit de demander à Dynamo de l'exécuter. Une fois le programme exécuté (automatiquement ou en mode
manuel), les données passent par les fils et les résultats s'affichent dans l'aperçu 3D.
 1. Cliquez sur Exécuter : si la barre d'exécution est en mode manuel, cliquez sur Exécuter pour exécuter le graphique.
2. Aperçu du nœud : placez le curseur de la souris sur la boîte située dans le coin inférieur droit d'un nœud pour afficher une fenêtre contextuelle
des résultats.
3. Aperçu 3D : si l'un des nœuds crée une géométrie, elle s'affiche dans l'aperçu 3D.
4. Géométrie de sortie sur le nœud de création.

Ajout de détails
Si votre programme fonctionne, un cercle qui passe par le point d'attraction doit apparaître dans l'aperçu 3D. C'est parfait, mais vous pouvez ajouter plus de
détails ou plus de contrôles. Ajustez l'entrée au nœud de cercle afin de pouvoir calibrer l'influence sur le rayon. Ajoutez un autre Number Slider à l'espace
de travail, puis cliquez deux fois sur une zone vide de l'espace de travail pour ajouter un nœud Code Block. Modifiez le champ dans le bloc de code pour
spécifier X/Y.

1. Code Block
2. DistanceTo et Number Slider avec Code Block
3. Code Block avec [Link]

Complexité accrue

Commencer simplement et augmenter la complexité au fur et à mesure est un moyen efficace de développer progressivement votre programme. Une fois
que ce programme fonctionne pour un cercle, appliquez sa puissance à plusieurs cercles. Au lieu d'un point central, si vous utilisez une grille de points et
prenez en compte la modification de la structure de données obtenue, votre programme va créer un grand nombre de cercles, chacun avec une valeur de
rayon unique définie par la distance calibrée par rapport au point d'attraction.

1. Ajoutez un nœud Number Sequence et remplacez les entrées de [Link]. Cliquez avec le bouton droit sur [Link]
et sélectionnez Combination > Produit vectoriel.
2. Ajoutez un nœud Flatten après [Link]. Pour aplanir complètement une liste, laissez l'entrée amt à la valeur par défaut de -1.
3. L'aperçu 3D est mis à jour avec une grille de cercles.

Ajustement avec manipulation directe

Parfois, la manipulation numérique n'est pas la bonne approche. Vous pouvez désormais manipuler manuellement la géométrie de points lorsque vous
naviguez dans l'aperçu 3D en arrière-plan. Vous pouvez également contrôler d'autres géométries créées à l'aide d'un point. Par exemple,
[Link] peut également être manipulé directement. Vous pouvez contrôler l'emplacement d'un point à partir d'une série de valeurs X,
Y et Z à l'aide de [Link]. Toutefois, avec l'approche de manipulation directe, vous pouvez mettre à jour les valeurs des curseurs en déplaçant
manuellement le point dans le mode de navigation de l'aperçu 3D. Cela offre une approche plus intuitive afin de contrôler un ensemble de valeurs discrètes
qui identifient l'emplacement d'un point.

1. Pour utiliser la manipulation directe, sélectionnez le panneau du point à déplacer : les flèches apparaissent sur le point sélectionné.
2. Passez en mode de navigation dans l'aperçu 3D.
1. Placez le curseur sur le point pour afficher les axes X, Y et Z.
2. Cliquez sur la flèche de couleur et faites-la glisser pour déplacer l'axe correspondant. Les valeurs de Number Slider sont mises à jour à
mesure que le point est déplacé manuellement.

1. Avant la manipulation directe, un seul curseur était branché au composant [Link]. Lorsque vous déplacez manuellement le
point dans la direction X, Dynamo génère automatiquement un nouveau Number Slider pour l'entrée X.
Anatomie d'un programme visuel
ANATOMIE D'UN PROGRAMME VISUEL
Dynamo permet de créer des programmes visuels dans un espace de travail en connectant des nœuds à des fils pour spécifier le flux logique du programme
visuel obtenu. Ce chapitre présente les éléments des programmes visuels, l'organisation des nœuds disponibles dans les bibliothèques de Dynamo, les
éléments et les états des nœuds, ainsi que les pratiques recommandées relatives à vos espaces de travail.
Nœuds
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 [Link]

2. 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. Icône de liaison : indique l'option de liaison spécifiée pour les entrées de liste correspondantes (plus d'informations sur cette option
ultérieurement)
5. 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

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.

Conseil : placez le curseur sur un port pour afficher une info-bulle contenant le type de données attendu.
 1. Libellé de port
2. Info-bulle
3. Type de données
4. Valeur par défaut

États

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. En outre, 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. Actif : les nœuds dont le nom est sur un arrière-plan gris foncé sont bien connectés et leurs entrées sont connectées
2. Inactif : les nœuds grisés sont inactifs et doivent être connectés avec des fils pour faire partie du flux du programme dans l'espace de travail
actif
3. État d'erreur : le rouge indique que le nœud est dans un état d'erreur
4. Geler : un nœud transparent a l'option Geler activée, ce qui interrompt l'exécution du nœud
5. Sélectionné : les nœuds actuellement sélectionnés ont une bordure bleue
6. Avertissement : les nœuds jaunes ont l'état Avertissement, ce qui signifie qu'ils peuvent avoir des types de données incorrects
7. Aperçu de l'arrière-plan : la couleur gris foncé indique que l'aperçu de la géométrie est désactivé

Si votre programme visuel contient des avertissements ou des erreurs, Dynamo fournit des informations supplémentaires sur le problème. Tout nœud jaune
comporte également une info-bulle au-dessus de son nom. Placez le curseur de la souris sur l'info-bulle pour la développer.

Conseil : examinez les nœuds en amont à la lumière de ces informations d'info-bulle pour voir si le type ou la structure de données requis est erroné.
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
Fils
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. Bien
que vous puissiez organiser vos nœuds comme vous le souhaitez dans l'espace de travail, on peut généralement dire que le flux du programme se déplace de
gauche à droite, puisque les ports de sortie se trouvent sur le côté droit des nœuds et les ports d'entrée sur le côté gauche.

Création de fils
Vous créez un fil en cliquant avec le bouton gauche de la souris sur un port, puis en cliquant 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.

Conseil : avant de terminer la connexion avec votre deuxième clic, autorisez l'accrochage des fils à un port et placez le curseur de la souris sur ce port
pour afficher l'info-bulle correspondante.
 1. Cliquez sur le port de sortie seq du nœud Number Sequence.
2. Lorsque vous déplacez la souris vers un autre port, le fil est en pointillés.
3. Cliquez sur le port d'entrée y de [Link] pour terminer la connexion.

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 :
 1. Fil existant
2. 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.
3. Pour supprimer le fil, retirez-le et cliquez avec le bouton gauche de la souris sur l'espace de travail.

*Remarque : il existe désormais une fonctionnalité supplémentaire permettant de déplacer plusieurs fils à la fois. Pour en savoir plus, rendez-vous sur
[Link]

Aperçus des fils

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 par défaut

2. Fil en surbrillance

Dynamo vous permet également de personnaliser l'apparence de vos fils dans l'espace de travail via le menu Vue > Connecteurs. Ici, vous pouvez basculer
entre les options Courbe et Polyligne ou toutes les désactiver.
1. Type de connecteur : Courbes
2. Type de connecteur : Polylignes
Bibliothèque
Bibliothèque Dynamo
La bibliothèque Dynamo contient les nœuds ajoutés à l'espace de travail et permettant de définir des programmes visuels à exécuter. Dans la bibliothèque,
vous pouvez rechercher des nœuds ou les parcourir. Les nœuds contenus ici (les nœuds de base installés, les nœuds personnalisés définis et les nœuds du
gestionnaire de package ajoutés à Dynamo) sont organisés de manière hiérarchique par catégorie. Examinez cette organisation et explorez les principaux
nœuds utilisés fréquemment.

Bibliothèque de bibliothèques
La bibliothèque Dynamo utilisée dans l'application est en fait un ensemble de bibliothèques fonctionnelles, chacune contenant des nœuds regroupés par
catégorie. Bien que cela puisse paraître compliqué au début, il s'agit d'une structure flexible permettant d'organiser les nœuds fournis avec l'installation par
défaut de Dynamo. Cette structure est encore plus efficace en aval lorsque vous commencez à étendre cette fonctionnalité de base avec des nœuds
personnalisés et des packages supplémentaires.

Schéma organisationnel

La section Bibliothèque de l'interface utilisateur de Dynamo se compose de bibliothèques organisées de manière hiérarchique. Lorsque vous vous déplacez
dans la bibliothèque, vous parcourez de manière séquentielle une bibliothèque, les catégories de la bibliothèque et les sous-catégories de la catégorie pour
trouver le nœud.

1. La bibliothèque : zone de l'interface Dynamo.

2. Une bibliothèque : ensemble de catégories associées, telles que Geometry.
3. Une catégorie : ensemble de nœuds associés, tels que tout ce qui est lié aux cercles.
4. Sous-catégorie : répartition des nœuds dans la catégorie, généralement définie par Create, Action ou Query.
5. Un nœud : objet ajouté à l'espace de travail permettant d'effectuer une action.

Conventions d'appellation

La hiérarchie de chaque bibliothèque est reflétée dans le nom des nœuds ajoutés à l'espace de travail, que vous pouvez également utiliser dans le champ de
recherche ou avec les blocs de code (qui utilisent le langage textuel Dynamo). Au-delà de l'utilisation de mots-clés pour essayer de trouver des nœuds, vous
pouvez saisir la hiérarchie séparée par un point.

La saisie de différentes parties de la position du nœud dans la hiérarchie de la bibliothèque au format bibliothè[Link]é[Link]œud
renvoie différents résultats :
 1. bibliothè[Link]é[Link]œud
2. caté[Link]œud
3. NomDuNœud ou motclé

En règle générale, le nom du nœud dans l'espace de travail est rendu au format caté[Link]œud, à 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 :
 1. Les nœuds de la plupart des bibliothèques incluent le format de catégorie.
2. Les nœuds [Link] et [Link] portent le même nom, mais proviennent de différentes catégories.
3. Les exceptions notables incluent les fonctions intégrées : [Link], [Link] 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).

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. Voici les nœuds disponibles dans la catégorie Input de la bibliothèque Core :

1. Boolean
2. Number
3. String
4. Number Slider
5. Integer Slider
6. Directory Path
7. File Path

Watch
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, mais vous pouvez aussi l'afficher dans un nœud Watch ou afficher les résultats de géométrie via un nœud Watch3D. Ces
deux nœuds sont disponibles dans la catégorie View de la bibliothèque Core.

Conseil : il peut arriver que l'aperçu 3D soit gênant lorsque votre programme visuel contient un grand nombre de nœuds. Pensez à désactiver l'option
Afficher l'aperçu en arrière-plan dans le menu Paramètres et à utiliser un nœud Watch3D pour afficher un aperçu de la géométrie.

1. Watch : lorsque vous sélectionnez un élément dans le nœud Watch, il est marqué dans les aperçus Watch3D et 3D.
2. Watch3D : sélectionnez la poignée inférieure droite pour redimensionner le nœud et y naviguer à l'aide de la souris comme vous le feriez avec
l'aperçu 3D.

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. Vous
pouvez également utiliser les nœuds Code Block comme raccourci pour définir un nœud Number Input ou appeler la fonctionnalité d'un autre nœud. La
syntaxe à suivre respecte la convention d'attribution de noms du langage textuel Dynamo, DesignScript, et est présentée dans la section 7.2. Essayez de créer
un cercle avec le raccourci suivant :

1. Cliquez deux fois pour créer un nœud Code Block.

2. Entrez [Link](x,y);.
3. Cliquez sur l'espace de travail pour effacer la sélection afin d'ajouter automatiquement des entrées x et y.
4. Créez les nœuds [Link] 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 doit être un cercle dans l'aperçu 3D.
Gestion de votre programme
Gestion de votre programme
Le processus de programmation visuelle peut être une activité créative puissante, mais le flux du programme et les entrées utilisateur clés peuvent très
rapidement être occultés par la complexité et/ou la disposition de l'espace de travail. Voici quelques bonnes pratiques pour gérer votre programme.

Alignement

Une fois que vous avez ajouté plusieurs nœuds à l'espace de travail, vous pouvez réorganiser la disposition des nœuds pour plus de clarté. Lorsque vous
sélectionnez plusieurs nœuds et cliquez avec le bouton droit de la souris sur l'espace de travail, la fenêtre contextuelle inclut un menu Aligner la sélection
avec les options de justification et de distribution dans X et Y.

1. Sélectionnez plusieurs nœuds.

2. Cliquez avec le bouton droit de la souris sur l'espace de travail.
3. Utilisez les options de Aligner la sélection.

Remarques
Avec une certaine expérience, vous pourrez probablement "lire" le programme visuel en examinant les noms des nœuds et en suivant le flux du programme.
Pour les utilisateurs de tous niveaux, il est également recommandé d'inclure des libellés et des descriptions en texte simple. Pour ce faire, Dynamo possède
un nœud Notes avec un champ de texte modifiable. Vous pouvez ajouter des notes à l'espace de travail de deux manières :
 1. Accédez au menu Modifier > Créer une note.
2. Utiliser le raccourci clavier Ctrl+W.

Une fois la note ajoutée à l'espace de travail, un champ de texte s'affiche pour vous permettre de modifier le texte de la note. Une fois la note créée, vous
pouvez la modifier en double-cliquant sur le nœud Note ou en cliquant dessus avec le bouton droit de la souris.

Groupement
Lorsque votre programme visuel est grand, il est utile d'identifier les étapes plus importantes qui seront exécutées. Vous pouvez mettre en surbrillance des
ensembles de nœuds plus grands avec un groupe pour les libeller avec un rectangle de couleur en arrière-plan et un titre. Il existe trois méthodes pour créer
un groupe avec plus d'un nœud sélectionné :
 1. Accédez au menu Modifier > Créer un groupe.
2. Utilisez le raccourci clavier Ctrl+G.
3. Cliquez avec le bouton droit de la souris sur l'espace de travail et choisissez Créer un groupe.

Une fois le groupe créé, vous pouvez modifier ses paramètres, tels que son titre et sa couleur.

Conseil : l'utilisation des notes et des groupes est une méthode efficace pour annoter votre fichier et améliorer sa lisibilité.

Voici notre programme de la section 2.4 avec des notes et des groupes ajoutés :
1. Note : "Paramètres de grille"
2. Note : "Points de la grille"
3. Groupe : "Créer une grille de points"
4. Groupe : "Créer un point d'attraction"
5. Note : "Calibrer les valeurs de distance"
6. Note : "Grille variable de cercles"
Blocs de construction des programmes
BLOCS DE CONSTRUCTION DES PROGRAMMES
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.
Données
Données
Les données sont les éléments des programmes. Elles circulent par l'intermédiaire de fils, fournissant des entrées pour les nœuds où elles sont traitées dans
une nouvelle forme de données de sortie. Vous trouverez ci-dessous des informations sur la définition des données, leur structure et leur utilisation dans
Dynamo.

En quoi consistent les données ?

Les données sont un ensemble de valeurs de variables qualitatives ou quantitatives. La forme de données la plus simple est celle des nombres tels que 0,
3.14 ou 17. Cependant, les données peuvent également être un nombre de différents types : une variable représentant des nombres changeants (height),
des caractères (myName), une géométrie (Circle) ou une liste d'éléments de données (1,2,3,5,8,13,...). Vous avez besoin de données à ajouter
aux ports d'entrée des nœuds de Dynamo. Vous pouvez avoir des données sans actions, mais vous avez besoin de données pour traiter les actions que les
nœuds représentent. Lorsque vous avez ajouté un nœud à l'espace de travail, si aucune entrée n'est fournie, le résultat est une fonction, et non le résultat de
l'action elle-même.

1. Données simples
2. Exécution réussie des données et des actions (nœud A)
3. Une action (nœud A) sans entrées de données renvoie une fonction générique

Méfiez-vous des valeurs nulles

Le type "null" représente l'absence de données. Bien qu'il s'agisse d'un concept abstrait, vous risquez de rencontrer ce phénomène lorsque vous travaillez
avec la programmation visuelle. Si une action ne crée pas de résultat valide, le nœud renvoie une valeur nulle. Il est crucial de tester les valeurs nulles et de
les supprimer de la structure de données pour créer des programmes robustes.

Icône Nom/Syntaxe Entrées Sorties

[Link] obj bool

Structures de données
Lorsque vous concevez des programmes visuels, vous pouvez générer très rapidement beaucoup de données, ce qui exige un moyen de gérer la hiérarchie. Il
s'agit du rôle des structures de données, les schémas organisationnels dans lesquels sont stockées les données. Les spécificités des structures de données et
leur utilisation varient d'un langage de programmation à un autre. Dynamo permet de hiérarchiser les données via des listes. Vous allez explorer cela en
détail dans les prochains chapitres, mais commençons simplement :
 1. Un nœud Number Sequence définit une liste de nombres en utilisant les entrées start, amount et step. Ces nœuds permettent de créer deux
listes distinctes de dix nombres, l'une qui va de 100 à 109 et l'autre qui va de 0 à 9.
2. Le nœud [Link] sélectionne un élément dans une liste à un index spécifique. Lorsque vous choisissez 0, le premier élément de
la liste est affiché (100 dans ce cas).
3. Si vous appliquez le même processus à la deuxième liste, vous obtenez la valeur 0, le premier élément de la liste.
4. Vous allez maintenant fusionner les deux listes en une seule à l'aide du nœud [Link]. Le nœud crée une liste de listes. Cette action
modifie la structure des données.
5. Lorsque vous utilisez de nouveau [Link], avec un index défini sur 0, la première liste est répertoriée dans la liste de listes. C'est
ce que signifie traiter une liste comme un élément, ce qui est légèrement différent dans d'autres langages de script. Les prochains chapitres
vous permettront d'en savoir plus sur la manipulation des listes et la structure des données.

Voici le concept clé à retenir sur la hiérarchie des données dans Dynamo : en ce qui concerne la structure des données, les listes sont considérées comme
des éléments. En d'autres termes, Dynamo fonctionne avec un processus descendant permettant de comprendre les structures de données. Qu'est-ce que cela
signifie ? Découvrez-le grâce à un exemple.

Utilisation de données pour créer une chaîne de cylindres

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : Building
Blocks of Programs - [Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Dans ce premier exemple, vous allez assembler un cylindre en forme de coque qui traverse la hiérarchie de la géométrie abordée dans cette section.
1. [Link] : après l'ajout du nœud dans la zone de dessin, un point apparaît à l'origine de la grille d'aperçu Dynamo. Les valeurs par
défaut des entrées x,y et z sont 0,0, ce qui vous donne un point à cet emplacement.

1. [Link] : l'étape suivante dans la hiérarchie de la géométrie est un plan. Il existe plusieurs façons de construire un plan. Pour
l'entrée, utilisez une origine et une normale. L'origine est le nœud de point créé à l'étape précédente.
2. [Link] : il s'agit d'un vecteur unifié dans la direction Z. Notez qu'il n'y a pas d'entrées, seulement un vecteur de valeur [0,0,1]. Utilisez-
le comme entrée normal pour le nœud [Link]. Vous obtenez ainsi un plan rectangulaire dans l'aperçu Dynamo.

1. [Link] : en avançant dans la hiérarchie, vous créez une courbe à partir du plan de l'étape précédente. Après avoir connecté le
nœud, un cercle apparaît à l'origine. Le rayon par défaut sur le nœud est de 1.
1. [Link] : permet de faire apparaître cet élément en lui donnant une certaine profondeur et en allant dans la troisième dimension. Ce
nœud crée une surface à partir d'une courbe par extrusion. La distance par défaut sur le nœud est 1 et un cylindre doit apparaître dans la
fenêtre.

1. [Link] : ce nœud vous donne un solide fermé grâce au décalage de la surface d'une distance donnée et à la fermeture de la forme. La
valeur d'épaisseur par défaut est de 1 et un cylindre en forme de coque s'affiche dans la fenêtre coformément à ces valeurs.
 1. Number Slider : au lieu d'utiliser les valeurs par défaut pour toutes ces entrées, ajoutez un contrôle paramétrique au modèle.
2. Domain Edit : après avoir ajouté le curseur de numérotation à la zone de dessin, cliquez sur le curseur situé en haut à gauche pour afficher les
options du domaine.
3. Min/Max/Step : remplacez les valeurs Min, Max et Step par 0, 2 et 0,01 respectivement. Ces valeurs servent à contrôler la taille de la
géométrie globale.

1. Number Slider : dans toutes les entrées par défaut, copiez et collez ce curseur de numérotation (sélectionnez le curseur, appuyez plusieurs fois
sur Ctrl+C, puis sur Ctrl+V), jusqu'à ce que toutes les entrées avec des valeurs par défaut disposent d'un curseur à la place. Certaines valeurs
du curseur doivent être supérieures à zéro pour que la définition fonctionne ([Link]., vous devez disposer d'une profondeur d'extrusion pour
disposer d'une surface à épaissir).

Vous avez maintenant créé un cylindre paramétrique en forme de coque avec ces curseurs. Ajustez certains de ces paramètres et observez la géométrie se
mettre à jour dynamiquement dans la fenêtre Dynamo.
 1. Number Slider : pour aller plus loin, ajoutez de nombreux curseurs dans la zone de dessin et nettoyez l'interface de l'outil que vous venez de
créer. Cliquez avec le bouton droit de la souris sur un curseur, choisissez "Renommer..." et remplacez chaque curseur par le nom approprié
pour son paramètre. Vous pouvez faire référence à l'image ci-dessus pour les noms.

À ce stade, vous avez créé un élément cylindrique épaississant fantastique. Il s'agit d'un seul objet actuellement. Découvrez désormais comment créer un
réseau de cylindres liés dynamiquement. Pour ce faire, vous allez créer une liste de cylindres, plutôt que de travailler avec un seul élément.

1. Ajout (+) : votre objectif est d'ajouter une ligne de cylindres à côté du cylindre créé. Si vous souhaitez ajouter un cylindre adjacent au cylindre
en cours, vous devez prendre en compte à la fois le rayon du cylindre et l'épaisseur de sa coque. Pour obtenir ce nombre, ajoutez les deux
valeurs des curseurs.
Étant donné que cette étape est plus importante, allez-y étape par étape : l'objectif final consiste à créer une liste de nombres qui définissent les
emplacements de chaque cylindre dans une ligne.

1. Multiplication : tout d'abord, multipliez la valeur de l'étape précédente par 2. La valeur de l'étape précédente représente un rayon et il convient
de déplacer le cylindre sur le diamètre complet.
2. Number Sequence : créez un réseau de nombres à l'aide de ce nœud. La première entrée est le nœud de multiplication de l'étape précédente
vers la valeur step. Pour définir la valeur start sur 0,0, utilisez un nœud Number.
3. Integer Slider : connectez un curseur d'entier à la valeur amount. Cela permet de définir le nombre de cylindres créés.
4. Sortie : cette liste affiche la distance déplacée pour chaque cylindre du réseau et est paramétriquement définie par les curseurs d'origine.

1. Cette étape est relativement simple : connectez la séquence définie à l'étape précédente à l'entrée x du nœud [Link] d'origine.
Cette action permet de remplacer le curseur pointX que vous pouvez supprimer. Un réseau de cylindres apparaît maintenant dans la fenêtre
(assurez-vous que la valeur du curseur d'entier est supérieure à 0).
La chaîne de cylindres est toujours liée dynamiquement à tous les curseurs. Ajustez chaque curseur et observez la définition se mettre à jour.
Math
Math
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.

Icône Nom Syntaxe Entrées Sorties

Ajouter + var[]...[], var[]...[] var[]...[]

Soustraire - var[]...[], var[]...[] var[]...[]

Multiplier * var[]...[], var[]...[] var[]...[]

Diviser / var[]...[], var[]...[] var[]...[]

Formule paramétrique

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : Building
Blocks of Programs - [Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

À partir des opérateurs, l'étape logique suivante consiste à combiner des opérateurs et des variables pour former une relation plus complexe à l'aide de
formules. Créez une formule qui peut être contrôlée par des paramètres d'entrée, tels que des curseurs.
 1. Number Sequence : définissez une séquence de nombres reposant sur les trois entrées start, amount et step. Cette séquence représente le "t"
dans l'équation paramétrique. Vous devez donc utiliser une liste suffisamment grande pour définir une clothoïde.

L'étape ci-dessus a permis de créer une liste de nombres pour définir le domaine paramétrique. La clothoïde dorée est définie comme l'équation suivante :
= et = . Le groupe de nœuds ci-dessous représente cette équation 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.

1. 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é.
2. * : 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.
3. [Link] : 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.
4. [Link] : la fonction de "t" et le numéro "e" permettent de créer la séquence Fibonacci.
5. [Link] et [Link] : ces deux fonctions trigonométriques différencient respectivement la coordonnée x et la coordonnée y de chaque point
paramétrique.
6. 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.

De la formule à la géométrie
Le bloc de nœuds de l'étape précédente fonctionne correctement, mais cela demande beaucoup de travail. Pour créer un workflow plus efficace, consultez la
section Blocs de code (section [Link]) pour définir une chaîne d'expressions Dynamo en un nœud. Dans cette prochaine série d'étapes, vous allez utiliser
l'équation paramétrique pour dessiner la clothoïde Fibonacci.

1. [Link] : 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.

1. [Link] : connectez [Link] 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.

De la clothoïde au Nautilus
1. 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 [Link].

1. [Link] : il s'agit également du nœud de l'exercice précédent, utilisé comme référence.

2. [Link] : 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.
 1. [Link] : pour créer un réseau de cercles plus dynamique, connectez la séquence de nombres d'origine (séquence "t") à
la valeur de rayon.
2. Number Sequence : réseau d'origine de "t". Si vous connectez ceci à la valeur du rayon, les centres des cercles divergent davantage à partir de
l'origine, mais le rayon des cercles augmente, créant ainsi un super graphique circulaire Fibonacci. Et c'est encore mieux en 3D !

Du Nautilus à la phyllotaxie
Maintenant que vous avez créé une coque Nautilus circulaire, passez aux grilles paramétriques. Vous allez utiliser une rotation de base sur la clothoïde
Fibonacci pour créer une grille Fibonacci, et le résultat est modélisé après la croissance des graines de tournesol.

1. Comme point de départ ici aussi, 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 [Link].
 1. Géomé[Link] : il existe plusieurs options [Link]. Assurez-vous d'avoir choisi le nœud avec les entrées geometry, basePlane
et degrees. Connectez [Link] à l'entrée geometry.
2. [Link] : connexion à l'entrée basePlane. Vous allez effectuer une rotation autour de l'origine, servant également de base pour la clothoïde.
3. Intervalle de nombres : 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.
4. 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 :

1. 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.
1. 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.
Logique
Logique
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 :

Icône Nom Syntaxe Entrées Sorties

If If test, true, false résultat

Formule IF(x,y,z) x, y, z résultat

Bloc de code (x?y:z) x, y, z résultat

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.

Filtrage d'une liste

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : Building
Blocks of Programs - [Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

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

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

2. 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.
3. Sortie : le résultat est une liste de 11 chiffres compris entre 0 et 10.
4. 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.
5. 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.
6. 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.
7. [Link] : 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.
8. 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.

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.

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

1. Les valeurs d'entrée ont changé.

2. L'entrée list de [Link] est déconnectée. Pour l'instant, mettez ces nœuds de côté. Vous les utiliserez plus tard dans l'exercice.

Commencez par connecter les nœuds ensemble, 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 :

1. Le premier curseur doit avoir une valeur minimale de 1, une valeur maximale de 4 et un pas de 0.01.
2. Le deuxième curseur doit avoir une valeur minimale de 0, une valeur maximale de 1 et un pas de 0.01.
3. [Link] : 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.
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.

1. [Link] : à l'aide de la séquence de nombres créée à l'étape 1, 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.
1. [Link] : connectez [Link] (de l'étape 2) à curve et [Link] à 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].

1. [Link] : connectez [Link] de l'étape précédente à l'entrée list.

2. 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.
1. [Link] : 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.
1. Number Slider : en revenant au début de la définition, ajustez le curseur de numérotation et observer le zipper se mettre à jour. La rangée
supérieure des images représente un intervalle de valeurs pour le curseur de numérotation supérieur. Il s'agit de la fréquence de l'onde.
2. Number Slider : la ligne inférieure des images représente un intervalle de valeurs pour le curseur inférieur. Il s'agit de l'amplitude de l'onde.
Chaînes
Chaînes
Officiellement, une chaîne est une séquence de caractères représentant une constante littérale ou un type de variable. Officieusement, dans le jargon de la
programmation, une chaîne est du texte. Vous avez travaillé avec des nombres entiers et des nombres décimaux pour définir les paramètres et vous pouvez
faire de même avec du texte.

Création de chaînes

Les chaînes peuvent être utilisées pour une large gamme d'applications, y compris la définition de paramètres personnalisés, l'annotation de jeux de
documentation et l'analyse via des jeux de données textuelles. Le nœud String se trouve dans la catégorie Core > Input.

Les exemples de nœuds ci-dessus sont des chaînes. Un nombre peut être représenté sous forme de chaîne, de lettre ou de tableau complet de texte.

Interrogation des chaînes

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : Building
Blocks of Programs - [Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Interroger les chaînes vous permet d'analyser rapidement de grandes quantités de données. Vous allez découvrir certaines opérations de base qui peuvent
accélérer un workflow et aider à l'interopérabilité des logiciels.

L'image ci-dessous prend en compte une chaîne de données provenant d'une feuille de calcul externe. La chaîne représente les sommets d'un rectangle dans
le plan XY. Effectuez quelques opérations de fractionnement de chaînes dans un petit exercice :
 1. Le séparateur ";" sépare chaque sommet du rectangle. Cette opération permet de créer une liste comportant 4 éléments pour chaque sommet.

1. Pour créer un séparateur, appuyez sur "+" au milieu du nœud.

2. Ajoutez une chaîne "," à la zone de dessin et connectez-la à la nouvelle entrée de séparateur.
3. Vous obtenez maintenant une liste de dix éléments. Le nœud se divise d'abord en fonction de separator0, puis en fonction de separator1.

Bien que la liste d'éléments ci-dessus puisse ressembler à des nombres, ils restent considérés comme des chaînes individuelles dans Dynamo. Pour créer des
points, leur type de données doit être converti d'une chaîne en nombre. Cette opération est effectuée à l'aide du nœud [Link].
 1. Ce nœud est simple. Connectez les résultats [Link] à l'entrée. La sortie ne semble pas différente, mais le type de données est maintenant
un nombre au lieu d'une chaîne.

1. Avec certaines opérations supplémentaires de base, vous avez maintenant un rectangle dessiné à l'origine en fonction de l'entrée de chaîne
d'origine.

Manipulation des chaînes

Étant donné qu'une chaîne est un objet texte générique, elle héberge une large gamme d'applications. Examinez certaines des principales actions de la
catégorie Core > String dans Dynamo :

Il s'agit d'une méthode de fusion de deux chaînes dans l'ordre. Cette opération consiste à prendre chaque chaîne littérale dans une liste et à créer une chaîne
fusionnée.
 L'image ci-dessus représente la concaténation de trois chaînes :

1. Pour ajouter ou soustraire des chaînes à la concaténation, cliquez sur les boutons +/- au centre du nœud.
2. La sortie produit une chaîne concaténée, avec des espaces et des signes de ponctuation inclus.

La méthode de jonction est très similaire à la concaténation, sauf qu'elle comporte une couche de ponctuation supplémentaire.

Si vous avez travaillé dans Excel, vous connaissez peut-être les fichiers CSV. Il s'agit de valeurs séparées par des virgules. Vous pouvez utiliser une virgule
(ou dans ce cas, deux tirets) comme séparateur avec le nœud de jointure pour créer une structure de données similaire :

L'image ci-dessus représente la jointure de deux chaînes :

1. L'entrée separator permet de créer une chaîne qui divise les chaînes jointes.

Utilisation des chaînes

Dans cet exercice, vous allez utiliser les méthodes de requête et de manipulation des chaînes pour déconstruire la dernière strophe du poème de Robert Frost
Stopping By Woods on a Snowy Evening. Ce n'est pas l'application la plus pratique, mais elle vous aidera à comprendre les actions de chaînes conceptuelles
lorsque vous les appliquez aux lignes lisibles de rythme et de rime.

Commencez par une division de chaîne de base de la strophe. Tout d'abord, remarquez que l'écriture est formatée par des virgules. Utilisez ce format
pour séparer chaque ligne en éléments individuels.

1. La chaîne de base est collée dans un nœud String.

2. Un autre nœud String est utilisé pour désigner le séparateur. Dans ce cas, utilisez une virgule.
3. Ajoutez un nœud [Link] à la zone de dessin et connectez-le aux deux chaînes.
4. Le résultat montre que vous avez séparé les lignes en éléments individuels.

Passez désormais à la meilleure partie du poème : les deux dernières lignes. La strophe d'origine était un élément de données. Vous avez divisé ces
données en éléments individuels lors de la première étape. Vous devez maintenant trouver le texte que vous recherchez. Bien que vous puissiez faire
cela en sélectionnant les deux derniers éléments de la liste, s'il s'agissait d'un livre entier, vous ne pourriez pas tout lire et isoler manuellement les
éléments.

1. Au lieu d'effectuer une recherche manuelle, utilisez le nœud [Link] pour rechercher un ensemble de caractères. Cette opération est
similaire à la commande "Rechercher" dans un traitement de texte. Dans ce cas, vous obtenez le retour de "true" ou de "false" si cette sous-
 chaîne se trouve dans l'élément.
2. Dans l'entrée "searchFor", définissez une sous-chaîne à rechercher dans la strophe. Utilisez un nœud String avec le texte "And miles".
3. La sortie vous donne une liste des valeurs true et false. Vous allez utiliser cette logique booléenne pour filtrer les éléments à l'étape suivante.

1. [Link] est le nœud à utiliser pour éliminer les valeurs true et false. La sortie "in" renvoie les instructions avec une entrée
"mask" ayant la valeur "true", tandis que la sortie "out" renvoie celles qui sont "false".
2. Le résultat de l'entrée "in" est tel qu'attendu, vous donnant ainsi les deux dernières lignes de la strophe.

À présent, pour obtenir la répétition de la strophe, vous devez fusionner les deux lignes. Si vous observez la sortie de l'étape précédente, vous pouvez
remarquer que la liste contient deux éléments :

1. À l'aide de deux nœuds [Link], vous pouvez isoler les éléments en utilisant les valeurs 0 et 1 comme entrée d'index.
2. La sortie de chaque nœud vous donne, dans l'ordre, les deux dernières lignes.
 Pour fusionner ces deux éléments en un seul élément, utilisez le nœud [Link] :

1. Après avoir ajouté le nœud [Link], vous remarquez que vous avez besoin d'un séparateur.
2. Pour créer le séparateur, ajoutez un nœud String dans la zone de dessin et entrez une virgule.
3. Le résultat final a fusionné les deux derniers éléments en un seul élément.

Isoler les deux dernières lignes semble représenter beaucoup de travail ; et il est vrai que les opérations de chaîne nécessitent souvent un peu de travail en
amont. Cependant, ces opérations sont évolutives et peuvent être appliquées à de grands jeux de données avec une certaine facilité. Si vous travaillez de
manière paramétrique avec des feuilles de calcul et l'interopérabilité, n'oubliez pas les opérations relatives aux chaînes.
Couleur
Couleur
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.

Icône Nom Syntaxe Entrées Sorties

Couleur ARVB [Link] A,R,G,B color

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
[Link] donne les quatre sorties différentes, ce nœud est préférable pour l'interrogation des propriétés d'une couleur.

Icône Nom Syntaxe Entrées Sorties

Alpha [Link] color A

Rouge [Link] color R

Vert [Link] color G

Bleu [Link] color B

Composants [Link] color A,R,G,B

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é.

Icône Nom de la requête Syntaxe Entrées Sorties

Teinte [Link] color Teinte

 Saturation [Link] color Saturation

Luminosité [Link] color Luminosité

Intervalles de couleurs

L'intervalle de couleurs est semblable au nœud Remap Range de la section 4.2 : 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 de bloc de code, 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. Bloc de code : valeurs d'entrée (entre 0 et 1) pour convertir en couleurs.

Aperçu des couleurs

Le nœud [Link] 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.
Exercice sur les couleurs
Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") : Building
Blocks of Programs - [Link]. 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 bloc de code (3.2.3). 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. [Link] : connectez les trois sorties du bloc de code 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. [Link] : connectez la sortie [Link] à l'entrée points du nœud. Vous obtenez une courbe hélicoïdale.
2. [Link] : connectez la sortie [Link] à 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 [Link]. 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. [Link] : connectez la sortie [Link] à l'entrée. Connectez [Link] à 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. [Link] : connectez la sortie [Link] à 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 [Link] à un nœud et la sortie [Link] à 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. [Link] : connectez la sortie [Link] à l'entrée radius et la sortie [Link] d'origine à l'entrée
centerPoint.
 1. Number Slider : 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 [Link] afin qu'ils soient compatibles avec ce
domaine.
2. [Link] : pour le moment, désactivez l'aperçu sur ce nœud (cliquez avec le bouton droit de la souris > Aperçu).
1. [Link] : ce processus devrait vous sembler familier. Connectez la sortie [Link] à 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 [Link] à l'entrée value.

1. [Link] : 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 [Link] 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. [Link] : fusionnez les deux couleurs dans une liste. Connectez la sortie à l'entrée colors pour Color Range.
 1. [Link] : connectez [Link] à 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 !

Couleur sur les surfaces

Le nœud [Link] 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 - Couleur sur surfaces
Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") : Building
Blocks of Programs - [Link]. 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 [Link]. 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. [Link] : 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 [Link] pour convertir le chemin d'accès au fichier en fichier, puis le transmettre à [Link] pour générer une
image à des fins d'échantillonnage.
3. [Link] : 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 [Link].
5. [Link] : 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
Géométrie pour la conception informatique
GÉOMÉTRIE POUR LA CONCEPTION INFORMATIQUE
En tant qu'environnement de programmation visuelle, Dynamo vous permet de définir la manière dont les données sont traitées. Les données sont des
nombres ou du texte, et il en va de même pour la géométrie. Tel qu'un ordinateur le comprend, la géométrie (aussi appelée géométrie de calcul) représente
les données que vous pouvez utiliser pour créer des modèles beaux et complexes à la fois, ou des modèles axés sur la performance. Pour ce faire, vous devez
comprendre les entrées et les sorties des différents types de géométrie que vous pouvez utiliser.
Présentation de la géométrie
Présentation de la géométrie
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.

Les principes fondamentaux

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 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 signifient que vous devez être conscient de ce que vous utilisez (type de géométrie, comment elle a été créée, etc.) afin de pouvoir
composer, décomposer et recomposer librement des géométries différentes à mesure que vous développez 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 autre catégorie de types
géométriques qui sont 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 parties.
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.

Géométrie dans Dynamo Sandbox

Qu'est-ce que cela implique pour l'utilisation de Dynamo ? 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 joint à cette image (cliquez avec le bouton droit de la souris et choisissez « Enregistrer le lien sous... ») : [Geometry
 for Computational Design - Geometry [Link]] (datasets/5-1/Geometry for Computational Design - Geometry [Link]). Vous trouverez la
liste complète des fichiers d'exemple dans l'annexe.

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.
Vecteurs
Vecteurs, plans et systèmes de coordonnées
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.
Qu'est-ce qu'un 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 d'une différence relative est source de confusion, considérez le vecteur AB comme "Je suis debout au point A, et je regarde vers le point B." La
direction, d'ici (A) vers là-bas (B), est le 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 ?

Les vecteurs sont 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 qui accompagne cette image (cliquez
avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : Geometry for Computational Design - [Link]. Vous trouverez
la liste complète des fichiers d'exemple dans l'annexe.

Qu'est-ce qu'un 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 aident à décrire la direction : chaque plan a 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 qui accompagne cette image (cliquez avec
le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : Geometry for Computational Design - [Link]. Vous trouverez la
liste complète des fichiers d'exemple dans l'annexe.

Qu'est-ce qu'un 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

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 qui accompagne cette image (cliquez avec le
bouton droit de la souris et choisissez "Enregistrer le lien sous...") : Geometry for Computational Design - Coordinate [Link]. Vous
trouverez la liste complète des fichiers d'exemple dans l'annexe.
Points
Points
Si la géométrie est la langue d'un modèle, les points en sont l'alphabet. Les points constituent la base sur laquelle est créée la géométrie. Il faut au moins
deux points pour créer une courbe, au moins trois points pour créer un polygone ou une face maillée, etc. La définition de la position, de l'ordre et de la
relation entre les points (essayez une fonction de sinus) nous permet de définir une géométrie d'ordre supérieur, comme des cercles ou des courbes.

1. Un cercle utilisant les fonctions x=r*cos(t) et y=r*sin(t)

2. Une courbe sinusoïdale utilisant les fonctions x=(t) et y=r*sin(t)

Qu'est-ce qu'un point ?

Un point est défini uniquement par une ou plusieurs valeurs, appelées coordonnées. Le nombre de valeurs de coordonnées requises pour définir le point
dépend du système de coordonnées ou du contexte dans lequel il se trouve. Le type de point le plus courant dans Dynamo existe dans notre système de
coordonnées général en trois dimensions et possède trois coordonnées [X,Y,Z].

Points en tant que coordonnées

Les points peuvent également exister dans un système de coordonnées bidimensionnel. La convention comporte différentes lettres de notation selon le type
d'espace avec lequel vous travaillez. Il se peut que vous utilisiez [X,Y] sur un plan ou [U,V] pour une surface.

1. Un point dans un système de coordonnées euclidien : [X,Y,Z]

2. Un point dans un système de coordonnées de paramètres de courbe : [t]
3. Un point dans un système de coordonnées de paramètres de surface : [U,V]

Bien que cela puisse sembler contre-intuitif, les paramètres des courbes et des surfaces sont continus et s'étendent au-delà de l'arête de la géométrie donnée.
Étant donné que les formes qui définissent l'espace des paramètres résident dans un système de coordonnées général en trois dimensions, vous pouvez
toujours convertir une coordonnée paramétrique en coordonnée "universelle". Le point [0.2, 0.5] sur la surface, par exemple, est le même que le point [1.8,
2.0, 4.1] en coordonnées universelles.
1. Point dans les coordonnées XYZ universelles supposées
2. Point relatif à un système de coordonnées donné (cylindrique)
3. Point comme coordonnée UV sur une surface Téléchargez le fichier d'exemple qui accompagne cette image (cliquez avec le bouton droit de la
souris et choisissez "Enregistrer le lien sous...") : Geometry for Computational Design - [Link]. Vous trouverez la liste complète des
fichiers d'exemple dans l'annexe.
Courbes
Courbes
Les courbes sont le premier type de données géométriques abordé qui a un jeu de propriétés descriptives de forme plus familier : courbe ou droite ? Longue
ou courte ? N'oubliez pas que les points restent des blocs de construction permettant de définir n'importe quel élément d'une ligne à une spline et tous les
types de courbes entre les deux.

1. Ligne
2. Polyligne
3. Arc
4. Cercle
5. Ellipse
6. Courbe NURBS
7. Polycourbe

Qu'est-ce qu'une courbe ?

Le terme courbe est généralement un terme "fourre-tout" pour toutes les formes relativement courbes (même les droites). La courbe "C" en majuscule est la
catégorisation parent de tous ces types de formes : lignes, cercles, splines, etc. Techniquement, une courbe décrit tous les points possibles qui peuvent être
trouvés en saisissant "t" dans un ensemble de fonctions, pouvant aller des fonctions simples (x = -1.26*t, y = t) aux fonctions comprenant du
calcul. Quel que soit le type de courbe sur lequel vous travaillez, ce paramètre appelé "t" est une propriété que vous pouvez évaluer. En outre, quel que soit
l'aspect de la forme, toutes les courbes ont également un point de départ et un point d'arrivée, qui, de manière fortuite, correspondent aux valeurs t minimale
et maximale utilisées pour créer la courbe. Cela permet de comprendre sa direction.

Il est important de noter que Dynamo suppose que le domaine des valeurs "t" d'une courbe est compris entre 0.0 et 1.0.

Toutes les courbes possèdent également un certain nombre de propriétés ou de caractéristiques servant à les décrire ou à les analyser. Lorsque la distance
entre les points de départ et d'arrivée est égale à zéro, la courbe est "fermée". De plus, chaque courbe comporte un certain nombre de points de contrôle. Si
tous ces points sont situés sur le même plan, la courbe est "planaire". Certaines propriétés s'appliquent à la courbe dans son ensemble, tandis que d'autres
s'appliquent uniquement à des points spécifiques situés le long de la courbe. Par exemple, la planéité est une propriété globale, tandis qu'un vecteur de
tangente à une valeur t donnée est une propriété locale.

Lignes
Les lignes sont la forme la plus simple des courbes. Elles ne semblent pas courbées, mais sont en fait des courbes (sans aucune courbure). Il existe plusieurs
méthodes pour créer des lignes. La méthode la plus intuitive consiste à relier le point A au point B. La forme de la ligne AB est dessinée entre les points,
mais mathématiquement, elle s'étend à l'infini dans les deux directions.
Lorsque vous connectez deux lignes, vous obtenez une polyligne. L'illustration ci-dessous est une représentation simple de ce qu'est un point de contrôle. Si
vous modifiez l'un des emplacements de ces points, la forme de la polyligne change. Si vous fermez la polyligne, vous obtenez un polygone. Si les
longueurs d'arête du polygone sont toutes égales, elles sont décrites comme régulières.

Arcs, cercles, arcs elliptiques et ellipses

À mesure que vous ajoutez de la complexité aux fonctions paramétriques qui définissent une forme, vous pouvez aller plus loin qu'une ligne pour créer un
arc, un cercle, un arc d'ellipse ou une ellipse en décrivant un ou deux rayons. Les différences entre la version arc et le cercle ou l'ellipse reposent
uniquement sur le fait que la forme est fermée ou non.
NURBS + polycourbes

Les NURBS (splines de base rationnelles non uniformes) sont des représentations mathématiques qui permettent de modéliser avec précision n'importe
quelle forme d'une simple ligne, d'un cercle, d'un arc ou d'un rectangle 2D à la courbe organique de forme libre 3D la plus complexe. En raison de leur
flexibilité (relativement peu de points de contrôle, mais une interpolation lisse en fonction des paramètres de degré) et de leur précision (liée à un calcul
robuste), les modèles NURBS peuvent être utilisés dans n'importe quel processus, de l'illustration à la fabrication, en passant par l'animation.

Degré : le degré de la courbe détermine la plage d'influence des points de contrôle sur une courbe. Lorsque la valeur du degré est élevée, l'intervalle est plus
important. Le degré est un nombre entier positif. Ce nombre est généralement 1, 2, 3 ou 5, mais il peut s'agir de n'importe quel nombre entier positif. Les
lignes et les polylignes NURBS sont généralement de degré 1 et la plupart des courbes de forme libre de degré 3 ou 5.

Points de contrôle : les points de contrôle sont une liste de points de degrés+1 minimum. Pour modifier la forme d'une courbe NURBS, il suffit de déplacer
ses points de contrôle.

Poids : les points de contrôle sont associés à un nombre appelé poids. Les poids sont généralement des nombres positifs. Lorsque les points de contrôle
d'une courbe ont tous le même poids (généralement 1), la courbe est appelée non rationnelle. Dans le cas contraire, la courbe est appelée rationnelle. La
plupart des courbes NURBS ne sont pas rationnelles.

Nœuds : les nœuds sont une liste de nombres (degré + N-1), où N représente le nombre de points de contrôle. Les nœuds sont utilisés conjointement avec
les poids afin de contrôler l'influence des points de contrôle sur la courbe obtenue. L'une des utilisations possibles des nœuds consiste à créer des boucles à
certains points de la courbe.
 1. Degré = 1
2. Degré = 2
3. Degré = 3

Plus la valeur de degré est élevée, plus les points de contrôle sont utilisés pour interpoler la courbe obtenue.

Créez une courbe sinusoïdale dans Dynamo à l'aide de deux méthodes différentes afin de créer des courbes NURBS et de comparer les résultats.

1. [Link] utilise la liste de points comme points de contrôle.

2. [Link] trace une courbe passant par la liste de points. Téléchargez le fichier d'exemple qui accompagne cette image (cliquez
avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : Geometry for Computational Design - [Link]. Vous trouverez
la liste complète des fichiers d'exemple dans l'annexe.
Surfaces
Surfaces
Lorsque vous passez de l'utilisation de courbes à l'utilisation de surfaces dans un modèle, vous pouvez commencer à représenter les objets que vous voyez
dans un univers en trois dimensions. Tandis que les courbes ne sont pas toujours planes (elles sont en trois dimensions), l'espace qu'elles définissent est
toujours lié à une dimension. Les surfaces nous donnent une autre dimension et un ensemble de propriétés supplémentaires que vous pouvez utiliser dans
d'autres opérations de modélisation.

Qu'est-ce qu'une surface ?

Une surface est une forme mathématique définie par une fonction et deux paramètres. Au lieu de t pour les courbes, vous utilisez U et V pour décrire
l'espace de paramètre correspondant. Cela signifie que vous disposez de plus de données géométriques à partir desquelles dessiner lorsque vous utilisez ce
type de géométrie. Par exemple, les courbes ont des vecteurs tangents et des plans normaux (qui peuvent pivoter ou se tordre le long de la courbe), alors que
les surfaces ont des vecteurs normaux et des plans tangents qui seront cohérents dans leur orientation.

1. Surface
2. Isocourbe U
3. Isocourbe V
4. Coordonnées UV
5. Plan perpendiculaire
6. Vecteur normal

Domaine de surface : un domaine de surface est défini comme l'intervalle de paramètres (U,V) qui s'évaluent en un point tridimensionnel sur cette surface.
Le domaine dans chaque dimension (U ou V) est généralement décrit par deux nombres (U Min à U Max) et (V Min à V Max).
Bien que la forme de la surface ne paraisse pas rectangulaire et qu'elle puisse avoir localement un ensemble d'isocourbes plus ou moins étroit, l'"espace"
défini par son domaine est toujours en deux dimensions. Dans Dynamo, les surfaces sont toujours considérées comme ayant un domaine défini par un
minimum de 0.0 et un maximum de 1.0 dans les directions U et V. Les surfaces planes ou ajustées peuvent avoir des domaines différents.

Isocourbe (ou courbe isométrique) : courbe définie par une valeur U ou V constante sur la surface et par un domaine de valeurs pour l'autre direction U ou
V correspondante.

Coordonnée UV : point dans l'espace de paramètre UV défini par U, V et parfois W.

Plan perpendiculaire : plan perpendiculaire aux isocourbes U et V au niveau d'une coordonnée UV donnée.

Vecteur normal : vecteur définissant la direction vers le haut par rapport au plan perpendiculaire.

Surfaces NURBS
Les surfaces NURBS sont assez comparables aux courbes NURBS. Les surfaces NURBS peuvent être considérées comme une grille de courbes NURBS
qui vont dans deux directions. La forme d'une surface NURBS est définie par un certain nombre de points de contrôle et le degré de cette surface dans les
directions U et V. Les mêmes algorithmes sont utilisés pour calculer la forme, les normales, les tangentes, les courbures et d'autres propriétés par le biais de
points de contrôle, de poids et de degrés.

Dans le cas des surfaces NURBS, il existe deux directions impliquées par la géométrie, car les surfaces NURBS sont, quelle que soit la forme que vous
voyez, des grilles rectangulaires de points de contrôle. Et même si ces directions sont souvent arbitraires par rapport au système de coordonnées général,
vous les utiliserez fréquemment pour analyser vos modèles ou générer d'autres géométries basées sur la surface.
 1. Degré (U,V) = (3,3)
2. Degré (U,V) = (3,1)
3. Degré (U,V) = (1,2)
4. Degré (U,V) = (1,1)

Polysurfaces

Les polysurfaces sont composées de surfaces qui sont jointes sur une arête. Les polysurfaces offrent plus de deux définitions UV dimensionnelles, car vous
pouvez maintenant parcourir les formes connectées au moyen de leur topologie.

Bien que le terme "topologie" décrive généralement un concept relatif à la façon dont les composants sont connectés et/ou la topologie associée, dans
Dynamo, il s'agit également d'un type de géométrie. Il s'agit en particulier d'une catégorie parent pour les surfaces, les polysurfaces et les solides.

La jonction de surfaces, parfois appelée face de fermeture, de cette manière vous permet de créer des formes plus complexes et de définir des détails sur la
jointure. Vous pouvez appliquer facilement une opération de congé ou de chanfrein aux arêtes d'une polysurface.

Importez et évaluez une surface au niveau d'un paramètre dans Dynamo pour voir quel type d'informations vous pouvez extraire.
1. [Link] renvoie le point à une coordonnée UV donnée.
2. [Link] renvoie le vecteur normal à une coordonnée UV donnée.

3. [Link] renvoie la courbe isoparamétrique à une coordonnée U ou V. Notez l'entrée isoDirection. Téléchargez les fichiers d'exemple
qui accompagnent cette image (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous trouverez la liste
complète des fichiers d'exemple dans l'annexe.

4. Geometry for Computational Design - [Link]

5. [Link]
Solides
Solides
Si vous voulez construire des modèles plus complexes qui ne peuvent pas être créés à partir d'une seule surface ou si vous voulez définir un volume
explicite, vous devez maintenant vous aventurer dans le domaine des solides (et des polysurfaces). Même un cube simple est assez complexe pour avoir
besoin de six surfaces, une par face. Les solides donnent accès à deux concepts clés qui n'existent pas dans les surfaces : une description topologique plus
affinée (faces, arêtes, sommets) et les opérations booléennes.

Qu'est-ce qu'un solide ?

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.

Cela rend les objets booléens solides extrêmement efficaces. Il existe trois opérations booléennes de solide qui permettent de distinguer les parties de la
géométrie qui sont conservées.

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.

Outre ces trois opérations, Dynamo dispose des nœuds [Link] et [Link] pour effectuer des opérations de différence et d'union avec
plusieurs 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

Utilisez quelques opérations booléennes pour créer une balle hérisson.

1. [Link] : permet de créer le solide de base.

2. [Link], [Link] : 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. [Link] : permet de créer des cônes en utilisant des points sur la surface.
4. [Link] : permet d'unir les cônes et la sphère.
5. [Link] : permet d'envoyer des requêtes aux arêtes du nouveau solide.
6. [Link] : permet de raccorder les arêtes de la balle hérisson. Téléchargez les fichiers d'exemple qui accompagnent cette image (cliquez
avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous trouverez la liste complète des fichiers d'exemple dans
l'annexe. Geometry for Computational Design - [Link]

Gel
Les opérations booléennes sont complexes et peuvent être lentes à calculer. Utilisez la fonctionnalité Geler pour suspendre l'exécution des nœuds
sélectionnés et affectés aux nœuds en aval.
Utilisez le menu contextuel du bouton droit de la souris pour geler l'opération d'union de solide.
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.

Pour dégeler les nœuds, cliquez avec le bouton droit de la souris et désactivez l'option Geler.
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.
Maillages
Mailles
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 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.

Qu'est-ce qu'un 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.

É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.

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ées UV. 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 nœuds 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.

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.

Reportez-vous au chapitre 10.2 pour découvrir un exemple du package Mesh Toolkit.

Importation de géométrie
Importation de géométrie
Conception avec des listes
Conception avec des listes
Les listes servent à organiser les données. Dans le système d'exploitation de votre ordinateur, vous disposez de fichiers et de dossiers. Dans Dynamo, vous
pouvez les considérer respectivement comme des éléments et des listes. Comme dans votre système d'exploitation, il existe de nombreuses façons de créer
et de modifier des données, ainsi que de leur envoyer des requêtes. Dans ce chapitre, nous allons détailler la façon dont les listes sont gérées dans Dynamo.
Qu'est-ce qu'une liste
Qu'est-ce qu'une liste ?
Une liste est un ensemble d'éléments. Par exemple, prenez une grappe de bananes. Chaque banane est un élément de la liste (ou grappe). Il est plus facile de
ramasser une grappe de bananes plutôt que chaque banane individuellement. Il en est de même pour le regroupement d'éléments par relations paramétriques
dans une structure de données.

Photo de Augustus Binu.

Quand vous faites les courses, vous déposez tous vos achats dans un sac. Ce sac est aussi une liste. Si vous préparez un cake aux bananes, il vous faut 3
grappes de bananes (vous préparez plusieurs cakes aux bananes). Le sac représente une liste de grappes de bananes et chaque grappe représente une liste de
bananes. Le sac est une liste de listes (bidimensionnelle) et la grappe est une liste (unidimensionnelle).

Dans Dynamo, les données de liste sont triées et le premier élément de chaque liste possède un index "0". Vous trouverez ci-dessous la définition des listes
dans Dynamo et de leur rapport.

Index de base 0
Aussi étrange que cela puisse paraître à première vue, le premier index d'une liste est toujours 0, et non 1. Lorsqu'il est question du premier élément d'une
liste, il s'agit en fait de l'élément qui correspond à l'index 0.

Par exemple, si vous comptez le nombre de doigts de votre main droite, il y a de fortes chances que vous comptiez de 1 à 5. Cependant, si vous deviez
placer vos doigts dans une liste, Dynamo leur aurait donné des index de 0 à 4. Bien que cela puisse paraître un peu étrange aux débutants en programmation,
l'index de base 0 est une pratique courante dans la plupart des systèmes de calcul.
La liste contient toujours 5 éléments : elle utilise un système de comptage de base 0. Les éléments stockés dans la liste ne sont pas nécessairement des
nombres. Il peut s'agir de tout type de données pris en charge par Dynamo, tel que des points, des courbes, des surfaces, des familles, etc.

Souvent, la méthode la plus simple pour examiner le type de données stockées dans une liste consiste à connecter un nœud Watch à la sortie d'un autre
nœud. Par défaut, le nœud Watch affiche automatiquement tous les index sur le côté gauche de la liste et affiche les éléments de données sur la droite.

Ces index sont un élément crucial lorsque vous travaillez avec des listes.

Entrées et sorties
En ce qui concerne les listes, les entrées et sorties varient en fonction du nœud Dynamo utilisé. Par exemple, utilisez une liste de 5 points et connectez cette
sortie à deux nœuds Dynamo différents, [Link] et [Link] :

1. L'entrée points de [Link] recherche "Point[]". Cela représente une liste de points.
2. La sortie de [Link] est une simple polycourbe créée à partir d'une liste de cinq points.
3. L'entrée centerPoint de [Link] demande "Point".
4. La sortie de [Link] est une liste de cinq cercles, dont les centres correspondent à la liste de points d'origine.

Les données d'entrée de [Link] et de [Link] sont identiques. Cependant, le nœud Polycurve vous donne une polycourbe,
tandis que le nœud Circle vous donne 5 cercles dont les centres correspondent aux points. À première vue, ce résultat est logique : la polycourbe est
dessinée en tant que courbe reliant les 5 points, tandis que les cercles créent un cercle différent à chaque point. Qu'est-ce qui se passe avec les données ?

Lorsque vous placez le curseur sur l'entrée points de [Link], vous pouvez constater que l'entrée recherche "Point[]". Observez les crochets à la
fin. Ils représentent une liste de points. Pour créer une polycourbe, l'entrée doit être une liste pour chaque polycourbe. Ce nœud va ainsi condenser chaque
liste en une seule polycourbe.

En revanche, l'entrée centerPoint de [Link] demande "Point". Ce nœud recherche un point, en tant qu'élément, pour définir le point
central du cercle. C'est la raison pour laquelle vous obtenez cinq cercles à partir des données d'entrée. Reconnaître cette différence avec les entrées de
Dynamo permet de mieux comprendre le fonctionnement des nœuds lors de la gestion des données.

Liaison
Le couplage de données est un problème en l'absence de solution claire. C’est le cas lorsqu'un nœud a accès à des entrées qui ne sont pas en nombre égal. La
modification de l’algorithme de couplage des données peut entraîner des résultats très différents.

Imaginez un nœud qui crée des segments de ligne entre les points ([Link]). Il comporte deux paramètres d'entrée qui définissent tous
deux des coordonnées de point :
Comme vous pouvez le voir, il existe différentes manières de dessiner des lignes entre ces jeux de points. Pour accéder aux options de liaison, cliquez avec
le bouton droit de la souris sur le centre d'un nœud et sélectionnez le menu "Liaison".

Fichier de base
Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") : [Link].
Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Pour découvrir les opérations de liaison ci-dessous, vous allez utiliser ce fichier de base afin de définir la liste la plus courte, la liste la plus longue et le
produit cartésien.

1. Vous allez modifier la liaison sur [Link], mais sans modifier d'autres paramètres du graphique ci-dessus.

Liste la plus courte

La méthode la plus simple consiste à connecter les entrées une par une jusqu'à ce que l'un des flux soit épuisé. Cette méthode s'appelle l'algorithme "Liste la
plus courte". Il s'agit du comportement par défaut des nœuds Dynamo :
 En définissant la liaison sur Le plus court, vous obtenez une ligne diagonale de base composée de cinq points. Étant donné que la liste la plus courte
contient cinq points, la liaison de la liste la plus courte s'arrête après avoir atteint la fin d'une liste.

Liste la plus longue

L'algorithme "Liste la plus longue" continue à connecter les entrées, réutilisant les éléments, jusqu'à ce que tous les flux soient épuisés :
 En définissant la liaison sur Le plus long, vous obtenez une ligne diagonale qui s'étend verticalement. De la même façon que pour le diagramme de
concept, le dernier élément de la liste des 5 éléments sera répété pour atteindre la longueur de la liste la plus longue.

Produit cartésien

Enfin, la méthode "Produit cartésien" permet d'établir toutes les connexions possibles :
En définissant la liaison sur Produit cartésien, vous obtenez toutes les combinaisons de liaison entre chaque liste, ce qui vous donne une grille de
points de 5 x 10. Il s'agit d'une structure de données équivalente au produit cartésien, comme illustré dans le schéma de concept ci-dessus, sauf que vos
données sont désormais une liste de listes. Lorsque vous connectez une polycourbe, vous pouvez voir que chaque liste est définie par sa valeur X, ce
qui vous donne une rangée de lignes verticales.
Utilisation des listes
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

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.

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.

Opérations de liste
L'image ci-dessous représente le graphique de base utilisé pour faire la démonstration des opérations de liste de base. Vous allez découvrir comment gérer
des données dans une liste et montrer les résultats visuels.

Exercice - Opérations de liste

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : List-
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.
 1. Commencez par un bloc de code avec une valeur de 500;
2. Connectez-le à l'entrée x d'un nœud [Link].
3. Connectez le nœud de l'étape précédente à l'entrée d'origine d'un nœud [Link].
4. À l'aide d'un nœud [Link], connectez le nœud de l'étape précédente à l'entrée plane.
5. À l'aide d'unbloc de code, désignez une valeur de 50; pour le rayon. Il s'agit du premier cercle créé.
6. À l'aide d'un nœud [Link], déplacez le cercle de 100 unités vers le haut dans la direction Z.
7. À l'aide d'un nœud de bloc de code, 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 [Link]. Connectez [Link] à
l'entrée curve du nœud supérieur, puis [Link] à l'entrée curve du nœud situé en dessous.
9. À l'aide d'un nœud [Link], connectez les deux nœuds [Link].

1. Un nœud Watch3D affiche les résultats de [Link]. Vous dessinez actuellement des lignes entre deux cercles pour
représenter les opérations de liste de base et utiliserez ce graphique Dynamo de base pour parcourir les actions de liste ci-dessous.

[Link]
 Le nœud [Link] 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.

Exercice - [Link]

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : List-
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

1. Le nœud [Link] renvoie le nombre de lignes dans le nœud [Link]. La valeur est de 10 dans ce cas, ce qui correspond
au nombre de points créés à partir du nœud Code Block d'origine.

[Link]
 [Link] est une méthode fondamentale pour interroger un élément de la liste. Dans l'image ci-dessus, un index de "2" est utilisé pour
interroger le point intitulé "C".

Exercice - [Link]

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : List-
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

1. À l'aide du nœud [Link], sélectionnez l'index "0" ou le premier élément de la liste de lignes.
2. Le nœud Watch3D indique que vous avez sélectionné une ligne. Remarque : pour obtenir l'image ci-dessus, veillez à désactiver l'aperçu de
[Link].

[Link]

[Link] inverse l'ordre de tous les éléments d'une liste.

Exercice - [Link]

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : List-
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.
 1. Pour visualiser correctement la liste inversée des lignes, créez plus de lignes en remplaçant le bloc de code par 0..1..#100;
2. Insérez un nœud [Link] entre [Link] et [Link] pour l'un des points de la liste.
3. Les nœuds Watch3D affichent 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.

[Link]

[Link] 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.

Exercice - [Link]

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : List-
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.
 1. Dans le même processus que la liste inversée, insérez un nœud [Link] dans les nœuds [Link] et
[Link].
2. À l'aide d'un bloc de code, 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.

1. En remplaçant la valeur du bloc de code 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.

[Link]
 [Link] supprime certains éléments en fonction d'une liste de valeurs booléennes ou les valeurs "true" ou "false".

Exercice - [Link]

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") : List-
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Pour créer une liste de valeurs "true" ou "false", vous devez travailler un peu plus...

1. À l'aide d'un bloc de code, définissez une expression avec la syntaxe : 0..[Link](list);. Connectez le nœud
[Link] à 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 [Link].
2. À l'aide d'un nœud "%" (module), connectez la sortie du bloc de code à 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 [Link].
6. Connectez le nœud [Link] à chaque entrée list de [Link].
7. La sortie de [Link] 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 [Link], 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.
Listes de listes
Listes de listes
Ajoutons un autre niveau à la hiérarchie. Si vous prenez le paquet de cartes de l'exemple d'origine et si vous créez une boîte contenant plusieurs paquets, la
case représente désormais une liste de paquets et chaque paquet représente une liste de cartes. Voici une liste de listes. Pour l'analogie de cette section, la
zone rouge ci-dessous contient une liste de rouleaux de pièces de monnaie, et chaque rouleau contient une liste de centimes.

Photo de Dori.

Quelles requêtes pouvez-vous effectuer à partir de la liste de listes ? Cette action permet d'accéder aux propriétés existantes.

Nombre de pièces de monnaie ? 2.

Valeurs des types de pièces de monnaie ? 0,01 $ et 0,25 $.
Matériau des pièces de 0,25 $ ? 75 % de cuivre et 25 % de nickel.
Matériau des centimes ? 97,5 % de zinc et 2,5 % de cuivre.

Quelles actions pouvez-vous effectuer dans la liste de listes ? Cette action permet de modifier la liste de listes en fonction d'une opération donnée.

Sélectionnez une pile spécifique de pièces de 0,25 $ ou de centimes.

Sélectionnez une pièce de 0,25 $ ou un centime spécifique.
Réorganisez les piles de pièces de 0,25 $ et de centimes.
Mélangez les piles ensemble.

Pour rappel, Dynamo possède un nœud analogue pour chacune des opérations ci-dessus. Puisque vous travaillez avec des données abstraites et non des
objets physiques, vous avez besoin d'un ensemble de règles pour gérer la façon dont vous vous déplacer vers le haut et vers le bas de la hiérarchie de
données.

Lorsque vous travaillez sur des listes de listes, les données sont superposées et complexes, mais cela permet de réaliser des opérations paramétriques
extraordinaires. Déterminons les fondamentaux et discutons de certaines autres opérations dans les leçons ci-dessous.

Hiérarchie verticale
Voici le concept fondamental à retenir de cette section : Dynamo traite les listes comme des objets. Cette hiérarchie verticale est développée en tenant
compte de la programmation orientée objet. Au lieu de sélectionner des sous-éléments à l'aide d'une commande telle que [Link], Dynamo
sélectionne cet index de la liste principale dans la structure de données. Cet élément peut être une autre liste. Nous allons le décomposer avec une image
d'exemple :

Exercice - Hiérarchie verticale

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") : Top-Down-
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.
 1. Grâce au bloc de code, vous avez défini deux intervalles : "0..2; 0..3; "
2. Ces intervalles sont connectés à un nœud [Link] avec la liaison définie sur "Produit vectoriel". Cela crée une grille de points et
renvoie également une liste de listes sous forme de sortie.
3. Le nœud Watch donne 3 listes contenant chacune 4 éléments.
4. Lorsque vous utilisez [Link] avec un index de 0, Dynamo sélectionne la première liste et tout son contenu. D'autres programmes
peuvent sélectionner le premier élément de chaque liste dans la structure de données, mais Dynamo utilise une hiérarchie verticale lorsque
vous travaillez avec des données.

Flatten et [Link]

Le nœud Flatten permet de supprimer tous les niveaux de données d'une structure de données. Il est utile lorsque les hiérarchies de données ne sont pas
nécessaires à votre opération, mais il comporte un risque car il supprime des informations. L'exemple ci-dessous montre le résultat de l'aplanissement d'une
liste de données.

Exercice - Flatten

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") : [Link].
Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.
 1. Insérez une ligne de code pour définir un intervalle dans le bloc de code : "-250..-150..#4; "
2. En connectant le bloc de code aux entrées x et y d'un nœud [Link], vous définissez la liaison sur "Produit vectoriel" pour obtenir
une grille de points.
3. Le nœud Watch indique que vous avez une liste de listes.
4. Un nœud [Link] référence chaque liste et crée une polycourbe respective. Dans l'aperçu Dynamo, vous pouvez remarquer que
quatre polycourbes représentent chaque ligne de la grille.

1. En insérant un nœud Flatten avant le nœud de la polycourbe, vous créez une liste unique pour tous les points. Le nœud de la polycourbe fait
référence à une liste permettant de créer une courbe. Comme tous les points figurent sur une liste, une polycourbe en zigzag est générée pour
l'ensemble de la liste de points.

Il existe également des options permettant d'aplanir les niveaux de données isolés. Le nœud [Link] permet de définir un nombre défini de niveaux de
données à aplanir à partir du haut de la hiérarchie. Cet outil est très utile si vous avez des difficultés à gérer des structures de données complexes qui ne sont
pas nécessairement pertinentes pour votre workflow. Une autre option consiste à utiliser le nœud Flatten comme fonction dans [Link]. Nous allons
aborder [Link] plus en dessous.
Chop

Lors de la modélisation paramétrique, vous pouvez également ajouter des structures de données supplémentaires à une liste existante. Il existe également de
nombreux nœuds disponibles pour cette opération. La commande Chop est la version la plus élémentaire. Celle-ci vous permet de partitionner une liste en
sous-listes contenant un nombre défini d'éléments.

Exercice - [Link]

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") : [Link].
Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Une liste [Link] _with a _subLength de 2 crée 4 listes contenant 2 éléments chacune.

La commande Chop divise les listes en fonction d'une longueur de liste donnée. D'une certaine manière, la commande de découpage est l'opposé de
l'aplanissement : au lieu de supprimer la structure de données, elle y ajoute de nouveaux niveaux. Cet outil est utile pour les opérations géométriques comme
dans l'exemple ci-dessous.

[Link] et [Link]
La commande [Link]/Combine applique une fonction définie à une liste d'entrées, mais un niveau vers le bas de la hiérarchie. Les combinaisons
correspondent aux mappages, à l'exception près que les combinaisons peuvent avoir plusieurs entrées correspondant à l'entrée d'une fonction donnée.

Exercice - [Link]

Remarque : cet exercice a été créé avec une version précédente de Dynamo. La plupart des fonctionnalités [Link] ont été résolues par l'ajout de la
fonctionnalité List@Level. Pour plus d'informations, reportez-vous à la rubrique List@Level ci-dessous.

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") : [Link].
Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Pour une introduction rapide, examinons le nœud [Link] d'une section précédente.
 Le nœud [Link] compte tous les éléments d'une liste. Vous allez l'utiliser pour montrer comment fonctionne [Link].

1. Insérez deux lignes de code dans le bloc de code :

-50..50..#Nx;
-50..50..#Ny;

Une fois le code saisi, le bloc de code créera deux entrées pour Nx et Ny.

1. Avec deux curseurs d'entier, définissez les valeurs Nx et Ny en les connectant au bloc de code.
2. Connectez chaque ligne du bloc de code aux entrées X et Y respectives d'un nœud [Link]. Cliquez avec le bouton droit de la souris sur
le nœud, sélectionnez "Liaison", puis "Produit vectoriel". Cela crée une grille de points. Étant donné que vous avez défini l'intervalle de -50 à 50,
élargissez la grille Dynamo par défaut.
3. Un nœud Watch révèle les points créés. Observez la structure des données. Vous avez créé une liste de listes. Chaque liste représente une ligne de
points de la grille.
 1. Attachez un nœud [Link] à la sortie du nœud Watch de l'étape précédente.
2. Connectez un nœud Watch à la sortie [Link].

Le nœud [Link] donne une valeur de 5. Il s'agit de la variable "Nx" telle que définie dans le bloc de code. Pourquoi ?

Tout d'abord, le nœud [Link] utilise l'entrée "x" comme entrée principale pour la création de listes. Lorsque Nx est égale à 5 et Ny à
3, vous obtenez une liste de 5 listes, chacune comportant 3 éléments.
Étant donné que Dynamo traite les listes comme des objets, un nœud [Link] est appliqué à la liste principale de la hiérarchie. Le résultat est une
valeur de 5 ou le nombre de listes dans la liste principale.

1. En utilisant un nœud [Link], vous descendez d'un niveau dans la hiérarchie et effectuez une "fonction" à ce niveau.
2. Le nœud [Link] n'a pas d'entrée. Il est utilisé en tant que fonction, de sorte que le nœud [Link] sera appliqué à chaque liste individuelle
d'un niveau vers le bas dans la hiérarchie. L'entrée vide de [Link] correspond à l'entrée de liste de [Link].
3. Les résultats de [Link] donnent désormais une liste de 5 éléments, chacun d'entre eux ayant une valeur égale à 3. Cela représente la
longueur de chaque sous-liste.
Exercice - [Link]

Remarque : cet exercice a été créé avec une version précédente de Dynamo. La plupart des fonctionnalités [Link] ont été résolues avec l'ajout de la
fonction List@Level. Pour plus d'informations, reportez-vous à la rubrique List@Level ci-dessous.

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") :
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Dans cet exercice, vous allez utiliser une logique semblable à [Link], mais avec plusieurs éléments. Dans ce cas, vous voulez diviser une liste de courbes
par un nombre de points unique.

1. À l'aide du bloc de code, définissez un intervalle en utilisant la syntaxe suivante : "..20..#4; et une valeur de20;" au-dessous de cette
ligne.
2. Connectez le bloc de code à deux nœuds [Link].
3. Créez une ligne [Link] à partir des nœuds [Link].
4. Le nœud Watch affiche quatre lignes.
 1. Sous le graphique de la création de lignes, vous voulez utiliser un bloc de code pour créer quatre intervalles distincts afin de diviser les lignes
de manière unique. Pour ce faire, utilisez les lignes de code suivantes :

0..1..#3;
0..1..#4;
0..1..#5;
0..1..#6;

1. Grâce à un nœud [Link], vous fusionnez les quatre lignes du bloc de code dans une liste.
2. Le nœud Watch affiche une liste de listes.

1. [Link] ne fonctionne pas en connectant les lignes directement aux valeurs de paramètre. Vous devez descendre d'un niveau
dans la hiérarchie. Pour cela, utilisez [Link].
 Grâce à [Link], vous pouvez diviser chaque ligne avec succès en fonction des intervalles donnés. Étant donné que l'opération se complique
quelque peu, nous allons la décomposer en détail.

1. Tout d'abord, ajoutez un nœud [Link] à la zone de dessin. Il s'agit de la "fonction" _ou du "combinateur" que vous
appliquerez au nœud _List.Combine. Nous vous en dirons plus à ce sujet dans un instant.
2. Ajoutez un nœud [Link] à la zone de dessin. Appuyez sur "+" ou "-" pour ajouter ou soustraire des entrées. Dans ce cas, utilisez les
deux entrées par défaut sur le nœud.
3. Vous voulez connecter le nœud [Link] à l'entrée "comb" de [Link]. Un autre nœud important : veillez à cliquer avec
le bouton droit de la souris sur l'entrée "param" _input of _Curve.PointAtParameter et à désélectionner "Utiliser par défaut". Les valeurs par
défaut des entrées Dynamo doivent être supprimées lors de l'exécution d'un nœud en tant que fonction. En d'autres termes, vous devez
considérer les valeurs par défaut comme ayant des nœuds supplémentaires reliés à ces valeurs. Pour cette raison, vous devez supprimer les
valeurs par défaut dans ce cas.
4. Vous savez que vous avez deux entrées, les lignes et les paramètres pour créer des points. Mais comment les connecter aux entrées
[Link] et dans quel ordre ?
5. Les entrées vides de [Link] de haut en bas doivent être renseignées dans le combinateur dans le même ordre. Les lignes sont
donc connectées à list1 de [Link].
6. En suivant la couleur, les valeurs des paramètres sont connectées à l'entrée list2 de [Link].
7. Le nœud Watch et l'aperçu Dynamo vous montrent que vous avez 4 intervalles, chacun divisé en fonction des intervalles des blocs de code.

List@Level

Préférée à [Link], la fonctionnalité List@Level vous permet de sélectionner le niveau de liste que vous souhaitez utiliser directement au niveau du port
d'entrée du nœud. Cette fonction peut être appliquée à toute entrée entrante d'un nœud et vous permet d'accéder aux niveaux de vos listes plus rapidement et
plus facilement que d'autres méthodes. Indiquez simplement au nœud le niveau de la liste que vous souhaitez utiliser comme entrée et laissez le nœud faire
le reste.

Exercice - List@Level

Dans cet exercice, vous allez utiliser la fonction List@Level pour isoler un niveau de données spécifique.

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") : List@Level.
Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

1. Nous allons commencer par une grille de points 3D simple.

2. Puisque la grille est construite avec une intervalle pour X, Y et Z, vous savez que les données sont structurées avec trois niveaux : une liste X,
une liste Y et une liste Z.
3. Ces niveaux existent à différents niveaux. Les niveaux sont indiqués en bas de la bulle d'aperçu. Les colonnes de niveaux de la liste
correspondent aux données de liste ci-dessus pour vous aider à identifier le niveau à utiliser.
4. Les niveaux de liste sont organisés dans l'ordre inverse de sorte que les données de niveau le plus bas soient toujours dans "L1". Cela permet
de garantir le fonctionnement de vos graphiques tels qu'ils seront planifiés, même si tout est modifié en amont.
 1. Pour utiliser la fonction List@Level, cliquez sur '>'. Dans ce menu, vous verrez deux cases à cocher.
2. Utiliser les niveaux : permet d'activer la fonctionnalité List@Level. Après avoir cliqué sur cette option, vous pourrez sélectionner les niveaux
de liste d'entrée que le nœud doit utiliser. Ce menu vous permet de tester rapidement différentes options de niveau en cliquant sur les boutons
haut ou bas.
3. Conserver la structure de la liste : si cette option est activée, vous pouvez conserver la structure de niveau de cette entrée. Parfois, vous avez
peut-être délibérément organisé vos données en sous-listes. En cochant cette option, vous pouvez conserver votre organisation de liste intacte
et ne perdre aucune information.

La grille 3D simple vous permet d'accéder à la structure de la liste et de la visualiser en passant par les niveaux de liste. Chaque combinaison de niveau de
liste et d'index renvoie un jeu de points différent de votre jeu 3D d'origine.

1. Dans DesignScript, "@L2" permet de sélectionner uniquement la liste au niveau 2.

2. La liste au niveau 2 avec l'index 0 inclut uniquement le premier jeu de points Y, renvoyant uniquement la grille XZ.
3. Si vous définissez le filtre de niveaux sur "L1", vous pourrez voir l'intégralité du contenu du premier niveau de la liste. La liste au niveau 1
avec l'index 0 inclut tous vos points 3D dans une liste simple.
4. Si vous essayez de la même façon pour "L3", vous ne verrez que les troisièmes points de niveau de liste. La liste au niveau 3 avec l'index 0
inclut uniquement le premier jeu de points Z, renvoyant uniquement une grille XY.
5. Si vous essayez de la même façon pour "L4", vous ne verrez que les troisième points de niveau de liste. La liste au niveau 4 avec l'index 0
inclut uniquement le premier jeu de points X, renvoyant uniquement une grille YZ.

Bien que cet exemple particulier puisse également être créé avec [Link], List@Level simplifie grandement l'interaction, ce qui facilite l'accès aux
données de nœud. Comparez les méthodes [Link] et List@Level ci-dessous :
 1. Bien que les deux méthodes vous donnent accès aux mêmes points, la méthode List@Level vous permet de basculer facilement entre les
couches de données au sein d'un nœud unique.
2. Pour accéder à une grille de points avec [Link], vous avez besoin d'un nœud [Link] avec [Link]. Pour chaque niveau de
liste que vous allez descendre, utilisez un nœud [Link] supplémentaire. Selon la complexité de vos listes, vous devrez peut-être ajouter une
quantité importante de nœuds [Link] à votre graphique pour accéder au niveau d'informations approprié.
3. Dans cet exemple, un nœud [Link] avec un nœud [Link] renvoie le même jeu de points avec la même structure de liste que
[Link] avec '@L3' sélectionné.

Transposer
La fonction Transposer est une fonction fondamentale lorsque vous travaillez avec des listes de listes. Tout comme dans les programmes de feuille de
calcul, une transposition inverse les colonnes et les lignes d'une structure de données. Nous allons le démontrer avec une matrice de base ci-dessous. Dans la
section suivante, nous allons montrer comment une transposition peut être utilisée pour créer des relations géométriques.

Exercice - [Link]

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") :
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.
Supprimez les nœuds [Link] de l'exercice précédent et passez à une géométrie pour voir comment les données sont structurées.

1. Connectez un nœud [Link] à la sortie du nœud Watch à partir de [Link].

2. Le résultat affiche 5 polycourbes et les courbes sont visibles dans l'aperçu Dynamo. Le nœud Dynamo recherche une liste de points (ou une
liste de listes de points dans ce cas) et crée une polycourbe à partir de ces points. Chaque liste a en fait été convertie en une courbe dans la
structure de données.

1. Si vous souhaitez isoler une ligne de courbes, utilisez le nœud [Link].

2. À l'aide d'une valeur de bloc de code égale à 2, recherchez le troisième élément dans la liste principale.
3. Le nœud [Link] vous donne une courbe, car une seule liste est connectée au nœud.
 1. Un nœud [Link] permet de remplacer l'ensemble des éléments par toutes les listes dans une liste de listes. Cette opération semble
compliquée, mais la logique est la même que pour la fonction Transposer dans Microsoft Excel : remplacer des colonnes par des lignes dans
une structure de données.
2. Observez le résultat abstrait : la transposition a modifié la structure de la liste d'une liste de 5 listes comportant chacune 3 éléments en 3 listes
contenant 5 éléments.
3. Observez le résultat géométrique : à l'aide du nœud [Link], vous obtenez 3 polycourbes perpendiculaires aux courbes d'origine.

Création de bloc de code

Le raccourci de bloc de code utilise "[]" pour définir une liste. Cette méthode est beaucoup plus rapide et fluide pour créer une liste que le nœud [Link].
Les blocs de code sont traités en détail dans le chapitre 7. Consultez l'image ci-dessous pour découvrir comment définir une liste contenant plusieurs
expressions à l'aide d'un bloc de code.

Requête de bloc de code

Le raccourci de bloc de code utilise "[]" pour sélectionner facilement et rapidement des éléments spécifiques à partir d'une structure de données complexe.
Les blocs de code sont traités en détail dans le chapitre 7. Consultez l'image ci-dessous pour découvrir comment interroger une liste contenant plusieurs
types de données à l'aide d'un bloc de code.
Exercice - Interrogation et insertion de données
Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous...") :
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Cet exercice utilise une partie de la logique établie dans l'exercice précédent pour modifier une surface. Votre objectif ici est intuitif, mais la navigation dans
la structure de données sera plus importante. Nous voulons articuler une surface en déplaçant un point de contrôle.

1. Commencez par la chaîne de nœuds ci-dessus. Vous allez créer une surface de base qui s'étend sur la grille Dynamo par défaut.
2. À l'aide du bloc de code, insérez ces deux lignes de code et connectez-les aux entrées u et v de [Link], respectivement :

-50..50..#3;
-50..50..#5;

1. Veillez à définir la liaison de [Link] sur "Produit vectoriel".

2. Le nœud Watch indique que vous avez une liste de 3 listes, chacune comportant 5 éléments.
Dans cette étape, vous allez interroger le point central de la grille créée. Pour ce faire, sélectionnez le point central dans la liste centrale. Logique, non ?

1. Pour confirmer qu'il s'agit du bon point, vous pouvez également cliquer sur les éléments du nœud Watch pour confirmer que vous ciblez le bon
point.
2. À l'aide de l'option bloc de code, écrivez une ligne de code de base afin d'interroger une liste de listes : points[1][2];
3. À l'aide de [Link], vous allez déplacer le point sélectionné vers le haut dans la direction Z de 20 unités.

1. Sélectionnez également la ligne centrale des points avec un nœud [Link]. Remarque : comme lors de l'étape précédente, vous
pouvez également interroger la liste avec le bloc de code, à l'aide d'une ligne de points[1];
Jusqu'à présent, vous avez interrogé le point central et l'avez déplacé vers le haut. Vous devez à présent insérer ce point déplacé dans la structure de
données d'origine.

1. Vous devez d'abord remplacer l'élément de la liste isolé à l'étape précédente.

2. À l'aide de [Link], remplacez l'élément central à l'aide d'un index de "2" par l'élément de remplacement connecté au point
déplacé ([Link]).
3. La sortie montre que vous avez saisi le point déplacé dans l'élément central de la liste.

Maintenant que vous avez modifié la liste, vous devez la réinsérer dans la structure de données d'origine : la liste de listes.

1. En suivant la même logique, utilisez [Link] pour remplacer la liste centrale par la liste modifiée.
2. Les blocs de code définissant l'index de ces deux nœuds sont 1 et 2, ce qui correspond à la requête d'origine du bloc de code (points[1][2]).
3. En sélectionnant la liste à l'index 1, la structure de données s'affiche en surbrillance dans l'aperçu Dynamo. Vous avez fusionné le point
déplacé dans la structure de données d'origine.
Il existe plusieurs façons de créer une surface à partir de cet ensemble de points. Dans ce cas, vous allez créer une surface en lissant des courbes.

1. Créez un nœud [Link] et connectez la nouvelle structure de données pour créer trois courbes NURBS.

1. Connectez une surface [Link] à la sortie de [Link]. Vous avez maintenant une surface modifiée. Vous pouvez modifier
la valeur Z d'origine de la géométrie. Effectuez la conversion et observez la mise à jour de la géométrie.
Listes à n dimensions
Listes à n dimensions
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 [Link] et [Link] 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 les fichiers d'exemple joints à cet exercice (cliquez avec le bouton droit de la souris et sélectionnez "Enregistrer le lien sous..."). Vous
trouverez la liste complète des fichiers d'exemple dans l'annexe. [Link] [Link]

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 [Link], 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 [Link].
L'étape suivante consiste à diviser la surface en une grille de points.

1. À l'aide d'un bloc de code, insérez les deux lignes de code suivantes :

0..1..#10;
0..1..#5;

1. Avec le nœud [Link], connectez les deux valeurs de bloc de code à u et v. Définissez la liaison de ce nœud sur "Produit
vectoriel".
2. La sortie révèle la structure des données, également visible dans l'aperçu Dynamo.

1. Pour voir comment la structure de données est organisée, connectez un nœud [Link] à la sortie de [Link].
2. Dix courbes sont placées verticalement le long de la surface.
 1. Un nœud [Link] de base permet d'inverser les colonnes et les lignes d'une liste de listes.
2. Lorsque vous connectez la sortie de [Link] à [Link], vous obtenez cinq courbes placées horizontalement sur la surface.

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 [Link].
 1. À l'aide du nœud [Link], 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 bloc de code avec les deux lignes de code suivantes :

0..1..#10;
0..1..#5;

1. Connectez ces sorties à deux nœuds [Link] dont la liaison 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. Comme dans l'exercice précédent, connectez les sorties à deux nœuds [Link].
2. L'aperçu Dynamo affiche deux courbes, correspondant à deux surfaces.

1. Le nœud [Link] 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 [Link], vous pouvez visualiser cette structure de données. Le nœud lisse toutes les courbes de chaque sous-liste.
1. Si vous utilisez le nœud [Link], 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.
2. Le nœud [Link] vous permet d'obtenir une structure nervurée.

1. Le nœud [Link] constitue une alternative au nœud [Link]. Il exécute un "combinateur" sur chaque sous-liste.
2. Dans ce cas, vous utilisez [Link] en tant que "combinateur" qui va créer une liste de chaque élément dans les sous-listes.
3. Le nœud [Link] 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 [Link] s'avère plus fiable.
 1. Si vous souhaitez inverser l'orientation des courbes dans la structure nervurée, utilisez un nœud [Link] avant de les connecter à
[Link]. Cette action permet d'inverser les colonnes et les lignes et d'obtenir 5 nervures horizontales.

Exercice - Listes 3D

Vous allez désormais aller encore un peu plus loin. Dans cet exercice, vous allez travailler avec les deux surfaces importées et créer une hiérarchie de
données complexe. L'objectif est néanmoins d'effectuer la même opération avec la même logique sous-jacente.

1. Commencez par le fichier importé de l'exercice précédent.

 1. Comme dans l'exercice précédent, utilisez le nœud [Link] pour effectuer un décalage d'une valeur de 10.
2. Dans la sortie, vous pouvez voir que le nœud de décalage a créé deux surfaces.

1. De la même façon que dans l'exercice précédent, définissez un bloc de code avec les deux lignes de code suivantes :

0..1..#20;
0..1..#10;

1. Connectez ces sorties à deux nœuds [Link] dont la combinaison est définie sur "Produit vectoriel". L'un de ces nœuds est
connecté aux surfaces d'origine, tandis que l'autre est connecté aux surfaces décalées.
1. Comme dans l'exercice précédent, connectez les sorties à deux nœuds [Link].
2. Observez la sortie de [Link] : il s'agit d'une liste de deux listes, ce qui est plus complexe que l'exercice précédent. Étant donné
que les données sont classées par la surface sous-jacente, un autre niveau a été ajouté à la structure des données.
3. Les choses deviennent plus complexes dans le nœud [Link]. Dans ce cas, vous avez une liste de listes de listes.

1. À l'aide du nœud [Link], fusionnez les courbes NURBS en une structure de données, créant ainsi une liste de listes de listes.
2. Lorsque vous connectez un nœud [Link], vous obtenez une version des surfaces d'origine, car elles restent toutes dans leur propre liste
telle qu'elle a été créée à partir de la structure de données d'origine.
1. Dans l'exercice précédent, le fichier [Link] a été utilisé pour créer une structure nervurée. Ce ne sera pas possible ici. Vous devez
utiliser une transposition sur une liste bidimensionnelle. Étant donné que vous avez une liste tridimensionnelle, une opération de "basculement
des colonnes et des lignes" ne fonctionnera pas aussi facilement. N'oubliez pas que les listes sont des objets. Par conséquent, le nœud
[Link] inverse vos listes sans les sous-listes, mais n'inverse pas les courbes NURBS d'une liste plus bas dans la hiérarchie.

1. Le nœud [Link] fonctionne mieux ici. Lorsque vous obtenez des structures de données plus complexes, utilisez les nœuds [Link] et
[Link].
2. L'utilisation du nœud [Link] comme "combinateur" vous permet de créer une structure de données plus appropriée.
1. La structure de données doit toujours être transposée à une étape inférieure de la hiérarchie. Pour ce faire, utilisez [Link]. Ce nœud
fonctionne comme [Link], sauf qu'il utilise une liste d'entrées, au lieu de deux listes ou plus.
2. La fonction appliquée à [Link] est [Link], permettant d'inverser les colonnes et les lignes des sous-listes dans la liste principale.

1. Enfin, vous pouvez lisser les courbes NURBS avec une hiérarchie de données correcte. Vous obtenez ainsi une structure nervurée.
1. Ajoutez de la profondeur à la géométrie grâce au nœud [Link].

1. Il serait intéressant d'ajouter un support de surface sur deux structures. Pour ce faire, utilisez [Link] pour sélectionner la surface
arrière des surfaces lissées lors des étapes précédentes.
 1. L'articulation se termine lorsque vous avez épaissi les surfaces sélectionnées.

Ce n'est pas la chaise à bascule la plus confortable au monde, mais elle contient de nombreuses données.
Pour la dernière étape, inversez la direction des éléments striés. Dans l'exercice précédent, vous avez utilisé l'option Transposer. La procédure à suivre
est similaire ici.

1. Étant donné qu'un niveau supplémentaire a été ajouté à la hiérarchie, vous devez utiliser [Link] avec une fonction [Link] pour
modifier la direction des courbes NURBS.

1. Augmentez le nombre de girons de façon à pouvoir modifier le bloc de code comme suit :

0..1..#20;
0..1..#10;
La première version de la chaise à bascule était lisse. Le second modèle propose une chaise à bascule sportive originale.
Blocs de code et DesignScript
Blocs de code et DesignScript
Le bloc de code est une fonction unique de Dynamo qui lie de manière dynamique un environnement de programmation visuel avec un environnement de
texte. Le bloc de code a accès à tous les nœuds Dynamo et peut définir un graphique entier dans un nœud. Lisez attentivement ce chapitre, car le bloc de
code est un bloc de construction fondamental de Dynamo.
Qu'est-ce qu'un bloc de code ?
Qu'est-ce qu'un bloc de code ?
Les blocs de code permettent d'aborder de manière approfondie DesignScript, le langage de programmation au coeur de Dynamo. Conçu à partir de zéro
pour prendre en charge les workflows de conception exploratoires, DesignScript est un langage lisible et concis qui offre un retour immédiat aux petits
éléments de code et s'adapte aux interactions complexes et importantes. DesignScript constitue également la "colonne vertébrale" du moteur qui pilote la
plupart des aspects de Dynamo "sous le capot". Étant donné que la quasi-totalité des fonctionnalités que l'on trouve dans les nœuds et les interactions
Dynamo ont une relation individuelle avec le langage de génération de script, il existe des possibilités uniques de se déplacer entre les interactions basées
sur les nœuds et la génération de scripts de manière fluide.

Pour les débutants, les nœuds peuvent être automatiquement convertis en syntaxe de texte pour faciliter l'apprentissage de DesignScript ou simplement pour
réduire la taille des sections de graphiques plus grandes. Cette opération est effectuée à l'aide d'un processus appelé "Nœud vers code", qui est présenté en
détail dans la section Syntaxe DesignScript. Les utilisateurs plus expérimentés peuvent utiliser les blocs de code pour créer des combinaisons personnalisées
de fonctionnalités existantes et de relations créées par l'utilisateur à l'aide de nombreux paradigmes de codage standard. Entre l'utilisation par des débutants
et celle d'utilisateurs expérimentés, il existe un grand nombre de raccourcis et d'extraits de code qui pourront accélérer vos conceptions. Bien que le terme
"bloc de code" soit un peu intimidant pour les utilisateurs qui ne sont pas programmeurs, ce concept est à la fois facile à utiliser et robuste. Un débutant peut
utiliser le bloc de code efficacement avec un minimum de codage, et un utilisateur avancé peut définir des définitions de script à utiliser ailleurs dans une
définition Dynamo.

Bloc de code : présentation générale

Pour faire court, les blocs de code sont une interface de génération de script de texte au sein d'un environnement de script visuel. Ils peuvent être utilisés en
tant que nombres, chaînes, formules et autres types de données. Le bloc de code est conçu pour Dynamo, de sorte que l'on peut définir des variables
arbitraires dans le bloc de code, et ces variables sont automatiquement ajoutées aux entrées du nœud :

Avec les blocs de code, l'utilisateur peut décider de la méthode de spécification des entrées de manière flexible. Voici plusieurs méthodes pour créer un
point de base avec les coordonnées (10, 5, 0) :
Au fur et à mesure que vous découvrez les fonctions disponibles dans la bibliothèque, vous pouvez même constater que saisir "[Link]" est
plus rapide que d'effectuer une recherche dans la bibliothèque et trouver le nœud approprié. Lorsque vous tapez "Point", par exemple, Dynamo affiche une
liste des fonctions possibles à appliquer à un point. Cela rend le script plus intuitif et aide à apprendre comment appliquer les fonctions dans Dynamo.

Création de nœuds de bloc de code

Le bloc de code se trouve dans Core > Entrée > Actions > Bloc de code. Pour aller plus vite, il suffit de cliquer deux fois sur la zone de dessin pour afficher
le bloc de code. Ce nœud est si souvent utilisé qu'il dispose de privilèges de double-clic.

Numéros, chaînes et formules

Les blocs de code sont également flexibles en ce qui concerne les types de données. L'utilisateur peut rapidement définir des nombres, des chaînes et des
formules, et le bloc de code fournit la sortie souhaitée.

Dans l'image ci-dessous, vous pouvez voir que la manière "classique" de faire les choses est un peu longue : l'utilisateur recherche le nœud voulu dans
l'interface, ajoute le nœud à la zone de dessin, puis saisit les données. Avec le bloc de code, l'utilisateur peut double-cliquer sur la zone de dessin pour
afficher le nœud et entrer le type de données correct avec la syntaxe de base.

Les nœuds number, string et formula sont trois exemples de nœuds Dynamo qui sont probablement obsolètes par rapport au bloc de code.
Syntaxe DesignScript
Syntaxe DesignScript
Vous avez peut-être remarqué que les noms des nœuds dans Dynamo ont un point commun : chaque nœud utilise la syntaxe "." sans espaces. Cela est dû au
fait que le texte situé en haut de chaque nœud représente la syntaxe réelle pour l'écriture de scripts, et que la syntaxe "." (ou notation par points) sépare un
élément des méthodes qu'il est possible d'appeler. Cette syntaxe permet de convertir facilement les scripts visuels en scripts basés sur du texte.

Prenons une pomme paramétrique comme analogie générale de la notation par points : comment pouvez-vous la traiter dans Dynamo ? Voici quelques
méthodes que vous allez exécuter sur la pomme avant de la manger. (Remarque : il ne s'agit pas de méthodes Dynamo réelles) :

Visible de tous Notation par points Sortie

De quelle couleur est la pomme ? [Link] rouge
La pomme est-elle mûre ? [Link] true
Combien la pomme pèse-t-elle ? [Link] 170 g
D'où vient la pomme ? [Link] arborescence
Qu'est-ce que la pomme crée ? [Link] graines
Cette pomme est-elle produite localement ? [Link] 100 km

Je ne sais pas ce que vous en pensez, mais à en juger par les sorties du tableau ci-dessus, cette pomme est très appétissante. Je pense que je vais la manger :
[Link]().

Notation par points dans le bloc de code

En ayant à l'esprit l'analogie de la pomme, examinez [Link] et découvrez comment créer un point à l'aide du bloc de code :

La syntaxe du bloc de code [Link](0,10); donne le même résultat qu'un nœud [Link] dans Dynamo, sauf que
vous pouvez créer un point à l'aide d'un nœud. Cette opération est plus efficace que la connexion d'un nœud distinct à "X" et "Y".

1. La syntaxe [Link] du bloc de code vous permet d'indiquer les entrées dans le même ordre que le nœud prêt à l'emploi (X,Y).

Appel de nœuds
Vous pouvez appeler n'importe quel nœud standard dans la bibliothèque par le biais d'un bloc de code tant que le nœud n'est pas un nœud d'interface
utilisateur spécial : les nœuds dotés d'une fonction d'interface utilisateur spéciale. Par exemple, vous pouvez appeler [Link], mais il
n'est pas logique d'appeler un nœud Watch 3D.
Il existe généralement trois types de nœuds standard (la plupart des nœuds de votre bibliothèque) :

Create : permet de créer (ou de construire) un élément

Action : permet d'effectuer une action sur un élément
Query : permet d'obtenir une propriété d'un élément existant

La bibliothèque est organisée en fonction de ces catégories. Les méthodes ou les nœuds de ces trois types sont traités différemment lorsqu'ils sont appelés
dans un bloc de code.

Create

La catégorie "Create" permet de créer une géométrie à partir de zéro. Vous entrez des valeurs de gauche à droite dans le bloc de code. Ces entrées
apparaissent dans le même ordre que les entrées du nœud de haut en bas :

En comparant le nœud [Link] et la syntaxe correspondante dans le bloc de code, vous obtenez les mêmes résultats.

Action

Une action est une opération effectuée sur un objet de ce type. Pour appliquer une action à un élément, Dynamo utilise la notation par points, commune à de
nombreux langages de codage. Une fois que vous avez l'élément, tapez un point, puis le nom de l'action. L'entrée de la méthode de type action est mise entre
parenthèses tout comme celle des méthodes de type création. Cependant, il n'est pas nécessaire de spécifier la première entrée que vous voyez sur le nœud
correspondant. Au lieu de cela, vous devez indiquer l'élément sur lequel vous effectuez l'action :
 1. Étant donné que le nœud [Link] est un nœud de type action, la syntaxe fonctionne un peu différemment.
2. Les entrées sont (1) le point et (2) le vecteur à ajouter. Dans un bloc de code, le point (l'élément) est nommé "pt". Pour ajouter un vecteur
nommé "vec" à "pt", écrivez [Link](vec) ou : élément, point, action. L'action Ajouter ne possède qu'une seule entrée, ou toutes les entrées du
nœud [Link] sauf la première. La première entrée du nœud [Link] est le point lui-même.

Query

Les méthodes de type Query permettent d'obtenir une propriété d'un objet. Puisque l'objet lui-même est l'entrée, vous n'avez pas besoin de spécifier
d'entrées. Aucune parenthèse n'est requise.

Qu'en est-il de la combinaison ?

Avec des nœuds, la combinaison est légèrement différente de celle avec le bloc de code. Avec les nœuds, l'utilisateur clique avec le bouton droit de la souris
sur le nœud et sélectionne l'option de combinaison à effectuer. Avec le bloc de code, l'utilisateur dispose d'un contrôle bien plus précis sur la structure des
données. La méthode de raccourci du bloc de code utilise des guides de réplication pour définir la manière dont plusieurs listes unidimensionnelles sont
associées. Les nombres mis entre crochets angulaires "<>" définissent la hiérarchie de la liste imbriquée obtenue : <1>,<2>,<3>, etc.
 1. Dans cet exemple, un raccourci est utilisé pour définir deux intervalles (vous trouverez plus d'informations sur le raccourci dans la section
suivante de ce chapitre). En résumé, 0..1; équivaut à {0,1} et -3...-7équivaut à {-3,-4,-5,-6,-7}. Le résultat vous donne des
listes de 2 valeurs X et 5 valeurs Y. Si vous n'utilisez pas de guides de réplication avec ces listes incohérentes, vous obtenez une liste de deux
points, correspondant à la longueur de la liste la plus courte. Les guides de réplication vous permettent de trouver toutes les liaisons possibles
de 2 et 5 coordonnées (ou, un Produit cartésien).
2. La syntaxe [Link](x_vals<1>,y_vals<2>); vous permet d'obtenir deux listes contenant chacune cinq éléments.
3. La syntaxe [Link](x_vals<2>,y_vals<1>); vous permet d'obtenir cinq listes contenant chacune deux éléments.

Avec cette notation, vous pouvez également indiquer le type de liste dominant : 2 listes de 5 éléments ou 5 listes de 2 éléments. Dans cet exemple, la
modification de l'ordre des guides de réplication crée une liste de lignes de points ou une liste de colonnes de points dans une grille.

Nœud vers code

Bien que les méthodes de bloc de code susmentionnées puissent prendre en charge certains éléments, Dynamo inclut une fonctionnalité appelée "Nœud vers
code" qui facilite le processus. Pour utiliser cette fonction, sélectionnez un réseau de nœuds dans votre graphique Dynamo, cliquez avec le bouton droit de
la souris sur la zone de dessin et sélectionnez "Nœud vers code". Dynamo convertit ces nœuds en bloc de code, avec toutes les entrées et sorties ! Non
seulement cet outil est idéal pour découvrir les blocs de code, mais il vous permet également de travailler avec un graphique Dynamo paramétrique et plus
efficace. Ne manquez pas la fin de l'exercice ci-dessous : vous découvrirez l'utilisation de "Nœud vers code".
Exercice
Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous trouverez
la liste complète des fichiers d'exemple dans l'annexe. Dynamo-Syntax_Attractor-[Link]

Pour afficher la puissance du bloc de code, vous allez convertir une définition de champ d'attraction existante en formulaire de bloc de code. L'utilisation
d'une définition existante montre comment le bloc de code est lié aux scripts visuels et est utile pour découvrir la syntaxe DesignScript.

Commencez par recréer la définition dans l'image ci-dessus (ou en ouvrant le fichier d'exemple).

1. Notez que la liaison sur [Link] a été définie sur Produit cartésien.
2. Chaque point d'une grille est déplacé vers le haut dans la direction Z en fonction de sa distance par rapport au point de référence.
3. Une surface est recréée et épaissie, créant ainsi un renflement dans la géométrie par rapport à la distance par rapport au point de référence.
1. En commençant au début, définissez d'abord le point de référence : [Link](x,y,0);. Utilisez la même syntaxe
[Link] que celle indiquée dans la partie supérieure du nœud du point de référence.
2. Les variables x et y sont insérées dans le bloc de code afin que vous puissiez les mettre à jour de façon dynamique avec des curseurs.
3. Ajoutez des curseurs aux entrées du bloc de code qui vont de -50 à 50. Vous pouvez ainsi étendre la grille Dynamo par défaut.

1. Dans la deuxième ligne du bloc de code, définissez un raccourci pour remplacer le nœud Number Sequence : coordsXY =
(-50..50..#11);. Cette question est abordée plus en détail dans la section suivante. Pour le moment, notez que ce raccourci est
équivalent au nœud Number Sequence dans le script visuel.
1. Vous devez désormais créer une grille de points à partir de la séquence coordsXY. Pour ce faire, utilisez la syntaxe [Link], et
lancez un Produit cartésien de la liste de la même manière que dans le script visuel. Pour ce faire, entrez la ligne : gridPts =
[Link](coordsXY<1>,coordsXY<2>,0);. Les crochets angulaires indiquent la référence du produit cartésien.
2. Le nœud Watch3D présente une grille de points sur la grille Dynamo.

1. Difficulté : déplacer la grille de points vers le haut en fonction de leur distance par rapport au point de référence. Tout d'abord, appelez ce
nouvel ensemble de points transPts. Étant donné qu'une conversion est une action sur un élément existant, utilisez [Link] au
lieu de [Link]....
2. Le nœud réel sur la zone de dessin indique trois entrées. La géométrie à convertir est déjà déclarée, car vous effectuez l'action sur cet élément
(avec [Link]). Les deux entrées restantes seront insérées entre parenthèses de la fonction : direction et distance.
3. La direction est assez simple :·utilisez un nœud [Link]() pour vous déplacer verticalement.
4. La distance entre le point de référence et chaque point de grille doit encore être calculée. Pour ce faire, effectuez une action au point de
référence de la même manière : [Link](gridPts).
5. La dernière ligne de code vous donne les points convertis : transPts =
 [Link]([Link](),[Link](gridPts));.

1. Vous disposez à présent d'une grille de points avec la structure de données appropriée pour créer une surface NURBS. Construisez la surface
en utilisant srf = [Link](transPts);.

1. Enfin, pour ajouter de la profondeur à la surface, construisez un solide en utilisant solide = [Link](5);. Dans ce cas, la surface
a été épaissie de 5 unités dans le code, mais vous pouvez toujours déclarer cela comme variable (en l'appelant thickness par exemple), puis
contrôler cette valeur avec un curseur.

Simplifier le graphique avec "Nœud vers code"

La fonctionnalité "Nœud vers code" permet d'automatiser d'un simple clic l'ensemble de l'exercice que vous venez de réaliser. Non seulement cette
fonctionnalité est très utile pour créer des définitions personnalisées et des blocs de code réutilisables, mais elle est également un outil très pratique pour
apprendre à utiliser des scripts dans Dynamo :
 1. Commencez par le script visuel existant de l'étape 1 de l'exercice. Sélectionnez tous les nœuds, cliquez avec le bouton droit de la souris sur la
zone de dessin et sélectionnez "Nœud vers code". C'est aussi simple que ça.

Dynamo a automatisé une version texte du graphique visuel, de la liaison, etc. Testez cette opération sur vos scripts visuels et libérez la puissance du
bloc de code !
Raccourci
Raccourci
Il existe quelques méthodes de base pour raccourcir le bloc de code qui simplifient énormément la gestion des données. Vous allez découvrir les concepts de
base ci-dessous et comprendre comment ce raccourci peut être utilisé à la fois pour créer et interroger des données.

Type de
Dynamo standard
données

Nombres

Chaînes

Séquences
Intervalles

Obtenir
l'élément au
niveau de
l'index

Création d'une
liste

Concaténer des
chaînes
 Concaténer des
chaînes

Instructions
conditionnelles

Syntaxe supplémentaire

Bloc de code
Nœud(s) Remarque
équivalent
Tout opérateur (+, &&, +, &&, >=, !, Notez que "Not" devient "!" mais que le nœud est appelé "Not" pour
>=, Not, etc.) etc. faire la distinction avec "Factorial"
Valeur booléenne True true; Minuscules
Valeur booléenne False false; Minuscules

Intervalles

La méthode de définition des intervalles et des séquences peut être réduite au raccourci de base. Utilisez l'image ci-dessous comme guide de la syntaxe ".."
pour définir une liste de données numériques avec un bloc de code. Après avoir obtenu l'arrêt de cette notation, la création de données numériques est un
processus vraiment efficace :

1. Dans cet exemple, un intervalle de nombres est remplacé par la syntaxe de bloc de code de base définissant beginning..end..step-
size;. Représentés numériquement, voici le résultat : 0..10..1;
2. La syntaxe 0..10..1; est équivalente à 0..10;. La taille de pas 1 est la valeur par défaut de la notation de la plus courte. Par conséquent,
0..10; donne une séquence de 0 à 10 avec une taille de pas de 1.
 3. L'exemple de la séquence de nombres est similaire, sauf que vous devez utiliser "#" pour indiquer que vous voulez 15 valeurs dans la liste,
plutôt qu'une liste qui atteint 15. Dans ce cas, définissez ce qui suit : beginning..#ofSteps..step-size. La syntaxe réelle de la
séquence est 0..#15..2
4. Placez "#" de l'étape précédente dans la partie "taille de pas" de la syntaxe. À présent, vous avez un intervalle de nombres qui s'étend du
"début" à la "fin" et la notation "taille de pas" distribue uniformément un certain nombre de valeurs entre les deux valeurs :
beginning..end..#ofSteps

Intervalles avancés

La création d'intervalles avancés vous permet de travailler avec une liste de listes en toute simplicité. Dans les exemples ci-dessous, découvrez comment
isoler une variable de la notation d'intervalle principale et créer une autre série de cette liste.

1. En créant des intervalles imbriqués, comparez la notation avec "#" et la notation sans. La même logique s'applique aux intervalles de base, à la
différence qu'elle devient un peu plus complexe.
2. Vous pouvez définir un sous-intervalle à n'importe quel endroit de l'intervalle principal, et avoir aussi deux sous-intervalles.
3. En contrôlant la valeur de "fin" dans un intervalle, vous pouvez créer davantage d'intervalles de longueurs différentes.
 Dans le cadre d'un exercice logique, comparez les deux raccourcis ci-dessus et analysez comment les sous-intervalles et la notation "#" déterminent la
sortie résultante.

Création de listes et obtention d'éléments à partir d'une liste

Outre la création de listes avec un raccourci, vous pouvez également créer des listes à la volée. Ces listes peuvent contenir une large gamme de types
d'éléments et peuvent également être interrogées (rappelez-vous que les listes sont des objets en eux-mêmes). Pour résumer, un bloc de code vous permet de
créer des listes avec des accolades et d'interroger des éléments d'une liste avec des crochets :

1. Créez rapidement des listes avec des chaînes et interrogez-les à l'aide de l'index d'éléments.
2. Créez des listes avec des variables et interrogez-les à l'aide de la notation du raccourci d'intervalle.

La gestion de listes imbriquées est un processus similaire. Veillez à l'ordre de la liste et n'oubliez pas d'utiliser plusieurs jeux de crochets :
 1. Définissez une liste de listes.
2. Interrogez une liste avec une notation de crochet simple.
3. Interrogez un élément avec une notation entre crochets.

Exercice

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous trouverez
la liste complète des fichiers d'exemple dans l'annexe. Obsolete-Nodes_Sine-[Link]

Dans cet exercice, vous allez perfectionner vos nouvelles compétences en concevant une super surface en coquille d'oeuf définie par des intervalles et des
formules. Au cours de cet exercice, vous découvrirez comment utiliser le bloc de code et les nœuds Dynamo existants en tandem : le bloc de code est utilisé
pour le gros volume de données, tandis que les nœuds Dynamo sont visuellement disposés pour la lisibilité de la définition.

Commencez par créer une surface en connectant les nœuds ci-dessus. Au lieu d'utiliser un nœud Number pour définir la largeur et la longueur, cliquez
deux fois sur la zone de dessin et tapez 100; dans un bloc de code.
 1. Définissez un intervalle compris entre 0 et 1 et 50 divisions en tapant 0..1..#50 dans un bloc de code.
2. Connectez l'intervalle à [Link], qui prend les valeurs u et v entre 0 et 1 sur la surface. Pensez à définir la liaison sur
Produit cartésien en cliquant avec le bouton droit de la souris sur le nœud [Link].

Dans cette étape, vous allez utiliser votre première fonction pour déplacer la grille de points vers le haut sur l'axe Z. Cette grille pilotera une surface
générée reposant sur la fonction sous-jacente.

1. Ajoutez les nœuds visuels à la zone de dessin, comme illustré dans l'image ci-dessus.
2. Au lieu d'utiliser un nœud Formula, utilisez un bloc de code avec la ligne : (0..[Link](x*360)..#50)*5;. Pour décomposer
rapidement cet intervalle, définissez un intervalle contenant une formule. Cette formule est la fonction Sinus. La fonction Sinus reçoit les
entrées de degrés dans Dynamo. Ainsi, pour obtenir une onde sinusoïdale complète, multipliez les valeurs x (valeur d'entrée de l'intervalle de 0
à 1) par 360. Ensuite, utilisez le même nombre de divisions que les points de grille de contrôle pour chaque ligne. Définissez donc 50 sous-
divisions avec #50. Enfin, le multiplicateur de 5 augmente simplement l'amplitude de la translation de sorte que l'effet soit visible dans l'aperçu
Dynamo.
1. Même si le bloc de code précédent fonctionnait correctement, il n'était pas entièrement paramétrique. Pour piloter ses paramètres de manière
dynamique, remplacez la ligne de l'étape précédente par (0..[Link](x*360*cycles)..#[Link](x))*amp;. Cela vous
donne la possibilité de définir ces valeurs en fonction des entrées.

1. La modification des curseurs (de 0 à 10) permet d'obtenir des résultats intéressants.
1. Lorsque vous effectuez une transposition sur l'intervalle de nombres, vous inversez la direction de l'onde du rideau : transposeList =
[Link](sineList);

1. Lorsque vous ajoutez sineList et tranposeLit, vous obtenez une surface en coquille d'oeuf déformée : eggShellList =
sineList+transposeList;
1. Modifiez à nouveau les curseurs pour retrouver un algorithme "paisible".

1. Enfin, recherchez des parties isolées des données avec le bloc de code. Pour régénérer la surface avec un intervalle de points spécifique,
ajoutez le bloc de code ci-dessus entre le nœud [Link] et le nœud [Link]. Cette ligne contient la ligne de texte :
sinusBandes[0..15..1];. Cela permet de sélectionner les 16 premières lignes de points (sur 50). Recréez la surface. Vous pouvez voir
que vous avez généré une partie isolée de la grille de points.
1. Dans la dernière étape, pour rendre ce bloc de code encore plus paramétrique, pilotez la requête en utilisant un curseur compris entre 0 et 1.
Pour ce faire, utilisez cette ligne de code : sinusBandes[0..(([Link](sineSrayures)-1)*u)];. Cela peut sembler
déroutant, mais la ligne de code vous donne un moyen rapide de mettre à l'échelle la longueur de la liste en un multiplicateur entre 0 et 1.

1. Une valeur de 0.53 sur le curseur permet de créer une surface juste au-delà du milieu de la grille.
 1. Comme prévu, un curseur de 1 crée une surface à partir de la grille complète de points.

En examinant le graphique obtenu, vous pouvez mettre en surbrillance les blocs de code et voir chacune de leurs fonctions.

1. Le premier bloc de code remplace le nœud Number.

2. Le deuxième bloc de code remplace le nœud Number Range.
3. Le troisième bloc de code remplace le nœud Formula (ainsi que [Link], [Link] et Number Range).
4. Le quatrième bloc de code interroge une liste de listes, remplaçant ainsi le nœud [Link].
Fonctions
Fonctions de bloc de code
Les fonctions peuvent être créées dans un bloc de code et rappelées ailleurs dans une définition Dynamo. Cela permet de créer un autre calque de contrôle
dans un fichier paramétrique et de l'afficher en tant que version de texte d'un nœud personnalisé. Dans ce cas, le bloc de code "parent" est facilement
accessible et peut être situé n'importe où sur le graphique. Aucun fil n'est nécessaire.

Parent

La première ligne comporte le mot clé "def", puis le nom de la fonction, puis les noms des entrées entre parenthèses. Les contreventements définissent le
corps de la fonction et renvoient une valeur avec "return =". Les nœuds Code Block qui définissent une fonction ne disposent pas de ports d'entrée ou de
sortie, car ils sont appelés à partir d'autres nœuds Code Block.

/*This is a multi-line comment,

which continues for
multiple lines*/
def FunctionName(in1,in2)
{
//This is a comment
sum = in1+in2;
return sum;
};

Enfants
Appelez la fonction avec un autre nœud Code Block dans le même fichier en donnant le nom et le même nombre d'arguments. Cela fonctionne comme les
nœuds prêts à l'emploi de votre bibliothèque.
FunctionName(in1,in2);

Exercice

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous trouverez
la liste complète des fichiers d'exemple dans l'annexe. Functions_SphereByZ.dyn

Dans cet exercice, vous allez créer une définition générique permettant d'obtenir des sphères à partir d'une liste de points d'entrée. Le rayon de ces sphères
est défini par la propriété Z de chaque point.

Commencez par une plage de dix valeurs allant de 0 à 100. Connectez-les à un nœud [Link] afin de créer une ligne diagonale.
 1. Créez un nœud Code Block et introduisez la définition en utilisant la ligne de code suivante :

def sphereByZ(inputPt){
};

Le terme inputPt est le nom donné pour représenter les points qui contrôlent la fonction. Pour l'instant, la fonction ne fait rien, mais vous allez la construire
dans les étapes à venir.

1. L'ajout de la fonction Code Block permet de placer un commentaire et une variable sphereRadius qui interroge la position Z de chaque point.
N'oubliez pas que inputPt.Z n'a pas besoin de parenthèses comme méthode. Il s'agit d'une requête des propriétés d'un élément existant, donc
aucune entrée n'est nécessaire :

def sphereByZ(inputPt,radiusRatio)
{
 //get Z Value, use it to drive radius of sphere
sphereRadius=inputPt.Z;
};

1. Rappelez-vous la fonction créée dans un autre Code Block. Si vous double-cliquez sur la zone de dessin pour créer un Code Block et que vous
tapez sphereB, Dynamo suggère la fonction sphereByZ que vous avez définie. Votre fonction a été ajoutée à la bibliothèque Intellisense. Bien.

1. Vous allez maintenant appeler la fonction et créer une variable appelée Pt afin de connecter les points créés dans les étapes précédentes :

sphereByZ(Pt)

1. La sortie ne contient que des valeurs nulles. Pourquoi ? Lorsque vous avez défini la fonction, vous avez calculé la variable sphereRadius, mais vous
n'avez pas défini ce que la fonction doit renvoyer en tant que sortie. Vous pourrez résoudre ce problème à l'étape suivante.
 1. Une étape importante consiste à définir la sortie de la fonction en ajoutant la ligne return = sphereRadius; à la fonction sphereByZ.
2. La sortie du nœud Code Block indique désormais les coordonnées Z de chaque point.

Modifiez la fonction Parent pour créer des sphères réelles.

1. Tout d'abord, définissez une sphère avec la ligne de code suivante :

sphere=[Link](inputPt,sphereRadius);.
2. Ensuite, modifiez la valeur renvoyée pour la définir comme sphere au lieu de sphereRadius : return = sphere;. Vous obtenez ainsi des
sphères géantes dans l'aperçu de Dynamo.
1. Pour modifier la taille de ces sphères, mettez à jour la valeur sphereRadius en ajoutant un séparateur : sphereRadius =
inputPt.Z/20;. Les sphères distinctes sont maintenant visibles et la relation entre le rayon et la valeur Z devient plus claire.

1. Sur le nœud [Link], remplacez la liaison Liste la plus courte par Produit cartésien afin de créer une grille de points. La fonction
sphereByZ reste pleinement effective, de sorte que tous les points créent des sphères avec des rayons fondés sur des valeurs Z.
1. Pour tâter le terrain, connectez simplement la liste de nombres d'origine à l'entrée X de [Link]. Vous obtenez ainsi un cube de
sphères.
2. Remarque : si le calcul sur votre ordinateur prend beaucoup de temps, essayez de remplacer nº 10 par un autre élément, nº 5 par exemple.

1. N'oubliez pas que la fonction sphereByZ créée est générique. Vous pouvez donc rappeler l'hélice d'une leçon précédente et lui appliquer la
fonction.
Dernière étape : déterminez le rapport des rayons avec un paramètre défini par l'utilisateur. Pour ce faire, vous devez créer une entrée pour la fonction
et remplacer également le séparateur 20 par un paramètre.

1. Remplacez la définition de sphereByZ par :

def sphereByZ(inputPt,radiusRatio)
{
//get Z Value, use it to drive radius of sphere
sphereRadius=inputPt.Z/radiusRatio;
//Define Sphere Geometry
sphere=[Link](inputPt,sphereRadius);
//Define output for function
return sphere;
};

1. Mettez à jour les blocs de code enfant en ajoutant une variable ratio à l'entrée : sphereByZ(Pt,ratio);. Connectez un curseur à la nouvelle
entrée du bloc de code et modifiez la taille des rayons en fonction du rapport des rayons.
Dynamo for Revit
Dynamo for Revit
Dynamo est un environnement flexible, conçu pour s'intégrer à un large éventail de programmes, mais il a été créé pour être utilisé avec Revit. Un
programme visuel crée des options robustes pour la modélisation des informations du bâtiment (BIM). Dynamo offre une suite complète de nœuds
spécifiquement conçus pour Revit, ainsi que des bibliothèques tierces issues d'une communauté AEC dynamique. Ce chapitre porte sur les notions de base
de l'utilisation de Dynamo dans Revit.
La connexion Revit
La connexion Revit

Dynamo for Revit étend la modélisation des données du bâtiment à l'environnement de données et de logique d'un éditeur d'algorithmes graphiques. Sa
flexibilité, associée à une base de données Revit robuste, offre une nouvelle perspective pour le BIM.

Ce chapitre se concentre sur les workflows Dynamo pour le BIM. Les coupes sont principalement basées sur des exercices, car le passage immédiat à un
projet est le meilleur moyen de se familiariser avec un éditeur d'algorithmes graphiques pour le BIM. Mais d'abord, voici les débuts du programme.

Compatibilité de la version de Revit

Comme Revit et Dynamo évoluent encore, il se peut que vous constatiez que la version de Revit sur laquelle vous travaillez n'est pas compatible avec la
version de Dynamo for Revit que vous avez installée sur votre ordinateur. Les versions de Dynamo for Revit compatibles avec Revit sont répertoriées ci-
dessous.

Version de Dernière version de Dynamo for Revit prise en

Première version stable de Dynamo
Revit charge
2013 0.6.1 0.6.3
2014 0.6.1 0.8.2
2015 0.7.1 1.2.1
2016 0.7.2 1.3.2
2017 0.9.0 1.3.4 / 2.0.3
2018 1.3.0 1.3.4 / 2.0.3
2019 1.3.3 1.3.4 / 2.0.3
2.1.0 - Revit 2020 inclut désormais Dynamo et reçoit les mises à jour comme
2020 N/A
Revit.

Historique de Dynamo
 Avec une équipe de développeurs dédiée et une communauté passionnée, le projet est loin de ses débuts timides.

Dynamo a été créé à l'origine pour rationaliser les workflows AEC dans Revit. Bien que Revit crée une base de données solide pour chaque projet, il peut
être difficile pour un utilisateur lambda d'accéder à ces informations en dehors des contraintes de l'interface. Revit héberge une API (Application Program
Interface) complète, permettant aux développeurs tiers de créer des outils personnalisés. Les programmeurs utilisent cette API depuis des années, mais les
scripts basés sur du texte ne sont pas accessibles à tous. Dynamo vise à démocratiser les données Revit via un éditeur d'algorithmes graphiques abordable.

En utilisant les principaux nœuds Dynamo conjointement avec des nœuds Revit personnalisés, un utilisateur peut considérablement étendre les workflows
paramétriques pour l'interopérabilité, la documentation, l'analyse et la génération. Avec Dynamo, les workflows fastidieux peuvent être automatisés tandis
que les explorations de conception peuvent se développer.

Exécution de Dynamo dans Revit

 1. Dans un projet Revit ou un éditeur de familles, accédez à Compléments et cliquez sur Dynamo. Remarque : Dynamo s'exécute uniquement
dans le fichier dans lequel il a été ouvert.

1. Lors de l'ouverture de Dynamo dans Revit, une nouvelle catégorie appelée Revit apparaît. Il s'agit d'un ajout complet à l'interface utilisateur qui
offre des nœuds spécifiquement conçus pour les workflows Revit.*

*Remarque : en utilisant la famille de nœuds propre à Revit, le graphique Dynamo fonctionne uniquement lorsqu'il est ouvert dans Dynamo for Revit. Si un
graphique Dynamo for Revit est ouvert dans Dynamo Sandbox par exemple, les nœuds Revit sont manquants.

Gel des nœuds

Revit étant une plate-forme qui fournit une gestion de projet robuste, les opérations paramétriques dans Dynamo peuvent être complexes et lentes à calculer.
Si Dynamo met du temps pour calculer des nœuds, vous pouvez utiliser la fonctionnalité "geler" du nœud pour interrompre l'exécution des opérations Revit
lorsque vous développez votre graphique. Pour plus d'informations sur le gel des nœuds, consultez la section "Gel" du chapitre Solides.

Communauté

Depuis que Dynamo a été créé pour le secteur AEC, sa vaste communauté dynamique est une excellente ressource pour apprendre et créer des liens avec des
experts du secteur. La communauté de Dynamo est constituée d'architectes, d'ingénieurs, de programmeurs et de concepteurs dont la passion commune est
de partager ce qu'ils font.

Dynamo est un projet open source en constante évolution et un grand nombre de développements sont liés à Revit. Si vous êtes nouveau, rendez-vous sur le
forum de discussion et posez des questions. Si vous êtes programmeur et que vous souhaitez vous impliquer dans le développement de Dynamo, consultez
la page github. En outre, le gestionnaire de packages Dynamo constitue une ressource très utile pour les bibliothèques tierces. Beaucoup de ces packages
sont conçus pour le secteur AEC. Dans ce chapitre, vous étudierez les packages tiers pour la panélisation.

Dynamo maintient également un blog actif. Lisez les articles récents pour en savoir plus sur les derniers développements.
Sélection
Sélection
Revit est un environnement riche en données. Cet environnement vous offre de nombreuses possibilités de sélection allant bien au-delà du "pointer-cliquer".
Vous pouvez interroger la base de données Revit et lier dynamiquement des éléments Revit à la géométrie Dynamo tout en effectuant des opérations
paramétriques.

La bibliothèque Revit de l'interface utilisateur propose une catégorie "Selection" qui permet d'explorer plusieurs méthodes de sélection de géométrie.

Pour sélectionner correctement des éléments Revit, il est important de bien comprendre la hiérarchie des éléments Revit. Vous souhaitez sélectionner tous
les murs d'un projet ? Effectuez une sélection par catégorie. Vous voulez sélectionner toutes les chaises Eames dans votre hall moderne du milieu du siècle ?
Effectuez une sélection par famille. Avant de passer à l'exercice, examinez rapidement la hiérarchie Revit.

Hiérarchie Revit
Vous vous souvenez de la taxinomie en biologie ? Règne, Embranchement, Classe, Ordre, Famille, Genre, Espèces ? Les éléments Revit sont classés de la
même manière. À la base, la hiérarchie Revit peut être divisée en catégories, familles, types* et instances. Une instance est un élément de modèle individuel
(avec un ID unique), tandis qu'une catégorie définit un groupe générique (tel que "murs" ou "sols"). La base de données Revit étant organisée de cette
manière, vous pouvez sélectionner un élément et choisir tous les éléments similaires en fonction d'un niveau spécifié dans la hiérarchie.

*Remarque : les types définis dans Revit diffèrent des types de programmation. Dans Revit, un type fait référence à une branche de la hiérarchie plutôt qu'à
un "type de données".

Navigation dans la base de données avec les nœuds Dynamo

Les trois images ci-dessous décrivent les principales catégories pour la sélection d'éléments Revit dans Dynamo. Ces outils sont très utiles en association.
Vous allez en découvrir certains dans les exercices suivants.

Pointer-cliquer est la méthode la plus simple pour sélectionner directement un élément Revit. Vous pouvez sélectionner un élément de modèle complet
ou des parties de sa topologie (une face ou une arête, par exemple). Il reste lié dynamiquement à cet objet Revit, de sorte que lorsque l'emplacement ou
les paramètres du fichier Revit sont mis à jour, l'élément Dynamo référencé est mis à jour dans le graphique.
 Les menus déroulants permettent de créer une liste de tous les éléments accessibles dans un projet Revit. Vous pouvez utiliser cette option pour
référencer des éléments Revit qui ne sont pas nécessairement visibles dans une vue. C'est un outil formidable pour rechercher des éléments existants ou
en créer d'autres dans un projet Revit ou l'Éditeur de familles.

Vous pouvez également sélectionner des éléments Revit en fonction de niveaux spécifiques dans la hiérarchie Revit. Cette option est puissante pour
personnaliser des réseaux de données volumineux en vue de la documentation ou de l'instanciation et de la personnalisation génératives.

Tout en gardant les trois images ci-dessus, vous allez étudier un exercice qui sélectionne les éléments d'un projet Revit de base en vue de les préparer aux
applications paramétriques créées dans les autres sections de ce chapitre.

Exercice

Téléchargez les fichiers d'exemple joints à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous
trouverez la liste complète des fichiers d'exemple dans l'annexe.
 1. [Link]
2. [Link]

Ce fichier d'exemple Revit contient trois types d'éléments d'un bâtiment simple. Utilisez ce fichier comme exemple pour sélectionner des éléments
Revit dans le contexte de la hiérarchie Revit :

1. Volume de bâtiment
2. Fermes (composants adaptatifs)
3. Poutres (ossature)

Quelles conclusions pouvez-vous tirer des éléments affichés actuellement dans la vue du projet Revit ? Jusqu'à quelle distance de la hiérarchie devez-
vous aller pour sélectionner les éléments appropriés ? Cette tâche est évidemment plus complexe lorsque vous travaillez sur un projet volumineux. De
nombreuses options sont disponibles : vous pouvez sélectionner des éléments par catégories, niveaux, familles, instances, etc.

1. Puisque vous travaillez avec une configuration de base, sélectionnez le volume du bâtiment en choisissant "Mass" dans le nœud déroulant
Categories. Vous le trouverez dans l'onglet Revit > Selection.
2. La sortie de la catégorie Mass est uniquement la catégorie elle-même. Vous devez sélectionner les éléments. Pour ce faire, utilisez le nœud "All
Elements of Category".

À ce stade, aucune géométrie n'est visible dans Dynamo. Un élément Revit a été sélectionné, mais il n'a pas encore été converti en géométrie Dynamo. Il
s'agit d'une distinction importante. Si vous sélectionnez un grand nombre d'éléments, vous ne souhaitez pas afficher un aperçu de tous ces éléments dans
Dynamo, sous peine de ralentir le programme. Dynamo est un outil permettant de gérer un projet Revit sans avoir à effectuer des opérations de géométrie.
Vous allez le découvrir dans la section suivante de ce chapitre.
Dans ce cas, vous travaillez avec une géométrie simple. Vous devez donc importer la géométrie dans l'aperçu Dynamo. Le nœud Watch ci-dessus affiche un
numéro vert* en regard de l'élément "BldgMass". Il représente l'ID de l'élément et vous indique que vous travaillez avec un élément Revit et non avec une
géométrie Dynamo. L'étape suivante consiste à convertir cet élément Revit en géométrie dans Dynamo.

1. Le nœud Element. Faces vous permet d'obtenir une liste de surfaces représentant chaque face du volume Revit. Vous pouvez désormais voir la
géométrie dans la fenêtre Dynamo et commencer à référencer la face pour les opérations paramétriques.

Voici une autre méthode : dans ce cas, vous ne pouvez pas effectuer de sélection via la hiérarchie Revit ("All Elements of Category") et choisissez de
sélectionner explicitement la géométrie dans Revit.

1. Utilisez le nœud "Select Model Element", et cliquez sur le bouton "Select" (ou "Change"). Dans la fenêtre Revit, sélectionnez l'élément
souhaité. Dans ce cas, l'élément sélectionné est le volume du bâtiment.
2. Au lieu d'utiliser le nœud [Link], vous pouvez sélectionner le volume complet comme géométrie solide à l'aide du nœud
[Link]. Cette opération permet de sélectionner toute la géométrie contenue dans ce volume.
3. Le nœud [Link] vous permet de récupérer la liste des surfaces. Ces deux nœuds fonctionnent de la même manière que
[Link], mais offrent d'autres options permettant d'explorer la géométrie d'un élément Revit.
1. Certaines des opérations de liste de base vous permettent d'interroger la face qui vous intéresse.
2. Tout d'abord, le nœud [Link] indique que vous travaillez avec 23 surfaces du volume.
3. En faisant référence à ce nombre, définissez la valeur maximale d'un curseur de type entier sur "22".
4. À l'aide de [Link], entrez les listes et le curseur d'entier pour l'index. Faites glisser le curseur avec la sélection et arrêtez lorsque
vous atteignez l'index 9 et que vous avez isolé la façade principale qui héberge les fermes.

1. L'étape précédente était un peu compliquée. Grâce au nœud "Select Face", cette opération est beaucoup plus rapide. Cela vous permet d'isoler
une face qui n'est pas un élément en soi dans le projet Revit. La même interaction s'applique à "Select Model Element", sauf que vous
sélectionnez la surface plutôt que l'élément entier.
Imaginez que vous souhaitiez isoler les murs de la façade principale du bâtiment. Pour ce faire, vous pouvez utiliser le nœud "Select Faces". Cliquez
sur le bouton "Select", puis sélectionnez les quatre façades principales dans Revit.

1. Après avoir sélectionné les quatre murs, assurez-vous que vous cliquez sur le bouton "Terminer" dans Revit.
1. Les faces sont désormais importées dans Dynamo en tant que surfaces.

1. Examinez désormais les poutres sur l'atrium. À l'aide du nœud "Select Model Element", sélectionnez l'une des poutres.
2. Connectez l'élément poutre au nœud [Link]. La poutre apparaît dans la fenêtre Dynamo.
3. Vous pouvez effectuer un zoom avant sur la géométrie à l'aide d'un nœud Watch3D (si vous ne voyez pas la poutre dans Watch 3D, cliquez
avec le bouton droit de la souris et sélectionnez "Zoom tout").
 Question fréquente pendant les workflows Revit/Dynamo : comment sélectionner un élément et obtenir tous les éléments similaires ? Étant donné que
l'élément Revit sélectionné contient toutes ses informations hiérarchiques, vous pouvez interroger son type de famille et sélectionner tous les éléments
de ce type.

1. Connectez l'élément poutre à un nœud [Link]*.

2. Le nœud Watch indique que la sortie est désormais un symbole de famille plutôt qu'un élément Revit.
3. Étant donné que [Link] est une simple requête, vous pouvez le faire dans le bloc de code aussi facilement avec [Link];
et obtenir les mêmes résultats.

*Remarque : un symbole de famille est la terminologie de l'API de Revit pour le type de famille. Comme cela peut entraîner une certaine confusion, il sera
mis à jour dans les versions à venir.

1. Pour sélectionner les autres poutres, utilisez le nœud "All Elements of Family Type".
2. Le nœud Watch indique que cinq éléments Revit ont été sélectionnés.
 1. Vous pouvez également convertir ces cinq éléments en géométrie Dynamo.

Et si vous aviez 500 poutres ? La conversion de tous ces éléments en géométrie Dynamo serait très lente. Si Dynamo prend du temps pour calculer des
nœuds, vous pouvez utiliser la fonctionnalité de nœud "geler" pour interrompre l'exécution des opérations Revit lorsque vous développez votre graphique.
Pour plus d'informations sur le gel des nœuds, consultez la section "Gel" du chapitre Solides.

Dans tous les cas, si vous importiez 500 poutres, auriez-vous besoin de toutes les surfaces pour effectuer l'opération paramétrique souhaitée ? Ou pouvez-
vous extraire les informations de base des poutres et effectuer des tâches génératives avec une géométrie fondamentale ? Gardez cette question à l'esprit à
mesure que vous avancez dans ce chapitre. Prenez l'exemple du système de ferme :

À l'aide du même graphique de nœuds, sélectionnez l'élément ferme plutôt que l'élément poutre. Avant de procéder ainsi, supprimez [Link]
de l'étape précédente.
 1. Le nœud Watch contient une liste de composants adaptatifs sélectionnés dans Revit. Étant donné que vous voulez extraire les informations de
base, commencez par les points adaptatifs.
2. Connectez le nœud "All Elements of Family Type" au nœud "[Link]". Vous obtenez une liste de listes, chacune avec
trois points qui représentent les emplacements des points adaptatifs.
3. La connexion d'un nœud "[Link]" renvoie une polycourbe. Celle-ci apparaît dans la fenêtre Dynamo. Cette méthode vous a permis
de visualiser la géométrie d'un élément et de supprimer la géométrie du réseau d'éléments restants (qui peut être plus grand en nombre que
dans cet exemple).

*Conseil : si vous cliquez sur le numéro vert d'un élément Revit dans Dynamo, la fenêtre Revit effectue un zoom sur cet élément.
Modification
Édition
Une puissante fonction de Dynamo est la possibilité de modifier les paramètres d'un niveau paramétrique. Par exemple, un algorithme génératif ou les
résultats d'une simulation peuvent être utilisés pour piloter les paramètres d'un réseau d'éléments. Ainsi, un jeu d'occurrences de la même famille peut
posséder des propriétés personnalisées dans votre projet Revit.

Paramètres de type et d'occurrence

1. Les paramètres d'occurence définissent l'ouverture des panneaux sur la surface du toit, allant d'un rapport d'ouverture de 0,1 à 0,4.
2. Les paramètres basés sur le type sont appliqués à chaque élément de la surface, car ils appartiennent au même type de famille. Le matériau de
chaque panneau, par exemple, peut être piloté par un paramètre basé sur le type.

1. Si vous avez déjà configuré une famille Revit, n'oubliez pas d'affecter un type de paramètre (chaîne, nombre, cote, etc.) Veillez à utiliser le
 type de données correct lors de l'affectation de paramètres à partir de Dynamo.
2. Vous pouvez également utiliser Dynamo en combinaison avec les contraintes paramétriques définies dans les propriétés d'une famille Revit.

Pour rappel, Revit comprend des paramètres de type et des paramètres d'occurrence. Les deux peuvent être modifiés à partir de Dynamo, mais vous allez
utiliser les paramètres d'occurrence dans l'exercice ci-dessous.

Remarque : lorsque vous découvrez l'application complète de paramètres de modification, vous pouvez modifier un grand nombre d'éléments dans Revit
avec Dynamo. Il peut s'agir d'une opération coûteuse en ressources informatiques, ce qui signifie qu'elle peut être lente. Si vous modifiez un grand nombre
d'éléments, vous pouvez utiliser la fonctionnalité de nœud "Geler" pour interrompre l'exécution des opérations Revit lorsque vous développez votre
graphique. Pour plus d'informations sur le gel des nœuds, consultez la section "Gel" du chapitre Solides.

Unités

À partir de la version 0.8, Dynamo est fondamentalement sans unité. Dynamo reste ainsi un environnement de programmation visuel abstrait. Les nœuds
Dynamo qui interagissent avec les cotes Revit font référence aux unités du projet Revit. Par exemple, si vous définissez un paramètre de longueur dans
Revit à partir de Dynamo, le numéro de la valeur dans Dynamo correspondra aux unités par défaut dans le projet Revit. L'exercice ci-dessous utilise les
mètres.

Pour une conversion rapide des unités, utilisez le nœud "Convert Between Units". Cet outil est pratique pour convertir des unités de longueur, de
surface et de volume à la volée.

Exercice

Téléchargez les fichiers d'exemple joints à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous
trouverez la liste complète des fichiers d'exemple dans l'annexe.

1. [Link]
2. [Link]

Cet exercice est consacré à la modification d'éléments Revit sans effectuer d'opération géométrique dans Dynamo. Vous n'importez pas la géométrie
Dynamo ici, mais modifiez simplement les paramètres dans un projet Revit. Il s'agit d'un exercice de base et pour les utilisateurs de Revit les plus avancés,
notez qu'il s'agit de paramètres d'occurrence d'un volume, mais la même logique peut être appliquée à un réseau d'éléments à personnaliser à grande échelle.
Cette opération est effectuée à l'aide du nœud "[Link]".
Commencez par utiliser l'exemple de fichier Revit pour cette section. Les éléments structurels et les fermes adaptatives de la section précédente ont été
supprimés. Dans cet exercice, vous allez travailler sur une ossature paramétrique dans Revit et la manipuler dans Dynamo.

1. Lorsque vous sélectionnez le bâtiment dans Volume dans Revit, un réseau de paramètres d'occurrence s'affiche dans le groupe de fonctions
Propriétés.

1. Sélectionnez le volume du bâtiment à l'aide du nœud "Select Model Element".

2. Vous pouvez rechercher tous les paramètres de ce volume à l'aide du nœud "[Link]". Cela inclut les paramètres de type et
d'occurrence.
1. Référencez le nœud [Link] pour rechercher les paramètres cibles. Vous pouvez également afficher le groupe de fonctions
Propriétés de l'étape précédente pour choisir les noms de paramètres à modifier. Dans ce cas, vous recherchez les paramètres qui ont une
incidence sur les grands déplacements géométriques sur le volume du bâtiment.
2. Modifiez l'élément Revit à l'aide du nœud [Link].
3. À l'aide du bloc de code, définissez une liste de ces paramètres, avec des guillemets autour de chaque élément pour indiquer une chaîne. Vous
pouvez également utiliser le nœud [Link] avec une série de nœuds "String" connectés à plusieurs entrées. Le bloc de code est simplement
plus rapide et plus simple. Assurez-vous que la chaîne correspond au nom exact dans Revit, en faisant attention à la casse :
{"BldgWidth","BldgLength","BldgHeight", "AtriumOffset", "InsideOffset","LiftUp"};

1. Vous devez également désigner des valeurs pour chaque paramètre. Ajoutez six curseurs d'entier à la zone de dessin et renommez-les en
fonction du paramètre correspondant dans la liste. Définissez également les valeurs de chaque curseur tel qu'illustré ci-dessus. Dans l'ordre de
haut en bas : 62,92,25,22,8,12
2. Définissez un autre bloc de code avec une liste de la même longueur que les noms des paramètres. Dans ce cas, nommez les variables (sans
guillemets) qui créent des entrées pour le bloc de code. Connectez les curseurs à chaque entrée respective : {bw,bl,bh,ao,io,lu};
 3. Connectez le bloc de code au nœud "[Link]"*. Lorsque l'option Exécuter automatiquement est activée, les résultats
sont automatiquement affichés.

*Remarque : cette démonstration fonctionne avec les paramètres d'occurrence, mais pas avec les paramètres de type.

Tout comme dans Revit, la plupart de ces paramètres sont dépendants l'un de l'autre. Il existe bien entendu des combinaisons dans lesquelles la géométrie
peut être rompue. Vous pouvez résoudre ce problème avec des formules définies dans les propriétés des paramètres, ou bien configurer une logique
similaire avec des opérations mathématiques dans Dynamo (ce défi supplémentaire est nécessaire si vous souhaitez développer l'exercice).

1. Cette combinaison donne une super nouvelle conception au volume du bâtiment : 100,92,100,25,13,51.4

1. Copiez le graphique et concentrez-vous sur le vitrage de la façade qui va abriter le système de ferme. Dans ce cas, isolez quatre paramètres :
{"DblSkin_SouthOffset","DblSkin_MidOffset","DblSkin_NorthOffset","Facade Bend Location"};
2. De plus, créez des curseurs de numérotation et renommez-les en fonction des paramètres appropriés. Les trois premiers curseurs, de haut en
bas, doivent être remappés avec un domaine de [0,10], tandis que le curseur final, "Facade Bend Location", doit être remappé avec un domaine
 de [0,1]. Ces valeurs, de haut en bas, doivent commencer par les valeurs suivantes (bien qu'elles soient arbitraires) : 2.68,2.64,2.29,0.5
3. Définissez un nouveau bloc de code et connectez les curseurs : {so,mo,no,fbl};

1. En modifiant les curseurs dans cette partie du graphique, vous pouvez rendre le vitrage de la façade beaucoup plus important :
9.98,10.0,9.71,0.31
Création
Création
Vous pouvez créer un réseau d'éléments Revit dans Dynamo avec un contrôle paramétrique complet. Les nœuds Revit dans Dynamo permettent d'importer
des éléments à partir de géométries génériques vers des types de catégorie spécifiques (tels que des murs et des sols). Dans cette section, nous allons nous
concentrer sur l'importation d'éléments paramétriquement flexibles avec des composants adaptatifs.

Composants adaptatifs

Un composant adaptatif est une catégorie de famille flexible qui se prête bien aux applications génératives. Lors de l'instanciation, vous pouvez créer un
élément géométrique complexe qui est contrôlé par l'emplacement fondamental des points adaptatifs.

Exemple de composant adaptatif à trois points dans l'Éditeur de familles. Cela génère une ferme définie par la position de chaque point adaptatif. Dans
l'exercice ci-dessous, vous allez utiliser ce composant pour générer une série de fermes sur une façade.

Principes d'interopérabilité
Le composant adaptatif est un bon exemple des meilleures pratiques d'interopérabilité. Vous pouvez créer un réseau de composants adaptatifs en définissant
les points adaptatifs fondamentaux. Lors du transfert de ces données vers d'autres programmes, vous pouvez réduire la géométrie en données simples.
L'importation et l'exportation avec un programme tel qu'Excel suivent une logique similaire.

Supposez qu'un consultant en façade souhaite connaître l'emplacement des éléments de ferme sans avoir à les analyser par le biais d'une géométrie
entièrement articulée. Afin de se préparer à la fabrication, le consultant peut faire référence à l'emplacement des points adaptatifs pour régénérer la
géométrie dans un programme tel qu'Inventor.

Le workflow que vous allez configurer dans l'exercice ci-dessous vous permet d'accéder à toutes ces données lors de la création de la définition pour la
création d'éléments Revit. Grâce à ce processus, vous pouvez fusionner la conceptualisation, la documentation et la fabrication dans un workflow
homogène. Cela permet de créer un processus plus intelligent et efficace pour l'interopérabilité.

Éléments et listes multiples

L'exercice ci-dessous vous expliquera comment Dynamo référence les données pour la création d'éléments Revit. Pour générer plusieurs composants
adaptatifs, définissez une liste de listes dans laquelle chaque liste comporte trois points représentant chaque point du composant adaptatif. Gardez cela à
l'esprit lorsque vous gérez les structures de données dans Dynamo.

Exercice

Téléchargez les fichiers d'exemple joints à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous
trouverez la liste complète des fichiers d'exemple dans l'annexe.

1. [Link]
2. [Link]

À partir du fichier d'exemple de cette section (ou en continuant avec le fichier Revit de la session précédente), vous obtenez le même volume Revit.

1. Il s'agit du fichier ouvert.

2. Il s'agit du système de ferme créé avec Dynamo et relié intelligemment au volume Revit.
 Après avoir utilisé les nœuds "Select Model Element" et "Select Face", vous allez maintenant avancer plus loin dans la hiérarchie de la géométrie et
utiliser Select Edge. Lorsque le solveur Dynamo est défini pour exécuter la commande Automatic, le graphique est constamment mis à jour en fonction
des modifications apportées au fichier Revit. L'arête sélectionné est liée dynamiquement à la topologie des éléments Revit. Tant que la topologie* ne
change pas, la connexion reste liée entre Revit et Dynamo.

1. Sélectionnez la courbe la plus haute de la façade du vitrage. Elle s'étend sur toute la longueur du bâtiment. Si vous ne parvenez pas à
sélectionner l'arête, n'oubliez pas de choisir la sélection dans Revit en plaçant le curseur sur l'arête et en appuyant sur la touche "Tabulation"
jusqu'à ce que l'arête souhaitée soit mise en surbrillance.
2. À l'aide de deux nœuds "Select Edge", sélectionnez chaque arête représentant le dévers de rail au milieu de la façade.
3. Procédez de la même manière pour les arêtes inférieures de la façade dans Revit.
4. Les nœuds Watch indiquent que vous avez désormais des lignes dans Dynamo. Cette opération est automatiquement convertie en géométrie
Dynamo, car les arêtes elles-mêmes ne sont pas des éléments Revit. Ces courbes sont les références que vous allez utiliser pour instancier des
fermes adaptatives sur la façade.

*Remarque : pour conserver une topologie homogène, faites référence à un modèle auquel aucune face ou arête supplémentaire n'a été ajoutée. Bien que
les paramètres puissent en modifier la forme, la façon dont il est créé reste cohérente.
Vous devez d'abord joindre les courbes et les fusionner en une liste. De cette manière, vous pouvez "regrouper" les courbes pour effectuer des
opérations de géométrie.

1. Créez une liste pour les deux courbes au centre de la façade.

2. Joignez les deux courbes dans une polycourbe en connectant le composant [Link] à un nœud [Link].
3. Créez une liste pour les deux courbes au bas de la façade.
4. Joignez les deux courbes dans une polycourbe en connectant le composant [Link] à un nœud [Link].
5. Enfin, joignez les trois courbes principales (une ligne et deux polycourbes) dans une liste.

Vous voulez tirer parti de la courbe supérieure, qui est une ligne, et représente la portée complète de la façade. Pour ce faire, créez des plans le long de
cette ligne pour couper le jeu de courbes regroupées dans une liste.

1. Avec un bloc de code, définissez un intervalle en utilisant la syntaxe : 0..1..#numberOfTrusses;

2. Connectez un curseur d'entier à l'entrée du bloc de code. Vous l'aurez deviné, cette valeur représente le nombre de fermes. Le curseur contrôle
 le nombre d'éléments dans l'intervalle défini de 0 à 1.
3. Connectez le bloc de code à l'entrée param d'un nœud "[Link]" et connectez l'arête supérieure à l'entrée curve. Vous
obtiendrez ainsi dix plans, répartis uniformément sur l'ensemble de la façade.

Un plan est un élément abstrait de la géométrie, représentant un espace 2D infini. Les plans sont idéaux pour le contour et l'intersection, à mesure que
vous effectuez la configuration dans cette étape.

1. À l'aide du nœud [Link] (notez la liaison Produit cartésien), connectez le nœud [Link] à l'entrée entity du nœud
[Link]. Connectez le nœud principal [Link] à l'entrée geometry. Les points sont maintenant affichés dans la fenêtre Dynamo.
Ils représentent l'intersection de chaque courbe avec les plans définis.

Le résultat est une liste de listes. Trop de listes par rapport à vos besoins. Il convient ici d'effectuer un aplatissement partiel. Vous devez descendre d'un
niveau dans la liste et aplanir le résultat. Pour ce faire, utilisez l'opération [Link], comme indiqué dans le chapitre relatif aux listes du guide.
 1. Connectez le nœud [Link] à l'entrée de liste de [Link].
2. Connectez un nœud Flatten à l'entrée f(x) de [Link]. Les résultats donnent 3 listes, chacune contenant un nombre égal au nombre de fermes.
3. Vous devez modifier ces données. Si vous souhaitez instancier la ferme, utilisez le même nombre de points adaptatifs que celui défini dans la
famille. Il s'agit d'un composant adaptatif à trois points. Par conséquent, au lieu de trois listes contenant 10 éléments chacune
(numberOfTrusses), vous souhaitez obtenir 10 listes contenant trois éléments chacune. De cette manière, vous pouvez créer 10 composants
adaptatifs.
4. Connectez le fichier [Link] à un nœud [Link]. Vous disposez à présent de la sortie de données souhaitée.
5. Pour confirmer que les données sont correctes, ajoutez un nœud [Link] dans la zone de dessin et vérifiez deux fois l'aperçu
Dynamo.

Mettez en réseau les composants adaptatifs de la même façon que vous avez créé les polygones.

1. Ajoutez un nœud [Link] à la zone de dessin et connectez le nœud [Link] à l'entrée points.
2. À l'aide d'un nœud Family Types, sélectionnez la famille "AdaptiveTruss" et connectez-la à l'entrée familySymbol du nœud
[Link].
Dans Revit, les dix fermes sont à présent espacées régulièrement sur la façade.

1. En ajustant le graphique, augmentez la valeur de numberOfTrusses de 40 en déplaçant le curseur. Beaucoup de fermes, peu réalistes, mais le
lien paramétrique fonctionne.
 1. En utilisant le système de ferme, trouvez un compromis avec une valeur de 15 pour numberOfTrusses.

Pour le dernier test, en sélectionnant le volume dans Revit et en modifiant les paramètres d'occurrence, vous pouvez modifier la forme du bâtiment et
observer la ferme. Souvenez-vous que ce graphique Dynamo doit être ouvert pour que cette mise à jour s'affiche, et que le lien sera supprimé dès sa
fermeture.

Éléments DirectShape
Une autre méthode d'importation de géométrie Dynamo paramétrique dans Revit consiste à utiliser DirectShape. En résumé, l'élément DirectShape et les
classes associées permettent de stocker des formes géométriques créées en externe dans un document Revit. La géométrie peut inclure des solides ou des
maillages fermés. DirectShape sert principalement à importer des formes à partir d'autres formats de données, tels que IFC ou STEP, où il n'y a pas assez
d'informations pour créer un élément Revit "réel". Comme les workflows IFC et STEP, la fonctionnalité DirectShape fonctionne bien avec l'importation de
géométries créées dans des projets Revit en tant qu'éléments réels.
Vous allez examiner et réaliser des exercices dans le but d'importer une géométrie Dynamo en tant que forme directe dans votre projet Revit. Cette méthode
permet d'affecter une catégorie, un matériau et un nom de géométrie importée, tout en maintenant un lien paramétrique vers le graphique Dynamo.

Exercice
Téléchargez les fichiers d'exemple joints à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous
trouverez la liste complète des fichiers d'exemple dans l'annexe.

1. [Link]
2. [Link]
Ouvrez tout d'abord le fichier d'exemple de cette leçon : [Link].

1. Dans la vue 3D, vous pouvez voir le volume de votre bâtiment de la leçon précédente.
2. Le long de l'arête de l'atrium se trouve une courbe de référence, que vous allez utiliser comme courbe à référencer dans Dynamo.
3. Le long de l'arête opposée de l'atrium se trouve une autre courbe de référence que vous allez également référencer dans Dynamo.

1. Pour référencer la géométrie dans Dynamo, utilisez Select Model Element pour chaque membre dans Revit. Sélectionnez le volume dans Revit
et importez la géométrie dans Dynamo à l'aide de [Link]. Le volume doit maintenant être visible dans l'aperçu Dynamo.
2. Importez une courbe de référence dans Dynamo à l'aide de Select Model Element et [Link].
3. Importez l'autre courbe de référence dans Dynamo à l'aide de Select Model Element et [Link].
 1. En zoomant et en vous déplaçant vers la droite dans l'exemple de graphique, vous apercevez un grand groupe de nœuds : il s'agit d'opérations
géométriques qui génèrent la structure de toiture de treille visible dans l'aperçu Dynamo. Ces nœuds sont générés à l'aide de la fonctionnalité
Nœud vers code, comme décrit dans la section de bloc de code du guide.
2. La structure est contrôlée par trois paramètres principaux : Décalage diagonale, Contre-flèche et Rayon.

Effectuez un zoom avant sur les paramètres de ce graphique. Vous pouvez les ajuster pour obtenir différentes sorties de géométrie.
 1. Lorsque vous déposez le nœud [Link] sur la zone de dessin, vous voyez qu'il comporte quatre entrées : geometry,
category, material et name.
2. La géométrie sera le solide créé à partir de la partie de création de géométrie du graphique
3. L'entrée de catégorie est sélectionnée à l'aide du nœud déroulant Categories. Dans ce cas, vous allez utiliser "Ossature".
4. Vous pouvez sélectionner l'entrée de matériau via le réseau de nœuds ci-dessus, bien qu'il puisse être plus simplement défini comme "Par
défaut" dans ce cas.

Après avoir exécuté Dynamo, vous avez la géométrie importée sur le toit dans votre projet dans Revit. Il s'agit d'un élément d'ossature, et non d'un
modèle générique. Le lien paramétrique vers Dynamo reste intact.
Personnalisation
Personnalisation
Bien que vous ayez précédemment étudié la modification d'un volume de construction de base, vous devez approfondir le lien Dynamo/Revit en modifiant
un grand nombre d'éléments en une seule opération. La personnalisation à grande échelle devient plus complexe, car les structures de données nécessitent
des opérations de listes plus avancées. Toutefois, les principes sous-jacents de leur exécution sont fondamentalement les mêmes. Examinez certaines
possibilités d'effectuer des analyses à partir d'un ensemble de composants adaptatifs.

Emplacement du point

Imaginez que vous avez créé une série de composants adaptatifs et que vous souhaitez modifier les paramètres en fonction de leurs emplacements de point.
Les points, par exemple, peuvent définir un paramètre d'épaisseur lié à la zone de l'élément. Ils peuvent aussi définir un paramètre d'opacité lié à l'exposition
solaire tout au long de l'année. Dynamo permet la connexion de l'analyse aux paramètres en quelques étapes simples. Dans l'exercice ci-dessous, vous allez
explorer une version de base.

Interrogez les points adaptatifs d'un composant adaptatif sélectionné à l'aide du nœud [Link]. Cela vous permet de travailler
avec une version abstraite d'un élément Revit pour l'analyse.

En extrayant l'emplacement des points des composants adaptatifs, vous pouvez exécuter une série d'analyses pour cet élément. Par exemple, un composant
adaptatif à quatre points vous permet d'étudier l'écart par rapport au plan d'un panneau donné.

Analyse de l'orientation du soleil

 Utilisez la fonction de remappage pour mapper un jeu de données dans une plage de paramètres. Il s'agit d'un outil fondamental utilisé dans un modèle
paramétrique, que vous allez découvrir dans l'exercice ci-dessous.

Avec Dynamo, vous pouvez utiliser les emplacements des points des composants adaptatifs pour créer un plan d'ajustement optimal pour chaque élément.
Vous pouvez également interroger la position du soleil dans le fichier Revit et étudier l'orientation relative du plan par rapport au soleil en comparaison avec
les autres composants adaptatifs. Étudiez ce cas dans l'exercice ci-dessous en créant un environnement de toiture algorithmique.

Exercice
Téléchargez les fichiers d'exemple joints à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous
trouverez la liste complète des fichiers d'exemple dans l'annexe.

1. [Link]
2. [Link]

Cet exercice fournit des informations sur les techniques présentées dans la section précédente. Dans ce cas, définissez une surface paramétrique à partir
d'éléments Revit, instanciant des composants adaptatifs à quatre points, puis modifiez-les en fonction de l'orientation par rapport au soleil.
 1. Sélectionnez d'abord deux arêtes avec le nœud "Select Edge". Les deux arêtes sont les longues travées de l'atrium.
2. Combinez les deux arêtes dans une liste avec le nœud [Link].
3. Créez une surface entre les deux arêtes avec un nœud [Link].

1. À l'aide du bloc de code, définissez une plage comprise entre 0 et 1 avec 10 valeurs équidistantes : 0..1..#10;
2. Connectez le bloc de code aux entrées u et v d'un nœud [Link], puis connectez le nœud [Link] à l'entrée surface.
Cliquez avec le bouton droit de la souris sur le nœud et définissez la liaison sur Produit cartésien. Cette action permet de créer une grille de
points sur la surface.

Cette grille de points sert de points de contrôle pour une surface définie de manière paramétrique. Vous devez extraire les positions u et v de chacun de ces
points afin de pouvoir les relier à une formule paramétrique et conserver la même structure de données. Pour ce faire, vous pouvez interroger les
emplacements des paramètres des points que vous venez de créer.

1. Ajoutez un nœud [Link] à la zone de dessin et connectez les entrées comme indiqué ci-dessus.
2. Interrogez les valeurs u de ces paramètres avec le nœud UV.U.
3. Interrogez les valeurs v de ces paramètres avec le nœud UV.V.
4. Les sorties montrent les valeurs u et v correspondantes pour chaque point de la surface. Vous disposez à présent d'une plage de 0 à 1 pour
chaque valeur dans la structure de données appropriée. Vous êtes prêts à appliquer un algorithme paramétrique.

1. Ajoutez un bloc de code dans la zone de dessin et entrez le code : [Link](u*180)*[Link](v*180)*w;. Il s'agit d'une fonction
paramétrique qui crée un sinus à partir d'une surface plane.
2. L'entrée u se connecte à UV.U.
3. L'entrée v se connecte à UV.V.
4. Étant donné que l'entrée w représente l'amplitude de la forme, joignez-y un curseur de numérotation.

1. La liste des valeurs définies par l'algorithme est maintenant disponible. Utilisez cette liste de valeurs pour déplacer les points vers le haut dans
la direction +Z. À l'aide de [Link], connectez le bloc de code à zTranslation et le nœud [Link] à l'entrée
geometry. Les nouveaux points doivent s'afficher dans l'aperçu Dynamo.
 2. Enfin, créez une surface avec le nœud [Link] en connectant le nœud de l'étape précédente à l'entrée des points. Vous obtenez
une surface paramétrique. N'hésitez pas à déplacer le curseur pour observer la taille du monticule diminuer ou augmenter.

En ce qui concerne la surface paramétrique, vous devez définir un moyen de la paneliser afin de mettre en réseau les composants adaptatifs à quatre points.
Étant donné que Dynamo ne dispose pas de fonctionnalités prêtes à l'emploi pour la panelisation des surfaces, contactez la communauté pour des packages
Dynamo utiles.

1. Accédez à Packages > Rechercher un package...

2. Recherchez "LunchBox" et téléchargez "LunchBox for Dynamo". Il s'agit d'un ensemble d'outils très utiles pour les opérations de géométrie
telles que celle-ci.

1. Après le téléchargement, vous disposez maintenant d'un accès complet à la suite LunchBox. Recherchez "Quad Grid" et sélectionnez
"LunchBox Quad Grid By Face". Connectez la surface paramétrique à l'entrée surface et définissez les divisions U et V sur 15. Vous devriez
voir apparaître une surface à quatre panneaux dans l'aperçu Dynamo.
Si vous souhaitez en savoir plus sur la configuration, cliquez deux fois sur le nœud Lunch Box pour voir comment il est créé.

Dans Revit, examinez rapidement le composant adaptatif utilisé ici. Pas besoin de suivre, mais c'est le panneau de toit à instancier. Il s'agit d'un
composant adaptatif à quatre points, qui est une représentation grossière d'un système ETFE. L'ouverture du vide au centre se trouve sur un paramètre
appelé "ApertureRatio".
 1. Étant donné que vous allez instancier un grand nombre de géométries dans Revit, veillez à définir le solveur Dynamo sur Manuel.
2. Ajoutez un nœud Family Types à la zone de dessin et sélectionnez "ROOF-PANEL-4PT".
3. Ajoutez un nœud [Link] à la zone de dessin, connectez les points Panel Pts de la sortie "LunchBox Quad Grid by
Face" à l'entrée points. Connectez le nœud Family Types à l'entrée FamilySymbol.
4. Cliquez sur Exécuter. La création de la géométrie nécessite un peu de temps sur Revit. Si l'opération est trop longue, réduisez la valeur du bloc
de code qui est égale à 15. Cela permet de réduire le nombre de panneaux sur le toit.

Remarque : si Dynamo prend trop de temps pour calculer les nœuds, vous pouvez utiliser la fonctionnalité "geler" du nœud pour interrompre l'exécution
des opérations Revit lorsque vous développez votre graphique. Pour plus d'informations sur le gel des nœuds, consultez la section "Gel" du chapitre
Solides.

Dans Revit, vous avez le réseau de panneaux sur le toit.

 En zoomant, vous pouvez mieux observer leurs qualités de surface.

Analyse

1. À partir de l'étape précédente, reprenez l'ouverture de chaque panneau en fonction de son exposition au soleil. Dans Revit, en zoomant et en
sélectionnant un panneau, vous pouvez constater la présence d'un paramètre appelé "Aperture Ratio" dans la barre des propriétés. La famille
est configurée de façon à ce que l'ouverture s'étende, approximativement, de 0,05 à 0,45.
1. Si vous activez la trajectoire d'ensoleillement, vous pouvez voir l'emplacement actuel du soleil dans Revit.

1. Vous pouvez référencer l'emplacement du soleil à l'aide du nœud [Link].

2. Connectez l'entrée SunSettings à [Link] pour obtenir le vecteur solaire.
3. À partir des points Panel Pts utilisés pour créer les composants adaptatifs, ayez recours à [Link] pour obtenir une
approximation du plan du composant.
4. Interrogez la normale de ce plan.
5. Utilisez le produit scalaire pour calculer l'orientation du soleil. Le produit scalaire est une formule qui détermine la mesure selon laquelle deux
vecteurs sont parallèles ou antiparallèles. Prenez donc la normale du plan de chaque composant adaptatif et comparez-la au vecteur solaire
pour simuler l'orientation du soleil de façon approximative.
6. Prenez la valeur absolue du résultat. Cela permet de garantir que le produit scalaire est précis si la normale du plan est orientée vers l'arrière.
7. Cliquez sur Exécuter.
1. Le produit scalaire contient une grande quantité de nombres. Pour utiliser leur distribution relative, vous devez condenser les nombres dans la
plage appropriée du paramètre "Aperture Ratio" à modifier.
2. L'outil [Link] est idéal pour cela. Il prend une liste d'entrée et remappe ses limites en deux valeurs cibles.
3. Définissez les valeurs cibles sur 0,15 et 0,45 dans un bloc de code.
4. Cliquez sur Exécuter.

1. Connectez les valeurs remappées à un nœud [Link].

2. Connectez la chaîne "Aperture Ratio" à l'entrée parameterName.
3. Connectez les composants adaptatifs à l'entrée element.
4. Cliquez sur Exécuter.
Dans Revit, à partir d'une distance, vous pouvez définir l'impact de l'orientation du soleil sur l'ouverture des panneaux ETFE.

En zoomant, vous pouvez voir que plus les panneaux ETFE font face au soleil et plus ils sont fermés. L'objectif ici est de réduire la surchauffe de
l'exposition au soleil. Si vous voulez laisser davantage de lumière en fonction de l'exposition solaire, vous devez simplement définir le domaine sur
[Link].
Documentation
Documentation
La modification des paramètres de la documentation suit les leçons apprises dans les sections précédentes. Dans cette section, vous allez découvrir les
paramètres de modification qui n'affectent pas les propriétés géométriques d'un élément, mais qui permettent de préparer un fichier Revit pour la
documentation.

Écart

Dans l'exercice ci-dessous, vous allez utiliser un écart de base par rapport au nœud Plane pour créer une feuille Revit pour la documentation. Chaque
panneau de la structure de toit définie de façon paramétrique possède une valeur d'écart différente. L'objectif est de définir l'intervalle de valeurs à l'aide de
couleurs et en planifiant les points adaptatifs à transmettre à un consultant, un ingénieur ou un entrepreneur responsable de la façade.

L'écart par rapport au nœud Plane permet de calculer la distance à laquelle l'ensemble de quatre points varie par rapport au plan ajusté au mieux entre
eux. Il s'agit d'une méthode simple et rapide pour étudier la constructibilité.

Exercice
Téléchargez les fichiers d'exemple joints à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous
trouverez la liste complète des fichiers d'exemple dans l'annexe.

1. [Link]
2. [Link]

Commencez par utiliser le fichier Revit pour cette section (ou continuez à partir de la section précédente). Ce fichier contient un réseau de panneaux ETFE
sur le toit. Faites référence à ces panneaux pour cet exercice.
1. Ajoutez un nœud Family Types à la zone de dessin et choisissez "ROOF-PANEL-4PT".
2. Connectez ce nœud à un nœud de sélection All Elements of Family Type pour transférer tous les éléments de Revit dans Dynamo.

1. Recherchez l'emplacement des points adaptatifs pour chaque élément à l'aide du nœud [Link].
2. Créez un polygone à partir de ces quatre points avec le nœud [Link]. Vous avez maintenant une version abstraite du système à
panneaux dans Dynamo sans avoir à importer la géométrie complète de l'élément Revit.
3. Calculez l'écart planaire grâce au nœud [Link].
Juste pour voir, comme dans l'exercice précédent, définissez le rapport d'ouverture de chaque panneau en fonction de son écart planaire.

1. Ajoutez un nœud [Link] à la zone de dessin et connectez les composants adaptatifs à l'entrée element. Connectez un
bloc de code indiquant "Aperture Ratio" à l'entrée parameterName.
2. Vous ne pouvez pas connecter directement les résultats de l'écart à l'entrée value, car vous devez remapper les valeurs avec l'intervalle de
paramètres.

1. Utilisez [Link] pour remapper les valeurs d'écart avec un domaine compris entre 0.15 et 0.45.
2. Connectez ces résultats à l'entrée value de [Link].
 Dans Revit, vous pouvez donner un sens au changement d'ouverture sur la surface.

En zoomant, il apparaît plus clairement que les panneaux fermés sont orientés vers les coins de la surface. Les coins ouverts sont orientés vers le haut.
Les coins représentent les zones de plus grand écart, tandis que le renflement présente logiquement une courbure minimale.

Couleur et documentation
La définition du rapport d'ouverture n'indique pas clairement l'écart des panneaux sur le toit, et vous modifiez également la géométrie de l'élément réel.
Imaginez que vous souhaitiez simplement étudier l'écart du point de vue de la faisabilité de la fabrication. Il conviendrait de colorer les panneaux en
fonction de l'intervalle d'écart de la documentation. Pour ce faire, utilisez la série d'étapes ci-dessous et suivez un procédé très similaire à celui
susmentionné.
1. Supprimez les nœuds [Link] et ajoutez [Link].
2. Ajoutez un nœud Color Range à la zone de dessin et connectez-le à l'entrée color de [Link]. Vous devez toujours
connecter les valeurs d'écart à l'intervalle de couleurs pour créer le dégradé.
3. Placez le curseur sur l'entrée value. Vous pouvez voir que les valeurs d'entrée doivent être comprises entre 0 et 1 pour mapper une couleur avec
chaque valeur. Vous devez remapper les valeurs d'écart avec cet intervalle.

1. À l'aide de [Link], remappez les valeurs d'écart planaire sur un intervalle compris entre 0 et 1 (remarque : vous pouvez utiliser le
nœud "MapTo" pour définir également un domaine source).
2. Connectez les résultats à un nœud Color Range.
3. La sortie est un intervalle de couleurs, et non un intervalle de nombres.
4. Si vous avez défini le paramètre sur Manuel, cliquez sur Exécuter. À partir de ce point, vous devez être en mesure de choisir l'option
Automatique.
Dans Revit, le dégradé est bien plus lisible, qui est représentatif de l'écart planaire basé sur l'intervalle de couleurs. Mais que faire si vous voulez
personnaliser les couleurs ? Les valeurs d'écart minimal sont représentées en rouge, ce qui semble aller à contre-courant du résultat attendu. L'écart
maximal doit être rouge, avec un écart minimal représenté par une couleur plus douce. Retournez dans Dynamo et corrigez le problème.

1. À l'aide d'un bloc de code, ajoutez deux nombres sur deux lignes différentes : 0; et 255;.
2. Pour créer une couleur rouge et une couleur bleue, connectez les valeurs appropriées à deux nœuds [Link].
3. Créez une liste à partir de ces deux couleurs.
4. Connectez cette liste à l'entrée colors de Color Range et observez l'intervalle de couleurs personnalisé se mettre à jour.
 Dans Revit, vous pouvez désormais mieux comprendre les zones d'écart maximal dans les coins. Rappelez-vous que ce nœud permet de remplacer une
couleur dans une vue. Il serait donc utile si vous aviez une feuille particulière dans le jeu de dessins, axée sur un type particulier d'analyse.

Planification

1. Dans Revit, sélectionnez un panneau ETFE. Quatre paramètres d'occurrence sont disponibles : XYZ1, XYZ2, XYZ3 et XYZ4. Ils sont tous vides
après leur création. Il s'agit de paramètres basés sur du texte et des valeurs requises. Utilisez Dynamo pour écrire les emplacements de points
adaptatifs sur chaque paramètre. Cela permet d'assurer l'interopérabilité si la géométrie doit être envoyée à un ingénieur consultant en façade.
Voici une feuille d'exemple qui contient une nomenclature volumineuse et vide. Les paramètres XYZ sont des paramètres partagés dans le fichier
Revit, ce qui vous permet de les ajouter à la nomenclature.

En zoomant, les paramètres XYZ restent à remplir. Les deux premiers paramètres sont pris en charge par Revit.
L'écriture de ces valeurs requiert une opération de liste complexe. Le graphique lui-même est simple, mais les concepts sont très élaborés à partir du
mappage de liste, comme décrit dans le chapitre de liste.

1. Sélectionnez tous les composants adaptatifs à l'aide de deux nœuds.

2. Extrayez l'emplacement de chaque point à l'aide de [Link].
3. Convertissez ces points en chaînes. N'oubliez pas que le paramètre est basé sur du texte. Vous devez donc saisir le type de données correct.
4. Créez une liste des quatre chaînes qui définissent les paramètres à modifier : XYZ1, XYZ2, XYZ3 et XYZ4.
5. Connectez cette liste à l'entrée parameterName de [Link].
6. Connectez [Link] à l'entrée combinator de [Link].
7. Connectez les composants adaptatifs à list1.
8. Connectez l'élément String de l'objet à list2.
9. Vous obtenez ici une correspondance de liste, car vous écrivez quatre valeurs pour chaque élément, ce qui crée une structure de données
complexe. Le nœud [Link] définit une opération d'un pas vers le bas dans la hiérarchie de données. Par conséquent, les entrées element
et value restent vides. [Link] connecte les sous-listes de ses entrées aux entrées vides de [Link], en fonction de
l'ordre dans lequel elles sont connectées.
Lorsque vous sélectionnez un panneau dans Revit, il y a désormais des valeurs de chaîne pour chaque paramètre. En réalité, vous créeriez un format
plus simple pour écrire un point (X, Y, Z). Cela peut être effectué avec des opérations de chaîne dans Dynamo, mais ce thème n'est pas abordé ici pour
ne pas sortir du cadre de ce chapitre.

Vue de l'exemple de nomenclature avec des paramètres remplis.

Chaque panneau ETFE possède désormais les coordonnées XYZ écrites pour chaque point adaptatif, représentant les coins de chaque panneau pour la
fabrication.
Dictionnaires dans Dynamo
Dictionnaires dans Dynamo
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.

Image publiée avec l'autorisation de [Link]

Qu'est-ce qu'un dictionnaire ?
Dictionnaires
Dynamo 2.0 introduit le concept de séparation du type de données de dictionnaire du type de données de liste. Ce changement peut entraîner des
modifications importantes de la façon dont vous créez et utilisez les données dans vos workflows. Avant la version 2.0, les dictionnaires et les listes étaient
combinés en tant que type de données. En résumé, les listes étaient en fait des dictionnaires avec des clés d'entier.

Qu'est-ce qu'un dictionnaire ?

Un dictionnaire est un type de données composé d'un ensemble de paires clé-valeur, où chaque clé est unique dans chaque ensemble. Un
dictionnaire n'a pas d'ordre et vous pouvez, en fait, rechercher des éléments à l'aide d'une clé au lieu d'une valeur d'index, comme dans une liste.
Dans Dynamo 2.0, les clés peuvent uniquement être des chaînes.

Qu'est-ce qu'une liste ?

Une liste est un type de données composé d'un ensemble de valeurs ordonnées. Dans Dynamo, les listes utilisent des entiers comme valeurs d'index.

Pourquoi ce changement a-t-il été fait et en quoi suis-je concerné ?

La séparation des dictionnaires et des listes place les dictionnaires comme citoyens de première classe que vous pouvez utiliser pour stocker et
rechercher rapidement et facilement des valeurs, sans avoir à mémoriser une valeur d'index ou à maintenir une structure de listes stricte tout au long
de votre workflow. Lors des tests utilisateur, nous avons constaté une réduction significative de la taille du graphique lorsque les dictionnaires
étaient utilisés à la place de plusieurs nœuds GetItemAtIndex.

Quels sont les changements ?

Des modifications de syntaxe ont été apportées. Elles changent la façon dont vous allez initialiser et utiliser les dictionnaires et les listes
dans les blocs de code.
Les dictionnaires utilisent la syntaxe suivante : {key:value}
Les listes utilisent la syntaxe suivante [value,value,value]
De nouveaux nœuds ont été introduits dans la bibliothèque pour vous aider à créer et à modifier les dictionnaires, ainsi qu'à leur envoyer des
requêtes.
Les listes créées dans les blocs de code 1.x seront automatiquement migrées au chargement du script vers la nouvelle syntaxe de liste qui
utilise des crochets [ ] au lieu des accolades { }

En quoi suis-je concerné ? Dans quel but dois-je les utiliser ?

En informatique, les dictionnaires, comme les listes, sont des collections d'objets. Tandis que les listes suivent un ordre spécifique, les dictionnaires
sont des ensembles non ordonnés. Ils ne dépendent pas des numéros séquentiels (index), mais utilisent des clés.

Dans l'image ci-dessous, nous présentons un cas d'utilisation potentiel d'un dictionnaire. Souvent, les dictionnaires servent à relier deux types de données
qui ne possèdent pas de corrélation directe. Dans notre cas, nous connectons la version espagnole d'un mot à la version anglaise pour une recherche
ultérieure.
Utilisations des nœuds
Nœuds de dictionnaire
Dynamo 2.0 présente une variété de nœuds de dictionnaire à notre disposition. Cela inclut les nœuds create, action et query.

[Link] crée un dictionnaire avec les valeurs et les clés fournies. (Le nombre d'entrées correspond à la liste d'entrées la
plus courte possible)
[Link] produira les composants du dictionnaire d'entrée. (Il s'agit de l'inverse du nœud create.)
[Link] crée un objet de dictionnaire dont les clés d'entrée ont été supprimées.
[Link] crée un dictionnaire basé sur les clés d'entrée et les valeurs pour remplacer la valeur en cours au niveau des
clés correspondantes.
[Link] renvoie la valeur à la clé d'entrée.
[Link] vous indique le nombre de paires clés-valeurs dans le dictionnaire.
[Link] renvoie les clés actuellement stockées dans le dictionnaire.
[Link] renvoie les valeurs actuellement stockées dans le dictionnaire.

Le fait de pouvoir lier les données de manière globale avec les dictionnaires constitue une excellente solution de remplacement, par rapport à la méthode de travail classique avec les index et les listes.
Utilisations des blocs de code
Dictionnaires dans les blocs de code
Dynamo 2.0 introduit non seulement les nœuds précédemment abordés dans les dictionnaires, mais aussi les blocs de code.

Vous pouvez utiliser une syntaxe semblable à celle présentée ci-dessous ou des représentations de nœuds basées sur DesignScript.

Étant donné qu'un dictionnaire est un type d'objet dans Dynamo, nous pouvons lui appliquer les actions suivantes.
La gestion de ce type d'interactions est particulièrement utile lorsque vous associez des données Revit à des chaînes. Nous allons maintenant examiner
certains cas d'utilisation de Revit.
Cas d'utilisation
Dictionnaires - Cas d'utilisation de Revit
Avez-vous déjà voulu rechercher quelque chose dans Revit à partir d'un élément de données qu'il contient ?

Il y a des chances si vous avez procédé ainsi :

Dans l'image ci-dessus, nous rassemblons toutes les pièces dans le modèle Revit, nous obtenons l'index de la pièce souhaitée (par numéro de pièce),
puis nous sélectionnons la pièce au niveau de l'index.

Recréez maintenant cette idée à l'aide de dictionnaires.

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...") :
[Link]. Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Vous devez d'abord rassembler toutes les pièces dans votre modèle Revit.

Choisissez la catégorie Revit avec laquelle vous voulez travailler (dans le cas présent, vous travaillez avec des pièces).
Vous indiquez à Dynamo de collecter tous ces éléments.
Ensuite, vous devez décider des clés que vous allez utiliser pour rechercher ces données. (Pour plus d'informations sur les clés, consultez la section 9-1
Qu'est-ce qu'un dictionnaire ?.)

Les données que vous utilisez sont les numéros de pièce.

Vous allez maintenant créer le dictionnaire avec les clés et les éléments donnés.

Le nœud [Link] crée un dictionnaire en fonction des entrées appropriées.

Keys doit être une chaîne, tandis que values peut être une variété de types d'objets.
Enfin, vous pouvez extraire une pièce du dictionnaire avec son numéro de pièce.

String sera la clé que vous utiliserez pour rechercher un objet dans le dictionnaire.
Désormais, [Link] obtiendra l'objet à partir du dictionnaire.

Cette logique de dictionnaire permet également de créer des dictionnaires contenant des objets groupés. Si vous voulez
rechercher toutes les pièces à un niveau donné, vous pouvez modifier le graphique ci-dessus comme suit.

Au lieu d'utiliser le numéro de pièce comme clé, vous pouvez maintenant utiliser une valeur de paramètre (dans le cas présent, vous allez
utiliser le niveau).
Maintenant, vous pouvez regrouper les pièces selon le niveau sur lequel elles résident.

Avec les éléments regroupés par niveau, vous pouvez désormais utiliser les clés partagées (clés uniques) comme clés de votre dictionnaire,
ainsi que les listes de pièces comme éléments.
 Enfin, en utilisant les niveaux du modèle Revit, vous pouvez rechercher les pièces qui résident sur ce niveau dans le dictionnaire.
[Link] prend le nom du niveau et renvoie les objets de pièce à ce niveau.

Les possibilités d'utilisation du dictionnaire sont infinies. La possibilité de lier vos données BIM dans Revit à l'élément lui-même offre une variété de cas
d'utilisation.
Nœuds personnalisés
Nœuds personnalisés
Dynamo offre de nombreuses fonctionnalités prêtes à l'emploi, stockées dans sa bibliothèque de nœuds. Les nœuds personnalisés, quant à eux, constituent
un excellent moyen d'étendre les fonctionnalités de Dynamo pour les adapter à vos habitudes de travail ou pour concevoir un graphique spécial que vous
souhaitez partager avec la communauté.
Présentation des nœuds personnalisés
Nœuds personnalisés
Dynamo propose de nombreux nœuds clés pour une large gamme de tâches de programmation visuelle. Parfois, la création de vos propres nœuds est une
solution plus rapide, plus élégante ou plus facilement partageable. Ces nœuds peuvent être réutilisés dans différents projets, ils rendent votre graphique plus
clair et plus propre, et ils peuvent être transférés vers le gestionnaire de packages et partagés avec la communauté Dynamo mondiale.

Nettoyage de votre graphique

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

Adaptation au changement

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

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

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

Environnement de nœud personnalisé

Passez maintenant à l'environnement de nœud personnalisé et créez un nœud simple pour calculer un pourcentage. L'environnement de nœud personnalisé
est différent de l'environnement graphique Dynamo, mais l'interaction est similaire. Cela étant dit, vous allez maintenant créer votre premier nœud
personnalisé.
Pour créer un nœud personnalisé à partir de zéro, lancez Dynamo et choisissez Nœud personnalisé, ou tapez Ctrl + Maj + N dans la zone de dessin.

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

1. Nom : Pourcentage
2. Description : Calcule le pourcentage d'une valeur par rapport à une autre.
3. Catégorie : [Link]
 Une zone de dessin s'ouvre avec un arrière-plan jaune, indiquant que vous travaillez dans un nœud personnalisé. Dans cette zone de dessin, vous avez
accès à tous les nœuds Dynamo de base, ainsi qu'aux nœuds Input et Output, qui définissent le flux de données entrant et sortant du nœud
personnalisé. Ils sont disponibles dans Core > Input.

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

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

Vous pouvez enregistrer ce nœud personnalisé en tant que fichier .dyf (par opposition au fichier .dyn standard) et il sera automatiquement ajouté à votre
session et aux sessions ultérieures. Le nœud personnalisé se trouve dans votre bibliothèque, dans la catégorie spécifiée dans les propriétés du nœud
personnalisé.
 À gauche : catégorie Core > Math de la bibliothèque par défaut. À droite : Core > Math avec le nouveau nœud personnalisé.

Pour continuer
Maintenant que vous avez créé votre premier nœud personnalisé, les sections suivantes approfondiront la fonctionnalité des nœuds personnalisés et la
publication de workflows génériques. Dans la section suivante, vous allez développer un nœud personnalisé qui transfère la géométrie d'une surface à une
autre.
Création d'un nœud personnalisé
Création d'un nœud personnalisé
Dynamo propose plusieurs méthodes de création de nœuds personnalisés. Vous pouvez créer des nœuds personnalisés à partir de zéro, à partir d'un
graphique existant ou de façon explicite en C#. Dans cette section, vous allez découvrir comment créer un nœud personnalisé dans l'interface utilisateur de
Dynamo à partir d'un graphique existant. Cette méthode est idéale pour nettoyer l'espace de travail, ainsi que pour regrouper une séquence de nœuds à
réutiliser ailleurs.

Nœuds personnalisés pour le mappage UV

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

Création d'un nœud personnalisé à partir d'un graphique existant

Téléchargez et décompressez les fichiers d'exemple de cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous...").
Vous trouverez la liste complète des fichiers d'exemple dans l'annexe. [Link]

Commencez par créer un graphique à imbriquer dans un nœud personnalisé. Dans cet exemple, vous allez créer un graphique qui mappe des polygones
d'une surface de base vers une surface cible, à l'aide de coordonnées UV. Ce processus de mappage UV est fréquemment utilisé, ce qui en fait un bon
candidat pour un nœud personnalisé. Pour plus d'informations sur les surfaces et l'espace UV, reportez-vous à la section 5.5. Le graphique complet est
UVmapping_Custom-[Link] du fichier .zip téléchargé ci-dessus.
 1. Bloc de code : créez un intervalle de 10 nombres compris entre 45 et -45 à l'aide d'un bloc de code.
2. [Link] : connectez la sortie du bloc de code aux entrées "x" et "y" et définissez la liaison sur Référence croisée. Vous devez
maintenant avoir une grille de points.
3. [Link] : connectez la sortie "Point" à l'entrée "origin" pour créer un plan au niveau de chacun des points. Le vecteur normal
par défaut de (0,0,1) est utilisé.
4. [Link] : connectez les plans de l'étape précédente à l'entrée "plan", puis utilisez un bloc de code avec une valeur de 10
pour spécifier la largeur et la longueur.

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

1. [Link] : connectez la sortie Rectangle de l'étape précédente à l'entrée "polygon" pour extraire les points de coin de chaque rectangle.
Il s'agit des points que vous allez mapper sur la surface cible.
2. [Link] : utilisez un bloc de code avec une valeur de 100 pour spécifier la largeur et la longueur d'un rectangle. Il s'agit de
la limite de la surface de base.
3. [Link] : connectez le rectangle de l'étape précédente à l'entrée "closedCurve" pour créer une surface de base.
4. [Link] : connectez la sortie "Point" du nœud [Link] et la sortie "Surface" du nœud [Link] pour
renvoyer le paramètre UV à chaque point.
Maintenant que vous avez une surface de base et un ensemble de coordonnées UV, importez une surface cible et mappez les points entre les surfaces.

1. File Path : sélectionnez le chemin d'accès au fichier de la surface à importer. Le type de fichier doit être .SAT. Cliquez sur le bouton
"Parcourir..." et accédez au fichier UVmapping_srf.sat à partir du fichier .zip téléchargé ci-dessus.
2. [Link] : connectez le chemin d'accès au fichier pour importer la surface. Vous devez voir la surface importée dans
l'aperçu de la géométrie.
3. UV : connectez la sortie du paramètre UV à un nœud UV.U et à un nœud UV.V.
4. [Link] : connectez la surface importée ainsi que les coordonnées u et v. Vous devez maintenant voir une grille de points
3D sur la surface cible.

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

1. [Link] : connectez les points de la surface pour construire une polycourbe à travers les points.
2. Booléen : ajoutez un objet booléen à l'espace de travail et connectez-le à l'entrée "connectLastToFirst" et sélectionnez True pour fermer les
polycourbes. Vous devez maintenant voir des rectangles mappés sur la surface.
3. [Link] : connectez les polycourbes à l'entrée "closedCurve" pour construire des corrections de surface.
Sélectionnez les nœuds à imbriquer dans un nœud personnalisé, en choisissant les entrées et les sorties de votre nœud. Étant donné que votre nœud
personnalisé doit être aussi flexible que possible, il doit être en mesure de mapper des polygones, pas seulement des rectangles.

Sélectionnez les nœuds ci-dessus (en commençant par [Link]), cliquez avec le bouton droit de la souris sur l'espace de travail et choisissez
"Nouveau nœud de la sélection".

Dans la boîte de dialogue Propriétés du nœud personnalisé, attribuez un nom, une description et une catégorie au nœud personnalisé.
Le nœud personnalisé a considérablement nettoyé l'espace de travail. Notez que les entrées et les sorties ont été nommées en fonction des nœuds
d'origine. Modifiez le nœud personnalisé pour rendre les noms plus descriptifs.

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

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

2. Sorties : ajoutez une sortie supplémentaire pour les polygones mappés. Enregistrez le nœud personnalisé et revenez à l'espace de travail de
base.
 Le nœud MapPolygonsToSurface reflète les modifications apportées.

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

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

1. Commencez par modifier le bloc de code d'entrée. Pour commencer un commentaire, saisissez "//" suivi du texte du commentaire. Tapez tout
ce qui peut aider à clarifier le nœud : ici, c'est la surface cible qui est décrite.
2. Définissez également la valeur par défaut pour inputSurface en définissant le type d'entrée sur une valeur équivalente. Ici, la valeur par défaut
est définie sur le jeu [Link] d'origine.
 Vous pouvez également appliquer les commentaires aux sorties. Commencez par modifier le texte dans le bloc de code de sortie. Pour commencer un
commentaire, saisissez "//" suivi du texte du commentaire. Ici, une description plus détaillée est ajoutée pour clarifier les sorties de Polygons et de
surfacePatches.

>

1. Placez le curseur sur les entrées de nœud personnalisé pour afficher les commentaires.
2. Étant donné que la valeur par défaut est définie sur inputSurface, vous pouvez également exécuter la définition sans entrée de surface.
Publication dans votre bibliothèque
Ajout à votre bibliothèque
Vous venez de créer un nœud personnalisé et de l'appliquer à un processus spécifique dans le graphique Dynamo. Vous souhaitez en outre conserver ce
nœud dans la bibliothèque Dynamo pour établir des références à d'autres graphiques. Pour ce faire, vous allez publier le nœud localement. Cette procédure
est semblable à celle utilisée pour publier un package, que vous verrez plus en détail dans le chapitre suivant.

Publication locale d'un nœud personnalisé

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

Téléchargez le fichier d'exemple joint à cet exercice (cliquez avec le bouton droit de la souris et choisissez "Enregistrer le lien sous..."). Vous trouverez
la liste complète des fichiers d'exemple dans l'annexe. [Link]

Après avoir ouvert le nœud personnalisé PointsToSurface, le graphique ci-dessus s'affiche dans l'éditeur de nœuds personnalisés Dynamo. Vous
pouvez également ouvrir un nœud personnalisé en double-cliquant dessus dans l'éditeur graphique Dynamo.
 1. Pour publier un nœud personnalisé localement, cliquez simplement avec le bouton droit de la souris sur la zone de dessin et choisissez "Publier
ce nœud personnalisé...".

Remplissez les informations pertinentes comme dans l'image ci-dessus et choisissez "Publier localement". Notez que le champ Groupe définit
l'élément principal accessible à partir du menu Dynamo.
Choisissez un dossier pour héberger tous les nœuds personnalisés que vous envisagez de publier localement. Dynamo consultera ce dossier à chaque
chargement. Par conséquent, assurez-vous que le dossier réside dans un emplacement permanent. Accédez à ce dossier et choisissez "Sélectionner un
dossier". Votre nœud Dynamo est désormais publié localement et restera dans votre barre d'outils Dynamo chaque fois que vous chargez le
programme.

1. Pour vérifier l'emplacement du dossier de nœud personnalisé, accédez à Paramètres > Gérer les chemins d'accès de nœud et de package...
Dans cette fenêtre, vous voyez que deux chemins sont disponibles : AppData\Itinérance\Dynamo... désigne l'emplacement par défaut des packages
Dynamo installés en ligne. Documents\DynamoCustomNodes... fait référence à l'emplacement des nœuds personnalisés publiés localement. *

1. Vous pouvez déplacer le chemin d'accès au dossier local vers le bas dans la liste affichée ci-dessus (en sélectionnant le chemin d'accès au
dossier et en cliquant sur la flèche vers le bas située à gauche des noms de chemin). Le dossier racine est le chemin par défaut des installations
de package. Ainsi, en conservant le chemin d'installation par défaut du package Dynamo comme dossier par défaut, les packages en ligne sont
séparés des nœuds publiés localement.*

Nous avons changé l'ordre des noms de chemin pour que le chemin par défaut de Dynamo devienne l'emplacement d'installation du package.
En accédant à ce dossier local, vous trouvez le nœud personnalisé d'origine dans le dossier ".dyf", qui est l'extension d'un fichier de nœud personnalisé
Dynamo. Vous pouvez modifier le fichier dans ce dossier et le nœud sera mis à jour dans l'interface utilisateur. Vous pouvez également ajouter des
nœuds au dossier DynamoCustomNode principal et Dynamo les ajoutera à votre bibliothèque au redémarrage.

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