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.
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.
Données simples
Exécution réussie des données et des actions (nœud A)
Une action (nœud A) sans entrées de données renvoie une fonction générique
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.
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).
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.
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).
Si vous appliquez le même processus à la deuxième liste, vous obtenez la valeur 0, le premier élément de la liste.
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.
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.
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.
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.).
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.
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.
Les opérateurs sont un ensemble de composants qui utilisent des fonctions algébriques avec deux valeurs numériques d'entrée, ce qui génère une valeur de sortie unique (addition, soustraction, multiplication, division, etc.). Ces commandes sont disponibles sous Opérateurs > Actions.
| Icône | Nom (Syntaxe) | Entrées | Sorties |
|---|---|---|---|
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.
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.
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.
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 !
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.
| Icône | Nom/Syntaxe | Entrées | Sorties |
|---|---|---|---|
Object.IsNull
obj
bool
Ajouter (+)
var[]…[], var[]…[]
var[]…[]
Soustraire (-)
var[]…[], var[]…[]
var[]…[]
Multiplier (*)
var[]…[], var[]…[]
var[]…[]
Diviser (/)
var[]…[], var[]…[]
var[]…[]
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.
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.
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.
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 :
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.
Pour créer un séparateur, appuyez sur « + » au milieu du nœud.
Ajoutez une chaîne « , » à la zone de dessin et connectez-la à la nouvelle entrée de séparateur.
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.
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.
É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 :
Pour ajouter ou soustraire des chaînes à la concaténation, cliquez sur les boutons +/- au centre du nœud.
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 :
L’entrée separator permet de créer une chaîne qui divise les chaînes jointes.
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.
La chaîne de base est collée dans un nœud String.
Un autre nœud String est utilisé pour désigner le séparateur. Dans ce cas, utilisez une virgule.
Ajoutez un nœud String.Split à la zone de dessin et connectez-le aux deux chaînes.
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.
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.
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 ».
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.
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 ».
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 :
À 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.
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 :
Après avoir ajouté le nœud String.Join, vous remarquez que vous avez besoin d’un séparateur.
Pour créer le séparateur, ajoutez un nœud String dans la zone de dessin et entrez une virgule.
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.
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.
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é.
L’instruction « If » est un concept clé de la programmation : « If » cet élément a la valeur True, voici le résultat, sinon autre chose se produit. L’action résultant de l’instruction est déterminée par une valeur booléenne. Il existe plusieurs méthodes pour définir une instruction "If" dans Dynamo :
| Icône | Nom (Syntaxe) | Entrées | Sorties |
|---|---|---|---|
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.
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.
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.
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.
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.
Dans Dynamo, les couleurs sont créées à l’aide des entrées ARVB. Cet acronyme correspond aux canaux Alpha, Rouge, Vert et Bleu. L’alpha représente la transparence de la couleur, tandis que les trois autres couleurs sont utilisées comme couleurs primaires pour générer de concert l’ensemble du spectre de couleurs.
| Icône | Nom (Syntaxe) | Entrées | Sorties |
|---|---|---|---|
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.
| Icône | Nom (Syntaxe) | Entrées | Sorties |
|---|---|---|---|
Les couleurs du tableau ci-dessous correspondent à l’espace de couleurs HSB. Diviser la couleur en teinte, en saturation et en luminosité permet probablement de l’interpréter de façon plus intuitive : quelle couleur choisir ? Quel niveau de saturation de la couleur choisir ? Et quel niveau d'intensité de la couleur choisir ? Il s'agit respectivement de la répartition de la teinte, de la saturation et de la luminosité.
| Icône | Nom (Syntaxe) | Entrées | Sorties |
|---|---|---|---|
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.
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.
Créer une liste : fusionnez les trois couleurs dans une liste.
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.
Code Block : valeurs d’entrée (entre 0 et 1) pour convertir en 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.
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.
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.
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.
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.
PolyCurve.ByPoints : connectez la sortie Point.ByCoordinates à l’entrée points du nœud. Vous obtenez une courbe hélicoïdale.
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.
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.
Geometry.DistanceTo : connectez la sortie Curve.PointAtParameter à l’entrée. Connectez Point.ByCoordinates à l’entrée geometry.
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.
Math.RemapRange : connectez la sortie Geometry.DistanceTo à l’entrée numbers.
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.
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.
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.
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.
Sphere.ByCenterPointRadius : pour le moment, désactivez l’aperçu sur ce nœud (cliquez avec le bouton droit de la souris > Aperçu).
Math.RemapRange : ce processus devrait vous sembler familier. Connectez la sortie Geometry.DistanceTo à l’entrée numbers.
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.
Color Range : connectez la sortie Math.RemapRange à l’entrée value.
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.
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).
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.
List.Create : fusionnez les deux couleurs dans une liste. Connectez la sortie à l’entrée colors pour Color Range.
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 !
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.
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.
Surface.ByLoft : générez une surface interpolée entre la liste des courbes NURBS.
File Path : sélectionnez un fichier image à échantillonner pour les données de pixel en aval.
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.
Image.Pixels : entrez une image et indiquez une valeur d’exemple à utiliser le long des dimensions x et y de l’image.
Curseur : fournit des valeurs d’exemple pour Image.Pixels.
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
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.
Couleur ARVB (Color.ByARGB)
A,R,G,B
color
Alpha (Color.Alpha)
color
A
Rouge (Color.Red)
color
R
Vert (Color.Green)
color
G
Bleu (Color.Blue)
color
B
Composants (Color.Components)
color
A,R,G,B
Teinte (Color.Hue)
color
Teinte
Saturation (Color.Saturation)
color
Saturation
Luminosité (Color.Brightness)
color
Luminosité
If (If)
test, true, false
résultat
Formula (IF(x,y,z))
x, y, z
résultat
Code Block ((x?y:z);)
x ? y, z
résultat
