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.
Une liste est un ensemble d'éléments. Par exemple, prenez une grappe de bananes. Chaque banane est un élément de la liste (ou grappe). Il est plus facile de ramasser une grappe de bananes plutôt que chaque banane individuellement. Il en est de même pour le regroupement d’éléments par relations paramétriques dans une structure de données.
Photo de Augustus Binu.
Quand vous faites les courses, vous déposez tous vos achats dans un sac. Ce sac est aussi une liste. Si vous préparez un cake aux bananes, il vous faut 3 grappes de bananes (vous préparez plusieurs cakes aux bananes). Le sac représente une liste de grappes de bananes et chaque grappe représente une liste de bananes. Le sac est une liste de listes (bidimensionnelle) et la grappe 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.
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.
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 :
L’entrée points de PolyCurve.ByPoints recherche « Point[] ». Cela représente une liste de points.
La sortie de PolyCurve.ByPoints est une simple polycourbe créée à partir d’une liste de cinq points.
L’entrée centerPoint de Circle.ByCenterPointRadius demande « Point ».
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.
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 :
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 :
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 :
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 ».
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.
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.
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.
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.
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.
Quelles requêtes pouvez-vous faire à partir de la liste ? Elles permettent d’accéder aux propriétés existantes.
Nombre de cartes dans le paquet ? 52.
Nombre de couleurs ? 4.
Matériau ? Papier.
Longueur ? 3,5 pouces ou 89 mm.
Largeur ? 2,5 pouces ou 64 mm.
Quelles actions pouvez-vous effectuer dans la liste ? Elles permettent de modifier la liste en fonction d’une opération donnée.
Vous pouvez mélanger le paquet.
Vous pouvez trier le paquet par valeur.
Vous pouvez trier le paquet par couleur.
Vous pouvez diviser le paquet.
Vous pouvez diviser le paquet en distribuant les mains individuelles.
Vous pouvez sélectionner une carte spécifique dans le paquet.
Toutes les opérations répertoriées ci-dessus possèdent des nœuds Dynamo similaires qui permettent de travailler avec des listes de données génériques. Les leçons ci-dessous présentent certaines des opérations fondamentales que vous pouvez effectuer sur des listes.
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.
Commencez par un nœud Code Block avec une valeur de
500;.Connectez-le à l’entrée x d’un nœud Point.ByCoordinates.
Connectez le nœud de l’étape précédente à l’entrée d’origine d’un nœud Plane.ByOriginNormal.
À l’aide d’un nœud Cercle.ByPlaneRadius, connectez le nœud de l’étape précédente à l’entrée plane.
À l’aide d’un nœud Code Block, désignez une valeur de
50;pour le rayon. Il s’agit du premier cercle créé.À l’aide d’un nœud Geometry.Translate, déplacez le cercle de 100 unités vers le haut dans la direction Z.
À 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;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.
À l’aide d’un nœud Line.ByStartPointEndPoint, connectez les deux nœuds Curve.PointAtParameter.
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.
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.
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.
Tout d’abord, cliquez avec le bouton droit sur le nœud Line.ByStartPointEndPoint pour désactiver son aperçu.
À 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.
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.
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;.Dupliquez le nœud Line.ByStartPointEndPoint, insérez un nœud List.Reverse entre Curve.PointAtParameter et le deuxième nœud Line.ByStartPointEndPoint.
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.
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.
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.
À l’aide d’un nœud Code Block, définissez une valeur de « 1 » pour déplacer la liste d’un index.
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.
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…
À 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.À 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.
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 ».
Le nœud Watch montre que vous avez un motif true/false qui indique : true,false,false,false….
À l’aide de ce motif true/false, connectez-vous à l’entrée mask de deux nœuds List.FilterByBooleanMask.
Connectez le nœud Curve.PointAtParameter à chaque entrée list de List.FilterByBooleanMask.
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.
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.
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.
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.
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.
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 :
Grâce au nœud Code Block, vous avez défini deux intervalles :
0..2; 0..3;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.
Le nœud Watch donne 3 listes contenant chacune 4 éléments.
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.
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.
Insérez une ligne de code pour définir un intervalle dans le nœud Code Block :
-250..-150..#4;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.
Le nœud Watch indique que vous avez une liste de listes.
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.
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.
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.
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.
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.
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.
Avec deux nœuds Integer Slider, définissez les valeurs Nx et Ny en les connectant au nœud Code Block.
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.
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.
Attachez un nœud List.Count à la sortie du nœud Watch de l’étape précédente.
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.
En utilisant un nœud List.Map, vous descendez d’un niveau dans la hiérarchie et effectuez une « fonction » à ce niveau.
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.
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.
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.
Utilisez le nœud Sequence pour générer 10 valeurs, chacune avec un incrément de 10 pas.
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.
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.
Ajoutez un nœud List.Combine à l’espace de travail et connectez les deux jeux de points comme entrées list0 et list1.
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.
Reportez-vous à l’exercice dans Listes à n dimensions pour découvrir un autre exemple d’utilisation du nœud List.Combine.
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.
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.
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.
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.
Pour utiliser la fonction List@Level , cliquez sur « > ». Dans ce menu, vous verrez deux cases à cocher.
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.
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.
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.
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.
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.
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 :
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.
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é.
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é.
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.
Connectez un nœud PolyCurve.ByPoints à la sortie du nœud Watch à partir de Point.ByCoordinates.
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.
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.
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.
Observez le résultat géométrique : à l’aide du nœud PolyCurve.ByPoints, vous obtenez 3 polycourbes perpendiculaires aux courbes d’origine.
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.
À 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;Veillez à définir la combinaison de Surface.PointAtParameter sur « Produit vectoriel ».
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 ?
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.
À l’aide du nœud Code Block, écrivez une ligne de code de base afin d’interroger une liste de listes :
points[1][2];À l’aide de Geometry.Translate, vous allez déplacer le point sélectionné vers le haut dans la direction Z de 20 unités.
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.
Vous devez d’abord remplacer l’élément de la liste isolé à l’étape précédente.
À 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).
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.
En suivant la même logique, utilisez List.ReplaceItemAtIndex pour remplacer la liste centrale par la liste modifiée.
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]).
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.
Créez un nœud NurbsCurve.ByPoints et connectez la nouvelle structure de données pour créer trois courbes NURBS.
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.
Photo de
Photo de .
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 ci-dessous.
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_ ci-dessous.
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 . Consultez l’image ci-dessous pour découvrir comment définir une liste contenant plusieurs expressions à l’aide d’un 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 . 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.
Pour compliquer la tâche, vous allez ajouter encore plus de niveaux à la hiérarchie. La structure des données peut s'étendre au-delà d'une liste bidimensionnelle de listes. Étant donné que les listes sont des éléments dans Dynamo, vous pouvez créer des données avec autant de dimensions que possible.
L'analogie utilisée ici est celle des poupées russes. Chaque liste peut être considérée comme un conteneur contenant plusieurs éléments. Chaque liste possède ses propres propriétés et est considérée comme son propre objet.
L’ensemble de poupées russes (photo de Zeta) est une analogie pour les listes dimensionnelles. Chaque couche représente une liste et chaque liste contient des éléments. Dans le cas de Dynamo, chaque conteneur peut contenir plusieurs conteneurs (représentant les éléments de chaque liste).
Les listes à n dimensions sont difficiles à expliquer visuellement, mais vous allez découvrir dans ce chapitre quelques exercices axés sur des listes de plus de deux dimensions.
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.
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.
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.
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.
Sélectionnez l’index de 1 pour sélectionner la surface supérieure. Pour ce faire, utilisez le nœud List.GetItemAtIndex.
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.
Pour voir comment la structure de données est organisée, connectez un nœud NurbsCurve.ByPoints à la sortie de Surface.PointAtParameter.
Vous pouvez désactiver l’aperçu du nœud List.GetItemAtIndex pour obtenir un résultat plus clair.
Un nœud List.Transpose de base permet d’inverser les colonnes et les lignes d’une liste de listes.
Lorsque vous connectez la sortie de List.Transpose à NurbsCurve.ByPoints, vous obtenez cinq courbes placées horizontalement sur la surface.
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.
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.
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.
À l’aide du nœud Surface.Offset, décalez la surface par une valeur de 10.
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;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.
Désactivez l’aperçu de ces surfaces.
Comme dans l’exercice précédent, connectez les sorties à deux nœuds NurbsCurve.ByPoints. Le résultat affiche les courbes correspondant à deux surfaces.
Le nœud List.Create vous permet de combiner les deux jeux de courbes en une liste de listes.
La sortie affiche deux listes contenant chacune dix éléments, représentant chaque ensemble de connexions de courbes NURBS.
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.
Désactivez l’aperçu du nœud Surface.ByLoft à l’étape précédente.
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.
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.
Avant de commencer, désactivez l’aperçu de Surface.ByLoft à l’étape précédente pour éviter toute confusion.
Le nœud List.Combine constitue une alternative au nœud List.Transpose. Il exécute un « combinateur » sur chaque sous-liste.
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.
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.
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.
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.
Comme dans l’exercice précédent, utilisez le nœud Surface.Offset pour effectuer un décalage d’une valeur de 10.
Dans la sortie, vous pouvez voir que le nœud de décalage a créé deux surfaces.
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;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.
Comme dans l’exercice précédent, connectez les sorties à deux nœuds NurbsCurve.ByPoints.
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.
Les choses deviennent plus complexes dans le nœud Surface.PointAtParameter. Dans ce cas, vous avez une liste de listes de listes.
Avant de continuer, désactivez l’aperçu des surfaces existantes.
À 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.
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.
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.
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.
L’utilisation du nœud List.Create comme « combinateur » vous permet de créer une structure de données plus appropriée.
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.
La fonction appliquée à List.Map est List.Transpose, permettant d’inverser les colonnes et les lignes des sous-listes dans la liste principale.
Enfin, vous pouvez lisser les courbes NURBS avec une hiérarchie de données correcte. Vous obtenez ainsi une structure nervurée.
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é.
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.
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.
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.
É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.
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.
