Le bloc de code est une fonction unique de Dynamo qui lie de manière dynamique un environnement de programmation visuel avec un environnement de texte. Le bloc de code a accès à tous les nœuds Dynamo et peut définir un graphique entier dans un nœud. Lisez attentivement ce chapitre, car le bloc de code est un bloc de construction fondamental de Dynamo.
Les blocs de code permettent d'aborder de manière approfondie DesignScript, le langage de programmation au coeur de Dynamo. Conçu à partir de zéro pour prendre en charge les workflows de conception exploratoires, DesignScript est un langage lisible et concis qui offre un retour immédiat aux petits éléments de code et s'adapte aux interactions complexes et importantes. DesignScript constitue également la "colonne vertébrale" du moteur qui pilote la plupart des aspects de Dynamo "sous le capot". Étant donné que la quasi-totalité des fonctionnalités que l’on trouve dans les nœuds et les interactions Dynamo ont une relation individuelle avec le langage de génération de script, il existe des possibilités uniques de se déplacer entre les interactions basées sur les nœuds et la génération de scripts de manière fluide.
Pour les débutants, les nœuds peuvent être automatiquement convertis en syntaxe de texte pour faciliter l’apprentissage de DesignScript ou simplement pour réduire la taille des sections de graphiques plus grandes. Cette opération est effectuée à l’aide d’un processus appelé « Nœud vers code », qui est présenté en détail dans la section Syntaxe DesignScript. Les utilisateurs plus expérimentés peuvent utiliser les blocs de code pour créer des combinaisons personnalisées de fonctionnalités existantes et de relations créées par l’utilisateur à l’aide de nombreux paradigmes de codage standard. Entre l'utilisation par des débutants et celle d'utilisateurs expérimentés, il existe un grand nombre de raccourcis et d'extraits de code qui pourront accélérer vos conceptions. Bien que le terme "bloc de code" soit un peu intimidant pour les utilisateurs qui ne sont pas programmeurs, ce concept est à la fois facile à utiliser et robuste. Un débutant peut utiliser le bloc de code efficacement avec un minimum de codage, et un utilisateur avancé peut définir des définitions de script à utiliser ailleurs dans une définition Dynamo.
Pour faire court, les blocs de code sont une interface de génération de script de texte au sein d’un environnement de script visuel. Ils peuvent être utilisés en tant que nombres, chaînes, formules et autres types de données. Le bloc de code est conçu pour Dynamo, de sorte que l'on peut définir des variables arbitraires dans le bloc de code, et ces variables sont automatiquement ajoutées aux entrées du nœud :
Avec les blocs de code, l’utilisateur peut décider de la méthode de spécification des entrées de manière flexible. Voici plusieurs méthodes pour créer un point de base avec les coordonnées (10, 5, 0) :
Au fur et à mesure que vous découvrez les fonctions disponibles dans la bibliothèque, vous pouvez même constater que saisir « Point.ByCoordinates » est plus rapide que d’effectuer une recherche dans la bibliothèque et trouver le nœud approprié. Lorsque vous tapez « Point » par exemple, Dynamo affiche une liste des fonctions possibles à appliquer à un point. Cela rend le script plus intuitif et aide à apprendre comment appliquer les fonctions dans Dynamo.
Le bloc de code se trouve dans Core > Entrée > Actions > Bloc de code. Pour aller plus vite, il suffit de cliquer deux fois sur la zone de dessin pour afficher le bloc de code. Ce nœud est si souvent utilisé qu’il dispose de privilèges de double-clic.
Les blocs de code sont également flexibles en ce qui concerne les types de données. L'utilisateur peut rapidement définir des nombres, des chaînes et des formules, et le bloc de code fournit la sortie souhaitée.
Dans l'image ci-dessous, vous pouvez voir que la manière "classique" de faire les choses est un peu longue : l'utilisateur recherche le nœud voulu dans l'interface, ajoute le nœud à la zone de dessin, puis saisit les données. Avec le bloc de code, l'utilisateur peut double-cliquer sur la zone de dessin pour afficher le nœud et entrer le type de données correct avec la syntaxe de base.
Les nœuds number, string et formula sont trois exemples de nœuds Dynamo qui sont probablement obsolètes par rapport au bloc de code.
« La vieille école »
Nœuds Code Block
Les fonctions peuvent être créées dans un bloc de code et rappelées ailleurs dans une définition Dynamo. Cela permet de créer un autre calque de contrôle dans un fichier paramétrique et de l'afficher en tant que version de texte d'un nœud personnalisé. Dans ce cas, le bloc de code "parent" est facilement accessible et peut être situé n'importe où sur le graphique. Aucun fil n'est nécessaire.
La première ligne comporte le mot clé "def", puis le nom de la fonction, puis les noms des entrées entre parenthèses. Les contreventements définissent le corps de la fonction et renvoient une valeur avec "return =". Les nœuds Code Block qui définissent une fonction ne disposent pas de ports d’entrée ou de sortie, car ils sont appelés à partir d’autres nœuds Code Block.
Appelez la fonction avec un autre noeud Code Block dans le même fichier en donnant le nom et le même nombre d'arguments. Cela fonctionne comme les nœuds prêts à l’emploi de votre bibliothèque.
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 cet exercice, vous allez créer une définition générique permettant d'obtenir des sphères à partir d'une liste de points d'entrée. Le rayon de ces sphères est défini par la propriété Z de chaque point.
Commencez par une plage de dix valeurs allant de 0 à 100. Connectez-les à un nœud Point.ByCoordinates afin de créer une ligne diagonale.
Créez un nœud Code Block et introduisez votre définition.
Utilisez les lignes de code suivantes :
Le terme inputPt est le nom donné pour représenter les points qui contrôlent la fonction. Pour l’instant, la fonction ne fait rien, mais vous allez la construire dans les étapes à venir.
L’ajout de la fonction Code Block permet de placer un commentaire et une variable sphereRadius qui interroge la position Z de chaque point. N’oubliez pas que inputPt.Z n’a pas besoin de parenthèses comme méthode. Il s’agit d’une requête des propriétés d’un élément existant, donc aucune entrée n’est nécessaire :
Rappelez-vous la fonction créée dans un autre nœud Code Block. Si vous double-cliquez sur la zone de dessin pour créer un Code Block et que vous tapez sphereB, Dynamo suggère la fonction sphereByZ que vous avez définie. Votre fonction a été ajoutée à la bibliothèque Intellisense. Bien.
Vous allez maintenant appeler la fonction et créer une variable appelée Pt afin de connecter les points créés dans les étapes précédentes :
La sortie ne contient que des valeurs nulles. Pourquoi ? Lorsque vous avez défini la fonction, vous avez calculé la variable sphereRadius, mais vous n’avez pas défini ce que la fonction doit renvoyer en tant que sortie. Vous pourrez résoudre ce problème à l’étape suivante.
Une étape importante consiste à définir la sortie de la fonction en ajoutant la ligne
return = sphereRadius;à la fonction sphereByZ.La sortie du nœud Code Block indique désormais les coordonnées Z de chaque point.
Modifiez la fonction Parent pour créer des sphères réelles.
Commencez par définir une sphère avec la ligne de code suivante :
sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);Ensuite, modifiez la valeur renvoyée pour la définir comme sphere au lieu de sphereRadius :
return = sphere;Vous obtenez ainsi des sphères géantes dans l’aperçu de Dynamo.
1. Pour modifier la taille de ces sphères, mettez à jour la valeur sphereRadius en ajoutant un séparateur :
sphereRadius = inputPt.Z/20;Les sphères distinctes sont maintenant visibles et la relation entre le rayon et la valeur Z devient plus claire.
Sur le nœud Point.ByCoordinates, remplacez la liaison Liste la plus courte par Produit cartésien afin de créer une grille de points. La fonction sphereByZ reste pleinement effective, de sorte que tous les points créent des sphères avec des rayons fondés sur des valeurs Z.
Pour tâter le terrain, connectez simplement la liste de nombres d’origine à l’entrée X de Point.ByCoordinates. Vous obtenez ainsi un cube de sphères.
Remarque : si le calcul sur votre ordinateur prend beaucoup de temps, essayez de remplacer nº 10 par un autre élément, nº 5 par exemple.
N’oubliez pas que la fonction sphereByZ créée est générique. Vous pouvez donc rappeler l’hélice d’une leçon précédente et lui appliquer la fonction.
Dernière étape : déterminez le rapport des rayons avec un paramètre défini par l’utilisateur. Pour ce faire, vous devez créer une entrée pour la fonction et remplacer également le séparateur 20 par un paramètre.
Remplacez la définition de sphereByZ par :
Mettez à jour les nœuds Code Block enfant en ajoutant une variable ratio à l’entrée :
sphereByZ(Pt,ratio);Connectez un curseur à la nouvelle entrée du nœud Code Block et modifiez la taille des rayons en fonction du rapport des rayons.
Il existe quelques méthodes de base pour raccourcir le bloc de code qui simplifient énormément la gestion des données. Vous allez découvrir les concepts de base ci-dessous et comprendre comment ce raccourci peut être utilisé à la fois pour créer et interroger des données.
La méthode de définition des intervalles et des séquences peut être réduite au raccourci de base. Utilisez l'image ci-dessous comme guide de la syntaxe ".." pour définir une liste de données numériques avec un bloc de code. Après avoir obtenu l’arrêt de cette notation, la création de données numériques est un processus vraiment efficace :
Dans cet exemple, un intervalle de nombres est remplacé par la syntaxe Code Block de base définissant
beginning..end..step-size;. Voici le résultat représenté numériquement :0..10..1;Notez que la syntaxe
0..10..1;est équivalente à0..10;. Une taille de pas de 1 est la valeur par défaut de la notation abrégée. Par conséquent,0..10;donne une séquence de 0 à 10 avec une taille de pas de 1.L’exemple du nœud Sequence est similaire, sauf que vous devez utiliser « # » pour indiquer que vous voulez 15 valeurs dans la liste, plutôt qu’une liste qui atteint 15. Dans ce cas, vous définissez :
beginning..#ofSteps..step-size:. La syntaxe réelle de la séquence est0..#15..2.Placez « # » de l’étape précédente dans la partie « taille de pas » de la syntaxe. À présent, vous avez un intervalle de nombres qui s’étend du « début » à la « fin » et la notation « taille de pas » distribue uniformément un certain nombre de valeurs entre les deux valeurs :
beginning..end..#ofSteps.
La création d'intervalles avancés vous permet de travailler avec une liste de listes en toute simplicité. Dans les exemples ci-dessous, découvrez comment isoler une variable de la notation d’intervalle principale et créer une autre série de cette liste.
1. En créant des intervalles imbriqués, comparez la notation avec « # » et la notation sans. La même logique s’applique aux intervalles de base, à la différence qu’elle devient un peu plus complexe.
2. Vous pouvez définir un sous-intervalle à n’importe quel endroit de l’intervalle principal, et avoir aussi deux sous-intervalles.
3. En contrôlant la valeur de « fin » dans un intervalle, vous pouvez créer davantage d’intervalles de longueurs différentes.
À des fins d’exercice de logique, comparez les deux raccourcis ci-dessus et analysez comment les sous-intervalles et la notation # déterminent la sortie résultante.
Outre la création de listes avec un raccourci, vous pouvez également créer des listes à la volée. Ces listes peuvent contenir une large gamme de types d’éléments et peuvent également être interrogées (rappelez-vous que les listes sont des objets en eux-mêmes). Pour résumer, un nœud Code Block vous permet de créer des listes et d’interroger des éléments d’une liste avec des crochets (accolades) :
1. Créez rapidement des listes avec des chaînes et interrogez-les à l’aide de l’index d’éléments.
2. Créez des listes avec des variables et interrogez-les à l’aide de la notation du raccourci d’intervalle.
La gestion de listes imbriquées est un processus similaire. Veillez à l’ordre de la liste et n’oubliez pas d’utiliser plusieurs jeux de crochets :
1. Définissez une liste de listes.
2. Interrogez une liste avec une notation de crochet simple.
3. Interrogez un élément avec une notation entre crochets.
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 cet exercice, vous allez perfectionner vos nouvelles compétences en concevant une super surface en coquille d'oeuf définie par des intervalles et des formules. Au cours de cet exercice, vous découvrirez comment utiliser le bloc de code et les nœuds Dynamo existants en tandem : le bloc de code est utilisé pour le gros volume de données, tandis que les nœuds Dynamo sont visuellement disposés pour la lisibilité de la définition.
Commencez par créer une surface en connectant les nœuds ci-dessus. Au lieu d’utiliser un nœud Number pour définir la largeur et la longueur, cliquez deux fois sur la zone de dessin et tapez 100; dans un nœud Code Block.
Définissez un intervalle compris entre 0 et 1 et 50 divisions en tapant
0..1..#50dans un nœud Code Block.Connectez l’intervalle à Surface.PointAtParameter, qui prend les valeurs u et v entre 0 et 1 sur la surface. Pensez à définir la liaison sur Produit cartésien en cliquant avec le bouton droit de la souris sur le nœud Surface.PointAtParameter.
Dans cette étape, vous allez utiliser votre première fonction pour déplacer la grille de points vers le haut sur l’axe Z. Cette grille pilotera une surface générée reposant sur la fonction sous-jacente. Ajoutez de nouveaux nœuds comme illustrés dans l’image ci-dessous.
Au lieu d’utiliser un nœud Formula, utilisez un nœud Code Block avec la ligne :
(0..Math.Sin(x*360)..#50)*5;. Pour décomposer rapidement cet intervalle, définissez un intervalle contenant une formule. Cette formule est la fonction Sinus. La fonction Sinus reçoit les entrées de degrés dans Dynamo. Ainsi, pour obtenir une onde sinusoïdale complète, multipliez les valeurs x (valeur d'entrée de l'intervalle de 0 à 1) par 360. Ensuite, utilisez le même nombre de divisions que les points de grille de contrôle pour chaque ligne. Définissez donc 50 sous-divisions avec #50. Enfin, le multiplicateur de 5 augmente simplement l’amplitude de la translation de sorte que l’effet soit visible dans l’aperçu Dynamo.
Même si le nœud Code Block précédent fonctionnait correctement, il n’était pas entièrement paramétrique. Étant donné que vous voulez piloter ses paramètres dynamiquement, vous allez remplacer la ligne de l’étape précédente par
(0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;. Cela vous donne la possibilité de définir ces valeurs en fonction des entrées.
La modification des curseurs (de 0 à 10) permet d’obtenir des résultats intéressants.
Lorsque vous effectuez une transposition sur l’intervalle de nombres, vous inversez la direction de l’onde du rideau :
transposeList = List.Transpose(sineList);.
Lorsque vous ajoutez sineList et tranposeLit, vous obtenez une surface en coquille d’œuf déformée :
eggShellList = sineList+transposeList;.
Modifiez les valeurs de curseurs spécifiées ci-dessous pour retrouver un algorithme « paisible ».
Enfin, recherchez des parties isolées des données avec le nœud Code Block. Pour régénérer la surface avec un intervalle de points spécifique, ajoutez le bloc de code ci-dessus entre le nœud Geometry.Translate et le nœud NurbsSurface.ByPoints. Cette ligne contient la ligne de texte : sineStrips[0..15..1];. Cela permet de sélectionner les 16 premières lignes de points (sur 50). Recréez la surface. Vous pouvez voir que vous avez généré une partie isolée de la grille de points.
Dans la dernière étape, pour rendre ce nœud Code Block encore plus paramétrique, pilotez la requête en utilisant un curseur compris entre 0 et 1. Pour ce faire, utilisez la ligne de code suivante :
sineStrips[0..((List.Count(sineStrips)-1)*u)];. Cela peut sembler déroutant, mais la ligne de code vous donne un moyen rapide de mettre à l'échelle la longueur de la liste en un multiplicateur entre 0 et 1.
Une valeur de 0.53 sur le curseur permet de créer une surface juste au-delà du milieu de la grille.
Comme prévu, un curseur de 1 crée une surface à partir de la grille complète de points.
En examinant le graphique visuel, vous pouvez mettre en surbrillance les nœuds Code Block et voir chacune de leurs fonctions.
1. Le premier nœud Code Block remplace le nœud Number.
2. Le deuxième nœud Code Block remplace le nœud Number Range.
3. Le troisième nœud Code Block remplace le nœud Formula (ainsi que List.Transpose, List.Count et Number Range).
4. Le quatrième nœud Code Block interroge une liste de listes, remplaçant ainsi le nœud List.GetItemAtIndex.
Vous avez peut-être remarqué que les noms des nœuds dans Dynamo ont un point commun : chaque nœud utilise la syntaxe « . » sans espaces. Cela est dû au fait que le texte situé en haut de chaque nœud représente la syntaxe réelle pour l’écriture de scripts et que la « . » (ou notation par points) sépare un élément des méthodes que nous pouvons appeler. Cette syntaxe permet de convertir facilement les scripts visuels en scripts basés sur du texte.
Prenons une pomme paramétrique comme analogie générale de la notation par points : comment pouvez-vous la traiter dans Dynamo ? Voici quelques méthodes que vous allez exécuter sur la pomme avant de la manger. (Remarque : il ne s’agit pas de méthodes Dynamo réelles) :
| Visible de tous | Notation par points | Sortie |
|---|---|---|
Je ne sais pas ce que vous en pensez, mais à en juger par les sorties du tableau ci-dessus, cette pomme est très appétissante. Je pense que je vais la manger : Apple.eat().
En ayant à l’esprit l’analogie de la pomme, examinez Point.ByCoordinates et découvrez comment créer un point à l’aide du nœud Code Block.
La syntaxe du nœud Code Block Point.ByCoordinates(0,10); donne le même résultat qu’un nœud Point.ByCoordinates dans Dynamo, sauf que vous pouvez créer un point à l’aide d’un nœud. Cette opération est plus efficace que la connexion d’un nœud distinct à « X » et « Y ».
L’utilisation de Point.ByCoordinates dans le nœud Code Block vous permet d’indiquer les entrées dans le même ordre que le nœud prêt à l’emploi (X,Y).
Vous pouvez appeler n’importe quel nœud standard dans la bibliothèque par le biais d’un nœud Code Block tant que le nœud n’est pas un nœud d’interface utilisateur spécial : les nœuds dotés d’une fonction d’interface utilisateur spéciale. Par exemple, vous pouvez appeler Circle.ByCenterPointRadius, mais il n’est pas logique d’appeler un nœud Watch 3D.
Il existe généralement trois types de nœuds standard (la plupart des nœuds de votre bibliothèque). La bibliothèque est organisée en fonction de ces catégories. Les méthodes ou les nœuds de ces trois types sont traités différemment lorsqu’ils sont appelés dans un nœud Code Block.
Create : permet de créer (ou de construire) un élément
Action : permet d’effectuer une action sur un élément
Query : permet d’obtenir une propriété d’un élément existant
La catégorie "Create" permet de créer une géométrie à partir de zéro. Vous entrez des valeurs de gauche à droite dans le bloc de code. Ces entrées apparaissent dans le même ordre que les entrées du nœud de haut en bas.
En comparant le nœud Line.ByStartPointEndPoint et la syntaxe correspondante dans le bloc de code, vous obtenez les mêmes résultats.
Une action est une opération effectuée sur un objet de ce type. Pour appliquer une action à un élément, Dynamo utilise la notation par points, commune à de nombreux langages de codage. Une fois que vous avez l’élément, tapez un point, puis le nom de l’action. L’entrée de la méthode de type action est mise entre parenthèses tout comme celle des méthodes de type création. Cependant, il n’est pas nécessaire de spécifier la première entrée que vous voyez sur le nœud correspondant. Au lieu de cela, vous devez indiquer l’élément sur lequel vous effectuez l’action :
Étant donné que le nœud Point.Add est un nœud de type action, la syntaxe fonctionne un peu différemment.
Les entrées sont (1) le point et (2) le vecteur à ajouter. Dans un nœud Code Block, le point (l’élément) est nommé « pt ». Pour ajouter un vecteur nommé *“vec” *to “pt”, écrivez pt.Add(vec) ou : élément, point, action. L’action Ajouter ne possède qu’une seule entrée, ou toutes les entrées du nœud Point.Add sauf la première. La première entrée du nœud Point.Add est le point lui-même.
Les méthodes de type Query permettent d’obtenir une propriété d’un objet. Puisque l’objet lui-même est l’entrée, vous n’avez pas besoin de spécifier d’entrées. Aucune parenthèse n’est requise.
Avec des nœuds, la combinaison est légèrement différente de celle avec le bloc de code. Avec les nœuds, l’utilisateur clique avec le bouton droit de la souris sur le nœud et sélectionne l’option de combinaison à effectuer. Avec Code Block, l’utilisateur dispose d’un contrôle bien plus précis sur la structure des données. La méthode de raccourci du bloc de code utilise des guides de réplication pour définir la manière dont plusieurs listes unidimensionnelles sont associées. Les nombres mis entre crochets angulaires « <> » définissent la hiérarchie de la liste imbriquée obtenue : <1>,<2>,<3>, etc.
Dans cet exemple, un raccourci est utilisé pour définir deux intervalles (vous trouverez plus d’informations sur le raccourci dans la section suivante de ce chapitre). En résumé,
0..1;équivaut à{0,1}et-3..-7à{-3,-4,-5,-6,-7}. Le résultat vous donne des listes de 2 valeurs X et 5 valeurs Y. Si vous n’utilisez pas de guides de réplication avec ces listes incohérentes, vous obtenez une liste de deux points, correspondant à la longueur de la liste la plus courte. Les guides de réplication vous permettent de trouver toutes les liaisons possibles de 2 et 5 coordonnées (ou, un Produit cartésien).La syntaxe Point.ByCoordinates
(x_vals<1>,y_vals<2>);vous permet d’obtenir deux listes contenant chacune cinq éléments.La syntaxe Point.ByCoordinates
(x_vals<2>,y_vals<1>);vous permet d’obtenir cinq listes contenant chacune deux éléments.
Avec cette notation, vous pouvez également indiquer le type de liste dominant : 2 listes de 5 éléments ou 5 listes de 2 éléments. Dans cet exemple, la modification de l’ordre des guides de réplication crée une liste de lignes de points ou une liste de colonnes de points dans une grille.
Bien que les méthodes de bloc de code susmentionnées puissent prendre en charge certains éléments, Dynamo inclut une fonctionnalité appelée "Nœud vers code" qui facilite le processus. Pour utiliser cette fonction, sélectionnez un réseau de nœuds dans votre graphique Dynamo, cliquez avec le bouton droit de la souris sur la zone de dessin et sélectionnez "Nœud vers code". Dynamo convertit ces nœuds en bloc de code, avec toutes les entrées et sorties ! Non seulement cet outil est idéal pour découvrir les blocs de code, mais il vous permet également de travailler avec un graphique Dynamo paramétrique et plus efficace. Ne manquez pas la fin de l’exercice ci-dessous : vous découvrirez l’utilisation de « Nœud vers code ».
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 afficher la puissance du bloc de code, vous allez convertir une définition de champ d’attraction existante en formulaire de bloc de code. L’utilisation d’une définition existante montre comment le bloc de code est lié aux scripts visuels et est utile pour découvrir la syntaxe DesignScript.
Commencez par recréer la définition dans l’image ci-dessus (ou en ouvrant le fichier d’exemple).
Notez que la liaison sur Point.ByCoordinates a été définie sur Produit cartésien.
Chaque point d’une grille est déplacé vers le haut dans la direction Z en fonction de sa distance par rapport au point de référence.
Une surface est recréée et épaissie, créant ainsi un renflement dans la géométrie par rapport à la distance par rapport au point de référence.
Commencez par définir le point de référence : Point.ByCoordinates
(x,y,0);. Utilisez la même syntaxe Point.ByCoordinates que celle spécifiée dans la partie supérieure du nœud du point de référence.Les variables x et y sont insérées dans le nœud Code Block afin que vous puissiez les mettre à jour de façon dynamique avec des curseurs.
Ajoutez des curseurs aux entrées du nœud Code Block qui vont de -50 à 50. Vous pouvez ainsi étendre la grille Dynamo par défaut.
Dans la deuxième ligne du nœud Code Block, définissez un raccourci pour remplacer le nœud Number Sequence :
coordsXY = (-50..50..#11);. Vous en saurez plus dans la section suivante. Pour le moment, notez que ce raccourci est équivalent au nœud Number Sequence dans le script visuel.
Vous devez désormais créer une grille de points à partir de la séquence coordsXY. Pour ce faire, utilisez la syntaxe Point.ByCoordinates, et lancez un Produit cartésien de la liste de la même manière que dans le script visuel. Pour ce faire, tapez la ligne :
gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0);. Les crochets angulaires indiquent la référence du produit vectoriel.Le nœud Watch3D présente une grille de points sur la grille Dynamo.
Difficulté : déplacer la grille de points vers le haut en fonction de leur distance par rapport au point de référence. Tout d’abord, appelez ce nouvel ensemble de points transPts. Étant donné qu’une conversion est une action sur un élément existant, au lieu d’utiliser
Geometry.Translate..., utilisezgridPts.Translate.Le nœud réel sur la zone de dessin indique trois entrées. La géométrie à convertir est déjà déclarée, car vous effectuez l’action sur cet élément (avec gridPts.Translate). Les deux entrées restantes seront insérées entre les parenthèses de la fonction : direction et distance.
La direction est assez simple : utilisez un nœud
Vector.ZAxis()pour vous déplacer verticalement.La distance entre le point de référence et chaque point de grille doit encore être calculée. Pour ce faire, effectuez une action au point de référence de la même manière :
refPt.DistanceTo(gridPts).La dernière ligne de code donne les points convertis :
transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));
Vous disposez à présent d’une grille de points avec la structure de données appropriée pour créer une surface NURBS. Construisez la surface en utilisant
srf = NurbsSurface.ByControlPoints(transPts);.
Enfin, pour ajouter de la profondeur à la surface, construisez un solide en utilisant
solid = srf.Thicken(5);. Dans ce cas, la surface a été épaissie de 5 unités dans le code, mais vous pouvez toujours déclarer cela comme variable (en l’appelant épaisseur, par exemple), puis contrôler cette valeur avec un curseur.
La fonctionnalité "Nœud vers code" permet d'automatiser d'un simple clic l'ensemble de l'exercice que vous venez de réaliser. Non seulement cette fonctionnalité est très utile pour créer des définitions personnalisées et des blocs de code réutilisables, mais elle est également un outil très pratique pour apprendre à utiliser des scripts dans Dynamo :
Commencez par le script visuel existant de l’étape 1 de l’exercice. Sélectionnez tous les nœuds, cliquez avec le bouton droit de la souris sur la zone de dessin et sélectionnez « Nœud vers code ». C’est aussi simple que ça.
Dynamo a automatisé une version texte du graphique visuel, de la combinaison, etc. Testez cette opération sur vos scripts visuels et libérez la puissance du bloc de code !
Type de données
Dynamo standard
Bloc de code équivalent
Nombres
Chaînes
Séquences
Intervalles
Obtenir l’élément au niveau de l’index
Création d’une liste
Concaténer des chaînes
Instructions conditionnelles
Nœud(s)
Bloc de code équivalent
Remarque
Tout opérateur (+, &&, >=, Not, etc.)
+, &&, >=, !, etc.
Notez que « Not » devient « ! », mais que le nœud est appelé « Not » pour faire la distinction avec « Factorial »
Valeur booléenne True
true;
Minuscules
Valeur booléenne False
false;
Minuscules
De quelle couleur est la pomme ?
Apple.color
rouge
La pomme est-elle mûre ?
Apple.isRipe
true
Combien la pomme pèse-t-elle ?
Apple.weight
170 g
D’où vient la pomme ?
Apple.parent
arborescence
Qu’est-ce que la pomme crée ?
Apple.children
graines
Cette pomme est-elle produite localement ?
Apple.distanceFromOrchard
100 km
