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.

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

• Géométrie pour la conception informatique : comment utiliser les éléments géométriques dans Dynamo ? Explorez plusieurs méthodes pour créer des géométries simples ou complexes à partir de primitives.

• Blocs de construction des programmes : que sont les données et quels en sont les types fondamentaux à utiliser dans mes programmes ? De plus, découvrez comment intégrer les opérations mathématiques et logiques à votre workflow de conception.

• Conception avec des listes : comment gérer et coordonner les structures de données ? Apprenez-en davantage sur le concept de liste et utilisez-le pour gérer efficacement vos données de conception.

• Dictionnaires dans Dynamo : que sont les dictionnaires ? Découvrez comment utiliser les dictionnaires pour rechercher des données et des valeurs spécifiques à partir de résultats existants.

Courbes dans Dynamo

Qu’est-ce qu’une courbe ?

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

Ligne

Courbe NURBS

NURBS est un modèle utilisé pour représenter les courbes et les surfaces avec précision. 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. NurbsCurve.ByControlPoints utilise la liste de points comme points de contrôle.

2. NurbsCurve.ByPoints trace une courbe passant par la liste de points.

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

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

Approfondir...

Courbes

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

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

Vecteur

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

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

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

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

Plan

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

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

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

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

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

Système de coordonnées

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

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

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

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

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

Approfondir...

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

Vecteur

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

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

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

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

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

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

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

Roger, Roger. Quel est votre vecteur, Victor ?

Plan

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

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

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

Système de coordonnées

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

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

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

Surfaces dans Dynamo

Qu’est-ce qu’une surface ?

Grâce à l’utilisation de la surface dans le modèle, vous pouvez représenter des objets dans un univers en trois dimensions. Bien que les courbes ne soient pas toujours planes, c’est-à-dire tridimensionnelles, l’espace qu’elles définissent est toujours lié à une cote. 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.

Surface au niveau d’un paramètre

Importez et évaluez une surface au niveau d’un paramètre dans Dynamo pour voir quel type d’informations vous pouvez extraire.

1. Surface.PointAtParameter renvoie le point à une coordonnée UV donnée.

2. Surface.NormalAtParameter renvoie le vecteur normal à une coordonnée UV donnée.

3. Surface.GetIsoline renvoie la courbe isoparamétrique à une coordonnée U ou V. Notez l’entrée isoDirection.

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

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

Approfondir...

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.

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 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,...).

Dans Dynamo, ajoutez/transmettez des données aux ports d’entrée des nœuds. 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

Valeur nulle –·Absence de données

Attention aux 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.

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 :

Une liste représente un ensemble d’éléments placés dans une structure de données :

• J’ai cinq doigts (éléments) sur la main (liste).

• Il y a dix maisons (éléments) dans ma rue (liste).

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 List.GetItemAtIndex 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 List.Create. Le nœud crée une liste de listes. Cette action modifie la structure des données.

5. Lorsque vous utilisez de nouveau List.GetItemAtIndex, 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. Que cela signifie-t-il ? Découvrez-le grâce à un exemple.

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

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

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

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

Partie I : Configuration du graphique pour un cylindre avec des paramètres modifiables

1. Ajoutez Point.ByCoordinates : 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.

2. Plan.ByOriginNormal : 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.

Vector.ZAxis : 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 Plane.ByOriginNormal. Vous obtenez ainsi un plan rectangulaire dans l’aperçu Dynamo.

3. Circle.ByPlaneRadius : 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.

4. Curve.Extrude : 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.

5. Surface.Thicken : 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.

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

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.

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.

7. 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 (p.ex., vous devez disposer d’une profondeur d’extrusion pour disposer d’une surface à épaissir).

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

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 (Épaisseur, Rayon, Hauteur, etc.).

Partie II : Alimentation d’un réseau de cylindres à partir de la partie I

9. À 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.

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.

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

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

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

c. Integer Slider : connectez un curseur d’entier à la valeur amount. Cela permet de définir le nombre de cylindres créés.

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

11. Cette étape est relativement simple : connectez la séquence définie à l’étape précédente à l’entrée x du nœud Point.ByCoordinates 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).

12. La chaîne de cylindres est toujours liée dynamiquement à tous les curseurs. Ajustez chaque curseur et observez la définition se mettre à jour.

Solides dans Dynamo

Qu’est-ce qu’un solide ?

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.

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

Vous pouvez utiliser des opérations booléennes pour modifier des solides. Utilisez quelques opérations booléennes pour créer une balle hérisson.

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

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

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

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

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

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

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

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

Gel

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

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

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

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

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

Approfondir...

Solides

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

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

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

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

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

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

Topologie

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

1. Faces

2. Arêtes

3. Sommets

Opérations

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

1. Cube solide

2. Cube chanfreiné

3. Cube raccordé

Opérations booléennes

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

1. Entrecouper au moins deux objets.

2. Les scinder aux intersections.

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

4. Rassembler le tout.

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

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

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

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

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

Géométrie dans Dynamo Sandbox

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

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

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

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

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

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

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

Le concept de géométrie

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

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

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

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

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

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

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

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

Navigation dans la hiérarchie

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

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

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

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

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

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

Aller plus loin avec la géométrie

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

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

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

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

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

Opérateurs arithmétiques

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

Exercice : Formule de la clothoïde dorée

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

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

Partie I : Formule paramétrique

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

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

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

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

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

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

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

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

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

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

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

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

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

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 DesignScript 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 de Fibonacci.

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

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

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

Partie III : De la clothoïde au Nautilus

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

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

Et c’est encore mieux en 3D !

Partie IV : Du Nautilus à la phyllotaxie

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.

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


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

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

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

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

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

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

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

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

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

Valeurs booléennes

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

Instructions conditionnelles

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

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

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

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

Exercice : Logique et géométrie

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

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

Partie I : Filtrage d’une liste

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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.

Query

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

• Nombre de cartes dans le paquet ? 52.

• Nombre de couleurs ? 4.

• Matériau ? Papier.

• Longueur ? 3,5 pouces ou 89 mm.

• Largeur ? 2,5 pouces ou 64 mm.

Action

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

• Vous pouvez mélanger le paquet.

• Vous pouvez trier le paquet par valeur.

• Vous pouvez trier le paquet par couleur.

• Vous pouvez diviser le paquet.

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

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

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

Exercice

Opérations de liste

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

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

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

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

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

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

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

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

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

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

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

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

List.Count

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

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

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

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

List.GetItemAtIndex

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

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

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

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

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

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

List.Reverse

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

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

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

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

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

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

List.ShiftIndices

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

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

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

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

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

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

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

List.FilterByBooleanMask

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

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

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

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

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

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

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

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

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

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

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

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

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.

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 de bananes 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.

a. Index

b. Point

c. Elément

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, PolyCurve.ByPoints et Circle.ByCenterPointRadius :

1. L’entrée points de PolyCurve.ByPoints recherche « Point[] ». Cela représente une liste de points.

2. La sortie de PolyCurve.ByPoints est une simple polycourbe créée à partir d’une liste de cinq points.

3. L’entrée centerPoint de Circle.ByCenterPointRadius demande « Point ».

4. La sortie de Circle.ByCenterPointRadius est une liste de cinq cercles, dont les centres correspondent à la liste de points d’origine.

Les données d’entrée de PolyCurve.ByPoints et de Circle.ByCenterPointRadius sont identiques. Cependant, le nœud Polycurve.ByPoints vous donne une polycourbe, tandis que le nœud Circle.ByCenterPointRadius 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 Polycurve.ByPoints, 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 Circle.ByCenterPointRadius 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.

Combinaison

Sans solution de nettoyage, la correspondance des données est un problème. C'est le cas lorsqu'un nœud a accès à des entrées de taille différente. La modification de l’algorithme de correspondance 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 (Line.ByStartPointEndPoint). Il comporte deux paramètres d’entrée qui définissent tous deux des coordonnées de point :

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 :

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 :

Produit cartésien

Enfin, la méthode « Produit cartésien » permet d’établir toutes les connexions possibles :

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 combinaison, cliquez avec le bouton droit de la souris sur le centre d’un nœud et sélectionnez le menu « Combinaison ».

Exercice

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

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

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.

Vous allez modifier la combinaison sur Point.ByCoordinates, mais sans modifier d’autres paramètres du graphique ci-dessus.

Liste la plus courte

Si vous choisissez l’option de liaison Liste la plus courte (également l’option par défaut), vous obtenez une ligne diagonale de base composée de cinq points. Étant donné que la liste la plus courte contient cinq points, la combinaison de la liste la plus courte s’arrête après avoir atteint la fin d’une liste.

Liste la plus longue

En définissant la combinaison 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

En définissant la liaison sur Produit cartésien, vous obtenez toutes les combinaisons 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.

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.

Maillage dans Dynamo

Qu’est-ce qu’un maillage ?

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

Éléments maillage

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

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

1. Liste de sommets

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

Mesh Toolkit

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.

Approfondir…

Maillage

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

1. Sommets de maillage.

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

3. Faces de maillage.

Sommets + normales de sommet

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

1. Sommets

2. Normales de sommet

Faces

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

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

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

Maillages et surfaces NURBS

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

Définition des paramètres

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

1. Surface

2. Courbe isoparamétrique (isoparm)

3. Point de contrôle de surface

4. Polygone de contrôle de surface

5. Point isoparamétrique

6. Cadre de surface

7. Maillage

8. Arête nue

9. Réseau de maillage

10. Arêtes de maillage

11. Normale de sommet

12. Face de maillage/Normale de face de maillage

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

Influence locale et globale

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

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

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

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

Points dans Dynamo

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.

Point 2D et 3D

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 3D dans Dynamo).

Un point 2D dans Dynamo possède deux coordonnées [X, Y].

Point sur des courbes et des surfaces

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 en cliquant sur le lien ci-dessous.

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

Approfondir...

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)

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]

Qu’est-ce qu’une chaîne ?

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.

Exercice

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

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

Interrogation des chaînes

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 3 é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 String.ToNumber.

1. Ce nœud est simple. Connectez les résultats String.Split à 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.

Avec certaines opérations supplémentaires de base, vous avez maintenant un triangle 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 suivante 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 String.Join pour créer une structure de données similaire.

L’image suivante 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 String.Split à 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 String.Contains 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. List.FilterByBoolMask 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 List.GetItemAtIndex, 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, utilisez le nœud String.Join :

1. Après avoir ajouté le nœud String.Join, 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.

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, l’image ci-dessous contient une liste de rouleaux de pièces de monnaie, et chaque rouleau contient une liste de centimes.

Photo de Dori.

Requête

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

• Nombre de pièces de monnaie ? 2.

• Valeurs des type de pièce 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.

Action

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

Exercice

Hiérarchie verticale

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

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

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 List.GetItemAtIndex, 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 :

1. Grâce au nœud Code Block, vous avez défini deux intervalles : 0..2; 0..3;

2. Ces intervalles sont connectés à un nœud Point.ByCoordinates avec la combinaison 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 List.GetItemAtIndex 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.

List.Flatten

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

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

Le noeud 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.

1. Insérez une ligne de code pour définir un intervalle dans le nœud Code Block : -250..-150..#4;

2. En connectant le bloc de code aux entrées x et y d’un nœud Point.ByCoordinates, vous définissez la combinaison 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 PolyCurve.ByPoints référence chaque liste et crée une polycourbe respective. Dans l’aperçu Dynamo, notez 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 PolyCurve.ByPoints 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 List.Flatten 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 List.Map. Vous en découvrirez plus sur List.Map ci-dessous.

Chop

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

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

Lors de la modélisation paramétrique, vous pouvez ajouter la structure de données à 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.

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.

List.Map

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

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

La commande List.Map/Combine applique une fonction définie à une liste d’entrées, mais à un niveau plus bas dans 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.

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

En guise d’introduction, examinons le nœud List.Count d’une section précédente.

Le nœud List.Count compte tous les éléments d’une liste. Vous allez l’utiliser pour montrer comment fonctionne List.Map.

1. Insérez deux lignes de code dans le nœud Code Block : -50..50..#Nx; -50..50..#Ny;

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

2. Avec deux nœuds Integer Slider, définissez les valeurs Nx et Ny en les connectant au nœud Code Block.

3. Connectez chaque ligne du bloc de code aux entrées X et Y respectives d’un nœud Point.ByCoordinates. Cliquez avec le bouton droit de la souris sur le nœud, sélectionnez « Combinaison », 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.

4. 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 List.Count à la sortie du nœud Watch de l’étape précédente.

2. Connectez un nœud Watch à la sortie List.Count.

Le nœud List.Count 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 Point.ByCoordinates 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 List.Count 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 List.Map, vous descendez d’un niveau dans la hiérarchie et effectuez une « fonction » à ce niveau.

2. Le nœud List.Count n’a pas d’entrée. Il est utilisé en tant que fonction, de sorte que le nœud List.Count sera appliqué à chaque liste individuelle d’un niveau vers le bas dans la hiérarchie. L’entrée vide de List.Count correspond à l’entrée de liste de List.Map.

3. Les résultats de List.Count 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.

List.Combine

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

Dans cet exercice, vous allez utiliser le nœud List.Combine pour montrer comment il peut être utilisé pour appliquer une fonction à des listes d’objets distinctes.

Commencez par configurer deux listes de points.

1. Utilisez le nœud Sequence pour générer 10 valeurs, chacune avec un incrément de 10 pas.

2. Connectez le résultat à l’entrée x d’un nœud Point.ByCoordinates. Cela permet de créer une liste de points dans Dynamo.

3. Ajoutez un deuxième nœud Point.ByCoordinates à l’espace de travail, utilisez la même sortie Sequence que son entrée x, mais utilisez un nœud Integer Slider comme entrée y et définissez sa valeur sur 31 (il peut s’agir de n’importe quelle valeur, à condition qu’elle ne chevauche pas le premier jeu de points) de sorte que les deux jeux de points ne se chevauchent pas.

Ensuite, utilisez le nœud List.Combine pour appliquer une fonction aux objets dans deux listes distinctes. Dans ce cas, il s’agit d’une fonction de dessin de ligne simple.

1. Ajoutez un nœud List.Combine à l’espace de travail et connectez les deux jeux de points comme entrées list0 et list1.

2. Utilisez Line.ByStartPointEndPoint comme fonction d’entrée pour le nœud List.Combine.

Une fois l’opération terminée, les deux jeux de points sont compressés/associés via une fonction Line.ByStartPointEndPoint et renvoient 10 lignes dans Dynamo.

List@Level

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

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

À privilégier par rapport List.Map, 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.

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

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

1. Puisque la grille est construite avec un 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.

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

3. 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. La liste au niveau 2 avec l'index 0 inclut uniquement le premier jeu de points Y, renvoyant uniquement la grille XZ.

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

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

4. 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 List.Map, List@Level simplifie grandement l’interaction, ce qui facilite l’accès aux données de nœud. Comparez les méthodes List.Map 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 List.Map, vous avez besoin d’un nœud List.GetItemAtIndex avec List.Map. Pour chaque niveau de liste que vous allez décaler vers le bas, utilisez un nœud List.Map supplémentaire. Selon la complexité de vos listes, vous devrez peut-être ajouter une quantité importante de nœuds List.Map à votre graphique pour accéder au niveau d’informations approprié.

3. Dans cet exemple, un nœud List.GetItemAtIndex avec un nœud List.Map renvoie le même jeu de points avec la même structure de liste que List.GetItemAtIndex avec « @L3 » sélectionné.

Transposer

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

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

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.

Supprimez les nœuds List.Count 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 PolyCurve.ByPoints à la sortie du nœud Watch à partir de Point.ByCoordinates.

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. Un nœud List.Transpose 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 PolyCurve.ByPoints, vous obtenez 3 polycourbes perpendiculaires aux courbes d’origine.

Code Block pour la création de listes

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 List.Create. Le nœud Code Block est abordé plus en détail dans la rubrique Nœuds Code Block et DesignScript. 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 Code Block utilise « [] » pour sélectionner facilement et rapidement des éléments spécifiques à partir d’une structure de données complexe. Les nœuds Code Block sont abordés plus en détail dans le chapitre Nœuds Code Block et DesignScript. 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 en cliquant sur le lien ci-dessous.

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.

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.

1. À l’aide du nœud Code Block, insérez ces deux lignes de code et connectez-les aux entrées u et v de Surface.PointAtParameter, respectivement : -50..50..#3; -50..50..#5;

2. Veillez à définir la combinaison de Surface.PointAtParameter sur « Produit vectoriel ».

3. 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 du nœud Code Block, écrivez une ligne de code de base afin d’interroger une liste de listes : points[1][2];

3. À l’aide de Geometry.Translate, 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 List.GetItemAtIndex. Remarque : comme lors de l’étape précédente, vous pouvez également interroger la liste avec le nœud Code Block, à 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 List.ReplaceItemAtIndex, remplacez l’élément central à l’aide d’un index de « 2 » par l’élément de remplacement connecté au point déplacé (Geometry.Translate).

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 List.ReplaceItemAtIndex pour remplacer la liste centrale par la liste modifiée.

2. Les nœuds Code Blocks définissant l’index de ces deux nœuds sont 1 et 2, ce qui correspond à la requête d’origine du nœud Code Block (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 NurbsCurve.ByPoints et connectez la nouvelle structure de données pour créer trois courbes NURBS.

1. Connectez une surface Surface.ByLoft à la sortie de NurbsCurve.ByPoints. 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.

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 originale avec l’autorisation de : sixtysecondrevit.com

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 nœuds Code Block v1.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.

1. Créez un dictionnaire pour relier les deux types de données.

2. Obtenez la valeur avec la clé donnée.

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

Création de couleurs

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

Interrogation des valeurs de couleur

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

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

Intervalles de couleurs

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

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

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

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

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

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

Aperçu des couleurs

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

Couleur sur les surfaces

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

Exercice

Hélice de base avec couleurs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exercice - Couleur sur surfaces

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

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

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

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

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

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

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

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

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

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

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

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

Affichage

Color

Watch

Entrée

List

Logique

Math

Chaîne

Géométrie

Circle

Cuboid

Curve

Geometry Modifiers

Ligne

NurbsCurve

NurbsSurface

Plan

Point

Polycourbe

Rectangle

Sphere

Surface

UV

Vecteur

CoordinateSystem

Opérateurs

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 ) est une analogie pour les listes dimensionnelles. Chaque couche représente une liste et chaque liste contient des éléments. Dans le cas de Dynamo, chaque conteneur peut contenir plusieurs conteneurs (représentant les éléments de chaque liste).

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

Mappage et combinaisons

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

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

Exercice - Listes 2D - Basique

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Exercice - Listes 2D - Avancé

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1. Si vous souhaitez inverser l’orientation des courbes dans la structure nervurée, utilisez un nœud List.Transpose avant de les connecter à NurbsCurve.ByPoints. 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.

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

1. Comme dans l’exercice précédent, utilisez le nœud Surface.Offset 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 nœud Code Block avec les deux lignes de code suivantes : 0..1..#20; 0..1..#20;

2. Connectez ces sorties à deux nœuds Surface.PointAtParameter dont la combinaison est définie sur « Produit vectoriel ». L’un de ces nœuds est connecté 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 NurbsCurve.ByPoints.

2. Observez la sortie de NurbsCurve.ByPoints : 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 Surface.PointAtParameter. Dans ce cas, vous avez une liste de listes de listes.

1. Avant de continuer, désactivez l’aperçu des surfaces existantes.

2. À l’aide du nœud List.Create, fusionnez les courbes NURBS en une structure de données, créant ainsi une liste de listes de listes.

3. Lorsque vous connectez un nœud Surface.ByLoft, 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 List.Transpose 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 List.Transpose 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 List.Combine fonctionne mieux ici. Lorsque vous obtenez des structures de données plus complexes, utilisez les nœuds List.Map et List.Combine.

2. L’utilisation du nœud List.Create 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 List.Map. Ce nœud fonctionne comme List.Combine, sauf qu’il utilise une liste d’entrées, au lieu de deux listes ou plus.

2. La fonction appliquée à List.Map est List.Transpose, 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 à l’aide d’un nœud Surface.Thicken avec les paramètres d’entrée, comme indiqué.

1. Il peut être utile d’ajouter un support de surface à deux de ces structures. Ajoutez un autre nœud Surface.ByLoft et utilisez la première sortie de NurbsCurve.ByPoints d’une étape précédente comme entrée.

2. Comme l’aperçu est de plus en plus encombré, désactivez l’aperçu de ces nœuds en cliquant avec le bouton droit sur chacun d’eux et désélectionnez l’option « Aperçu » pour mieux voir le résultat.

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 List.Map avec une fonction List.Tranpose pour modifier la direction des courbes Nurbs.

1. Augmentez le nombre de girons de façon à pouvoir modifier le nœud Code Block comme suit : 0..1..#20; 0..1..#30;

La première version de la chaise à bascule était lisse. Le second modèle propose une chaise à bascule sportive originale.

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.

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é comme dans l’exemple suivant.

Dans l’image ci-dessous, vous allez rassembler toutes les pièces dans le modèle Revit, obtenir l’index de la pièce souhaitée (par numéro de pièce), puis sélectionner la pièce au niveau de l’index.

1. Rassemblez toutes les pièces du modèle.

2. Numéro de pièce à rechercher.

3. Obtenez le numéro de chambre et trouvez l’index correspondant.

4. Obtenez la pièce au niveau de l’index.

Exercice : Dictionnaire de pièces

Partie I : Création d’un dictionnaire de pièces

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

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

Recréez maintenant cette idée à l'aide de dictionnaires. Vous devez d’abord rassembler toutes les pièces dans votre modèle Revit.

1. Choisissez la catégorie Revit avec laquelle vous voulez travailler (dans le cas présent, vous travaillez avec des pièces).

2. Vous indiquez à Dynamo de collecter tous ces éléments.

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

1. Le nœud Dictionary.ByKeysValues crée un dictionnaire en fonction des entrées appropriées.

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

1. String est la clé que vous utilisez pour rechercher un objet dans le dictionnaire.

2. Désormais, Dictionary.ValueAtKey obtiendra l’objet à partir du dictionnaire.

Partie II : Recherche de valeurs

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.

1. 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).

1. Maintenant, vous pouvez regrouper les pièces selon le niveau sur lequel elles résident.

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

1. Enfin, en utilisant les niveaux du modèle Revit, vous pouvez rechercher les pièces qui résident sur ce niveau dans le dictionnaire. Dictionary.ValueAtKey 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.

Dynamo 2.0 présente une variété de nœuds de dictionnaire à notre disposition. Cela inclut les nœuds create, action et query.

Créer

1.Dictionary.ByKeysValues 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)

Action

1. Dictionary.Components produit les composants du dictionnaire d’entrée. (Il s’agit de l’inverse du nœud create.)

2. Dictionary.RemoveKeys crée un objet de dictionnaire dont les clés d’entrée ont été supprimées.

3. Dictionary.SetValueAtKeys 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.

4. Dictionary.ValueAtKey renvoie la valeur à la clé d’entrée.

Quantité

1. Dictionary.Count vous indique le nombre de paires clés-valeurs dans le dictionnaire.

2. Dictionary.Keys renvoie les clés actuellement stockées dans le dictionnaire.

3. Dictionary.Values 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.