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.
Couleur ARVB (Color.ByARGB)
A,R,G,B
color
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.
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
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é.
Teinte (Color.Hue)
color
Teinte
Saturation (Color.Saturation)
color
Saturation
Luminosité (Color.Brightness)
color
Luminosité
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.
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.
