Dynamo est une excellente façon de commencer à coder pour le monde AEC. Pour débuter en matière de codage, consultez les sections suivantes :

• Nœuds Code Block et DesignScript

• Géométrie avec DesignScript

• Python

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.

Parent

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.

/*This is a multi-line comment,
which continues for
multiple lines*/
def FunctionName(in1,in2)
{
//This is a comment
sum = in1+in2;
return sum;
};

Enfants

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.

FunctionName(in1,in2);

Exercice : Sphère par Z

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.

1. Utilisez les lignes de code suivantes :

   Copy

   def sphereByZ(inputPt)
   {
   
   };

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.

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

Copy

def sphereByZ(inputPt,radiusRatio)
{
//get Z Value, ise ot to drive radius of sphere
sphereRadius=inputPt.Z;
};

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

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

   Copy

   sphereByZ(Pt)

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

1. Une étape importante consiste à définir la sortie de la fonction en ajoutant la ligne return = sphereRadius; à la fonction sphereByZ.

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

1. Commencez par définir une sphère avec la ligne de code suivante : sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);

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

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

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

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

1. Remplacez la définition de sphereByZ par :

   Copy

   def sphereByZ(inputPt,radiusRatio)
   {
   //get Z Value, use it to drive radius of sphere
   sphereRadius=inputPt.Z/radiusRatio;
   //Define Sphere Geometry
   sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
   //Define output for function
   return sphere;
   };

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

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) :

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

Notation par points dans le bloc de code

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

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

Appel de nœuds - Création, Actions, Requête

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.

1. Create : permet de créer (ou de construire) un élément

2. Action : permet d’effectuer une action sur un élément

3. Query : permet d’obtenir une propriété d’un élément existant

Créer

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.

Action

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 :

1. Étant donné que le nœud Point.Add est un nœud de type action, la syntaxe fonctionne un peu différemment.

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

Query

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.

Qu’en est-il de la combinaison ?

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.

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

2. La syntaxe Point.ByCoordinates(x_vals<1>,y_vals<2>); vous permet d’obtenir deux listes contenant chacune cinq éléments.

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

Nœud vers code

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

Exercice : attraction de surface

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

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

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

1. Notez que la liaison sur Point.ByCoordinates a été définie sur Produit cartésien.

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

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

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

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

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

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

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

2. Le nœud Watch3D présente une grille de points sur la grille Dynamo.

1. 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..., utilisez gridPts.Translate.

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

3. La direction est assez simple : utilisez un nœud Vector.ZAxis() pour vous déplacer verticalement.

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

5. La dernière ligne de code donne les points convertis : transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));

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

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

Simplifier le graphique avec "Nœud vers code"

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 :

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

Système de coordonnées

Bien que Dynamo soit capable de créer diverses formes géométriques complexes, les primitives géométriques simples constituent la base de toute conception informatique. Elles sont soit directement exprimées dans la forme finale de la conception, soit utilisées comme armature à partir de laquelle une géométrie plus complexe est générée.

Bien qu'il ne s'agisse pas d'une partie de la géométrie à strictement parler, le CoordinateSystem est un outil important pour la construction d'une géométrie. Un objet CoordinateSystem conserve une trace des transformations de position et géométriques, telles que la rotation, la transvection et la mise à l'échelle.

La création d’un CoordinateSystem centré sur un point avec x = 0, y = 0, z = 0, sans rotation ni transformation de transvection ni de mise à l’échelle, requiert simplement l’appel du constructeur Identity :

// create a CoordinateSystem at x = 0, y = 0, z = 0,
// no rotations, scaling, or sheering transformations

cs = CoordinateSystem.Identity();

Les CoordinateSystems avec transformations géométriques dépassent la portée de ce chapitre, bien qu’un autre constructeur vous permette de créer un système de coordonnées à un point spécifique, à savoir CoordinateSystem.ByOriginVectors :

// create a CoordinateSystem at a specific location,
// no rotations, scaling, or sheering transformations
x_pos = 3.6;
y_pos = 9.4;
z_pos = 13.0;

origin = Point.ByCoordinates(x_pos, y_pos, z_pos);
identity = CoordinateSystem.Identity();

cs = CoordinateSystem.ByOriginVectors(origin,
    identity.XAxis, identity.YAxis, identity.ZAxis);

Point

La primitive géométrique la plus simple est un point, représentant un emplacement à zéro dimension dans un espace tridimensionnel. Comme indiqué précédemment, il existe plusieurs méthodes pour créer un point dans un système de coordonnées particulier : Point.ByCoordinates crée un point avec les coordonnées x, y et z spécifiées ; Point.ByCartesianCoordinates crée un point avec les coordonnées x, y et z dans un système de coordonnées spécifique ; Point.ByCylindricalCoordinates crée un point se trouvant sur un cylindre, avec rayon, angle de rotation et hauteur ; et Point.BySphericalCoordinates crée un point situé sur une sphère avec un rayon et deux angles de rotation.

Cet exemple montre des points créés sur différents systèmes de coordonnées :

// create a point with x, y, and z coordinates
x_pos = 1;
y_pos = 2;
z_pos = 3;

pCoord = Point.ByCoordinates(x_pos, y_pos, z_pos);

// create a point in a specific coordinate system
cs = CoordinateSystem.Identity();
pCoordSystem = Point.ByCartesianCoordinates(cs, x_pos,
    y_pos, z_pos);

// create a point on a cylinder with the following
// radius and height
radius = 5;
height = 15;
theta = 75.5;

pCyl = Point.ByCylindricalCoordinates(cs, radius, theta,
    height);

// create a point on a sphere with radius and two angles

phi = 120.3;

pSphere = Point.BySphericalCoordinates(cs, radius,
    theta, phi);

Ligne

La primitive Dynamo dimensionnelle supérieure suivante est un segment de ligne, représentant un nombre infini de points entre deux extrémités. Les lignes peuvent être créées en spécifiant explicitement les deux points de limite avec le constructeur Line.ByStartPointEndPoint, ou en spécifiant un point de départ, une direction et une longueur dans cette direction, Line.ByStartPointDirectionLength.

p1 = Point.ByCoordinates(-2, -5, -10);
p2 = Point.ByCoordinates(6, 8, 10);

// a line segment between two points
l2pts = Line.ByStartPointEndPoint(p1, p2);

// a line segment at p1 in direction 1, 1, 1 with
// length 10
lDir = Line.ByStartPointDirectionLength(p1,
    Vector.ByCoordinates(1, 1, 1), 10);

Primitives 3D : cuboïde, cône, cylindre, sphère, etc.

Dynamo comporte des objets représentant les principaux types de primitives géométriques de base en trois dimensions : des cuboïdes créés avec Cuboid.ByLengths ; des cônes créés avec Cone.ByPointsRadius et Cone.ByPointsRadii ; des cylindres créés avec Cylinder.ByRadiusHeight ; et des sphères créées avec Sphere.ByCenterPointRadius.

// create a cuboid with specified lengths
cs = CoordinateSystem.Identity();

cub = Cuboid.ByLengths(cs, 5, 15, 2);

// create several cones
p1 = Point.ByCoordinates(0, 0, 10);
p2 = Point.ByCoordinates(0, 0, 20);
p3 = Point.ByCoordinates(0, 0, 30);

cone1 = Cone.ByPointsRadii(p1, p2, 10, 6);
cone2 = Cone.ByPointsRadii(p2, p3, 6, 0);

// make a cylinder
cylCS = cs.Translate(10, 0, 0);

cyl = Cylinder.ByRadiusHeight(cylCS, 3, 10);

// make a sphere
centerP = Point.ByCoordinates(-10, -10, 0);

sph = Sphere.ByCenterPointRadius(centerP, 5);

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.

Bloc de code : présentation générale

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.

Création de nœuds de bloc de code

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.

Numéros, chaînes et formules

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.

1. « La vieille école »

2. Nœuds Code Block

Point

L'objet géométrique le plus simple de la bibliothèque de géométries standard Dynamo est un point. L'ensemble de la géométrie est créé à l'aide de fonctions spéciales appelées constructeurs, qui renvoient chacune une nouvelle occurrence de ce type de géométrie particulier. Dans Dynamo, les constructeurs commencent par le nom du type d’objet, ici Point, suivi de la méthode de construction. Pour créer un point tridimensionnel spécifié par les coordonnées cartésiennes X, Y et Z, utilisez le constructeur ByCoordinates :

// create a point with the following x, y, and z
// coordinates:
x = 10;
y = 2.5;
z = -6;

p = Point.ByCoordinates(x, y, z);

Les constructeurs dans Dynamo sont généralement désignés par le préfixe « By » et l’appel de ces fonctions renvoie un nouvel objet de ce type. L’objet créé est stocké dans la variable nommée, à gauche du signe égal.

La plupart des objets possèdent plusieurs constructeurs différents. Vous pouvez utiliser le constructeur BySphericalCoordinates pour créer un point se trouvant sur une sphère, spécifié par le rayon de la sphère, un premier angle de rotation et un second angle de rotation (spécifié en degrés) :

// create a point on a sphere with the following radius,
// theta, and phi rotation angles (specified in degrees)
radius = 5;
theta = 75.5;
phi = 120.3;
cs = CoordinateSystem.Identity();

p = Point.BySphericalCoordinates(cs, radius, theta,
    phi);

Du point à la ligne

Les points peuvent être utilisés pour construire une géométrie dimensionnelle plus importante, telle que des lignes. Vous pouvez utiliser le constructeur ByStartPointEndPoint pour créer un objet Line entre deux points :

// create two points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

// construct a line between p1 and p2
l = Line.ByStartPointEndPoint(p1, p2);

De la ligne à la surface

De même, les lignes peuvent être utilisées pour créer une géométrie de surface dimensionnelle plus importante, par exemple à l’aide du constructeur Loft, qui prend une série de lignes ou de courbes et interpole une surface entre elles.

// create points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

p5 = Point.ByCoordinates(9, -10, -2);
p6 = Point.ByCoordinates(-11, -12, -4);

// create lines:
l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);
l3 = Line.ByStartPointEndPoint(p5, p6);

// loft between cross section lines:
surf = Surface.ByLoft([l1, l2, l3]);

De la surface au solide

Les surfaces peuvent également être utilisées pour créer une géométrie de solide dimensionnelle plus importante, par exemple en épaississant la surface d'une distance spécifiée. De nombreux objets possèdent des fonctions associées, appelées méthodes, permettant au programmeur d’exécuter des commandes sur cet objet particulier. Les méthodes communes à tous les éléments de géométrie incluent Translate et Rotate, qui, respectivement, convertissent (déplacent) et font pivoter la géométrie d’une valeur spécifiée. Les surfaces ont une méthode Thicken, qui requiert une entrée unique, un nombre spécifiant la nouvelle épaisseur de la surface.

p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft([l1, l2]);

// true indicates to thicken both sides of the Surface:
solid = surf.Thicken(4.75, true);

Intersecter

Les commandes Intersection permettent d’extraire une géométrie dimensionnelle inférieure à partir d’objets dimensionnels plus élevés. La géométrie dimensionnelle inférieure extraite peut constituer la base d’une géométrie dimensionnelle plus élevée, dans un processus cyclique de création, d’extraction et de recréation géométriques. Dans cet exemple, vous utilisez le solide généré pour créer une surface et la surface pour créer une courbe.

p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft([l1, l2]);

solid = surf.Thicken(4.75, true);

p = Plane.ByOriginNormal(Point.ByCoordinates(2, 0, 0),
    Vector.ByCoordinates(1, 1, 1));

int_surf = solid.Intersect(p);

int_line = int_surf.Intersect(Plane.ByOriginNormal(
    Point.ByCoordinates(0, 0, 0),
    Vector.ByCoordinates(1, 0, 0)));

Il existe deux manières fondamentales de créer des courbes de forme libre dans Dynamo. Vous pouvez spécifier un ensemble de points et faire en sorte que Dynamo interpole une courbe lisse entre eux. Une méthode plus accessible consiste à spécifier les points de contrôle sous-jacents d'une courbe d'un certain degré. Les courbes interpolées sont utiles lorsqu'un concepteur sait exactement quelle forme une ligne doit prendre, ou si la conception comporte des contraintes spécifiques concernant les endroits où la courbe peut et ne peut pas passer. Les courbes spécifiées via des points de contrôle correspondent en substance à une série de segments de lignes droites qu'un algorithme lisse pour obtenir une forme de courbe finale. La définition d'une courbe par le biais de points de contrôle peut s'avérer utile pour explorer des formes de courbes avec différents degrés de lissage ou lorsqu'une continuité lisse est requise entre les segments de courbe.

Courbe interpolée

Pour créer une courbe interpolée, il suffit de transférer un ensemble de points à la méthode NurbsCurve.ByPoints.

num_pts = 6;

s = Math.Sin(0..360..#num_pts) * 4;

pts = Point.ByCoordinates(1..30..#num_pts, s, 0);

int_curve = NurbsCurve.ByPoints(pts);

La courbe générée coupe chacun des points d’entrée, en commençant et en finissant respectivement au premier et au dernier point de l’ensemble. Un paramètre périodique facultatif peut être utilisé pour créer une courbe périodique fermée. Dynamo remplira automatiquement le segment manquant, de sorte qu’un point d’arrivée en double (identique au point de départ) n’est pas nécessaire.

pts = Point.ByCoordinates(Math.Cos(0..350..#10),
    Math.Sin(0..350..#10), 0);

// create an closed curve
crv = NurbsCurve.ByPoints(pts, true);

// the same curve, if left open:
crv2 = NurbsCurve.ByPoints(pts.Translate(5, 0, 0),
    false);

Points de contrôle de courbe

Les courbes NURBS sont générées de la même façon, les points d’entrée représentant les extrémités d’un segment de ligne droite, et un second paramètre spécifiant le degré et le type de lissage de la courbe, appelé degré. * Une courbe de degré 1 n’a pas de lissage ; il s’agit d’une polyligne.

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

// a B-Spline curve with degree 1 is a polyline
ctrl_curve = NurbsCurve.ByControlPoints(pts, 1);

Une courbe de degré 2 est lissée de façon à ce que la courbe coupe et soit tangente au milieu des segments de polyligne :

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

// a B-Spline curve with degree 2 is smooth
ctrl_curve = NurbsCurve.ByControlPoints(pts, 2);

Dynamo prend en charge les courbes NURBS (Non-Uniform Rational B-spline) jusqu’au degré 20, et le script suivant illustre l’effet de l’augmentation des niveaux de lissage sur la forme d’une courbe :

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

def create_curve(pts : Point[], degree : int)
{
	return = NurbsCurve.ByControlPoints(pts,
        degree);
}

ctrl_crvs = create_curve(pts, 1..11);

Notez que vous devez disposer d’au moins un point de contrôle supplémentaire par rapport au degré de la courbe.

Un autre avantage de la construction de courbes par le biais de sommets de contrôle est la possibilité de conserver la tangence entre des segments de courbe individuels. Pour ce faire, il convient d'extraire la direction entre les deux derniers points de contrôle et de poursuivre dans cette direction avec les deux premiers points de contrôle de la courbe suivante. L’exemple suivant crée deux courbes NURBS distinctes qui sont néanmoins aussi lisses qu’une seule courbe :

pts_1 = {};

pts_1[0] = Point.ByCoordinates(0, 0, 0);
pts_1[1] = Point.ByCoordinates(1, 1, 0);
pts_1[2] = Point.ByCoordinates(5, 0.2, 0);
pts_1[3] = Point.ByCoordinates(9, -3, 0);
pts_1[4] = Point.ByCoordinates(11, 2, 0);

crv_1 = NurbsCurve.ByControlPoints(pts_1, 3);

pts_2 = {};

pts_2[0] = pts_1[4];
end_dir = pts_1[4].Subtract(pts_1[3].AsVector());

pts_2[1] = Point.ByCoordinates(pts_2[0].X + end_dir.X,
    pts_2[0].Y + end_dir.Y, pts_2[0].Z + end_dir.Z);

pts_2[2] = Point.ByCoordinates(15, 1, 0);
pts_2[3] = Point.ByCoordinates(18, -2, 0);
pts_2[4] = Point.ByCoordinates(21, 0.5, 0);

crv_2 = NurbsCurve.ByControlPoints(pts_2, 3);

Les objets dans les conceptions de calcul sont rarement créés explicitement dans leur position et leur forme finales. Le plus souvent, ils font l'objet d'opération de conversion et de rotation, et sont positionnés par rapport à la géométrie existante. Le calcul vectoriel sert d'"armature" à la géométrie en lui donnant une direction et une orientation, ainsi qu'en conceptualisant les mouvements dans l'espace 3D sans représentation visuelle.

Sous sa forme de base, un vecteur représente une position dans un espace 3D et est souvent considéré comme l’extrémité d’une flèche partant de la position (0, 0, 0) et allant jusqu’à cette position. Les vecteurs peuvent être créés avec le constructeur ByCoordinates, qui prend la position x, y et z de l’objet Vector venant d’être créé. Notez que les objets Vector ne sont pas des objets géométriques et n’apparaissent pas dans la fenêtre Dynamo. Toutefois, les informations sur un vecteur nouvellement créé ou modifié peuvent être imprimées dans la fenêtre de la console :

// construct a Vector object
v = Vector.ByCoordinates(1, 2, 3);

s = v.X + " " + v.Y + " " + v.Z;

Un ensemble d’opérations mathématiques est défini sur des objets Vector, ce qui vous permet d’ajouter, de soustraire, de multiplier et de déplacer des objets dans l’espace 3D, de la même manière que vous déplaceriez des nombres réels dans un espace 1D sur une ligne de nombres.

Addition de vecteurs

L’addition de vecteurs est définie comme la somme des composants de deux vecteurs. Elle peut être considérée comme le vecteur résultant si les deux flèches de vecteur des composants sont placées « bout à bout ». L’addition de vecteurs est effectuée à l’aide de la méthode Add et est représentée par le diagramme sur la gauche.

a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 9, y = 6, z = 0
c = a.Add(b);

Soustraction de vecteurs

De même, deux objets Vector peuvent être soustraits l’un à l’autre à l’aide de la méthode Subtract. La soustraction de vecteurs peut être considérée comme la direction à partir du premier vecteur vers le second vecteur.

a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 1, y = 4, z = 0
c = a.Subtract(b);

Multiplication de vecteurs

La multiplication de vecteurs peut être considérée comme le déplacement de l’extrémité d’un vecteur dans sa propre direction en fonction d’un facteur d’échelle donné.

a = Vector.ByCoordinates(4, 4, 0);

// c has value x = 20, y = 20, z = 0
c = a.Scale(5);

Normalisation de la longueur des vecteurs

Souvent, lors de la mise à l'échelle d'un vecteur, on souhaite que la longueur du vecteur résultant soit exactement la même que la valeur mise à l'échelle. Pour ce faire, il faut d’abord normaliser un vecteur, c’est-à-dire définir la longueur du vecteur comme exactement égale à un.

a = Vector.ByCoordinates(1, 2, 3);
a_len = a.Length;

// set the a's length equal to 1.0
b = a.Normalized();
c = b.Scale(5);

// len is equal to 5
len = c.Length;

c pointe toujours dans la même direction que a (1, 2, 3), bien qu’il ait maintenant une longueur exactement égale à 5.

Produit cartésien

Deux autres méthodes, qui n'ont pas de similitudes avec les mathématiques 1D, existent en mathématiques vectorielles. Il s'agit du produit vectoriel et du produit scalaire. Le produit vectoriel permet de générer un vecteur orthogonal (de 90 degrés) par rapport à deux vecteurs existants. Par exemple, le produit vectoriel des axes x et y est l’axe z, bien que les deux vecteurs d’entrée n’aient pas besoin d’être orthogonaux les uns par rapport aux autres. Un vecteur de produit vectoriel est calculé avec la méthode Cross.

a = Vector.ByCoordinates(1, 0, 1);
b = Vector.ByCoordinates(0, 1, 1);

// c has value x = -1, y = -1, z = 1
c = a.Cross(b);

Produit scalaire

Le produit scalaire est une autre fonction plus avancée de calcul vectoriel. Le produit scalaire entre deux vecteurs est un nombre réel (et non un objet Vector) qui fait référence, mais ne correspond pas exactement, à l'angle entre deux vecteurs. L’une des propriétés utiles de cette fonction est que le produit scalaire entre deux vecteurs sera égal à 0 si ces derniers sont perpendiculaires (et uniquement à cette condition). Le produit scalaire est calculé à l’aide de la méthode Dot.

a = Vector.ByCoordinates(1, 2, 1);
b = Vector.ByCoordinates(5, -8, 4);

// d has value -7
d = a.Dot(b);

Beaucoup de ces exemples se sont jusqu'ici concentrés sur la construction d'une géométrie dimensionnelle plus élevée à partir d'objets dimensionnels inférieurs. Les méthodes d’intersection permettent à cette géométrie dimensionnelle plus élevée de générer des objets dimensionnels inférieurs, tandis que les commandes d’ajustement et de sélection d’ajustement permettent au script de modifier considérablement les formes géométriques après leur création.

La méthode Intersect est définie sur tous les éléments de géométrie dans Dynamo, ce qui signifie en théorie que tout élément de géométrie peut être entrecoupé avec n’importe quel autre élément de géométrie. Naturellement, certaines intersections n’ont pas de sens, comme les intersections impliquant des points, car l’objet résultant sera toujours le point d’entrée lui-même. Les autres combinaisons possibles d'intersections entre des objets sont décrites dans le tableau suivant. Le tableau suivant présente le résultat de diverses opérations d’intersection :

Intersecter

L'exemple très simple suivant illustre l'intersection d'un plan avec une NurbsSurface. L’intersection génère un réseau de NurbsCurves, qui peut être utilisé comme toute autre NurbsCurve.

// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_5, 3, 3);

WCS = CoordinateSystem.Identity();

pl = Plane.ByOriginNormal(WCS.Origin.Translate(0, 0,
    0.5), WCS.ZAxis);

// intersect surface, generating three closed curves
crvs = surf.Intersect(pl);

crvs_moved = crvs.Translate(0, 0, 10);

La méthode Trim ressemble fortement à la méthode Intersect, dans le sens où elle est définie pour presque chaque élément de géométrie. Toutefois, la méthode Trim comporte beaucoup plus de limitations que la méthode Intersect.

Ajuster

Il est à noter que les méthodes Trim nécessitent un point de « sélection », qui détermine la géométrie à ignorer et les éléments à conserver. Dynamo recherche et ignore la géométrie ajustée la plus proche du point de sélection.

// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_5, 3, 3);

tool_pts = Point.ByCoordinates((-10..20..10)<1>,
    (-10..20..10)<2>, 1);

tool = NurbsSurface.ByPoints(tool_pts);

pick_point = Point.ByCoordinates(8, 1, 3);

result = surf.Trim(tool, pick_point);

Dans les conceptions informatiques, les courbes et les surfaces sont souvent utilisées comme une armature sous-jacente à des constructions géométriques ultérieures. Pour que cette première géométrie puisse être utilisée comme base pour une géométrie ultérieure, le script doit pouvoir extraire des qualités telles que la position et l'orientation sur toute la zone de l'objet. Les courbes et les surfaces prennent en charge cette extraction, appelée définition des paramètres.

Tous les points d'une courbe peuvent être considérés comme ayant un paramètre unique compris entre 0 et 1. Si nous devions créer une NurbsCurve basée sur plusieurs points de contrôle ou interpolés, le premier point aurait le paramètre 0 et le dernier point le paramètre 1. Il est impossible de savoir à l’avance quel est le paramètre exact d’un point intermédiaire, ce qui peut sembler être une limitation importante, bien qu’atténuée par une série de fonctions utilitaires. Les surfaces ont une définition des paramètres similaire en tant que courbes, mais avec deux paramètres au lieu d’un, appelés u et v. Si nous voulons créer une surface avec les points suivants :

pts = [ [p1, p2, p3],
        [p4, p5, p6],
        [p7, p8, p9] ];

p1 aurait le paramètre u = 0 v = 0, tandis que p9 aurait les paramètres u = 1 v = 1.

La définition des paramètres n’est pas particulièrement utile lors de la détermination des points utilisés pour générer des courbes. Elle permet principalement de déterminer les emplacements si des points intermédiaires sont générés par les constructeurs NurbsCurve et NurbsSurface.

Les courbes ont une méthode PointAtParameter, qui prend un double argument entre 0 et 1, et renvoie l’objet Point à ce paramètre. Par exemple, ce script recherche les points aux paramètres 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 et 1 :

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(6, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(3, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);

crv = NurbsCurve.ByPoints(pts);

pts_at_param = crv.PointAtParameter(0..1..#11);

// draw Lines to help visualize the points
lines = Line.ByStartPointEndPoint(pts_at_param,
    Point.ByCoordinates(4, 6, 0));

De même, les surfaces ont une méthode PointAtParameter qui prend deux arguments, le paramètre u et v du point généré.

Alors que l’extraction de points individuels sur une courbe et une surface peut être utile, les scripts requièrent souvent la connaissance des caractéristiques géométriques spécifiques d’un paramètre, telles que la direction dans laquelle la courbe ou la surface est orientée. La méthode CoordinateSystemAtParameter trouve non seulement la position, mais également un CoordinateSystem orienté au niveau du paramètre d’une courbe ou d’une surface. Par exemple, le script suivant extrait des CoordinateSystems orientés le long d’une surface de révolution et utilise leur orientation pour générer des lignes qui dépassent normalement par rapport à la surface :

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(3, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(5, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);
pts[7] = Point.ByCoordinates(4, 0, 7);

crv = NurbsCurve.ByPoints(pts);

axis_origin = Point.ByCoordinates(0, 0, 0);
axis = Vector.ByCoordinates(0, 0, 1);

surf = Surface.ByRevolve(crv, axis_origin, axis, 90,
    140);

cs_array = surf.CoordinateSystemAtParameter(
    (0..1..#7)<1>, (0..1..#7)<2>);

def make_line(cs : CoordinateSystem) {
	lines_start = cs.Origin;
    lines_end = cs.Origin.Translate(cs.ZAxis, -0.75);

    return = Line.ByStartPointEndPoint(lines_start,
        lines_end);
}

lines = make_line(Flatten(cs_array));

Comme mentionné précédemment, la définition des paramètres n’est pas toujours uniforme sur toute la longueur d’une courbe ou d’une surface, ce qui signifie que le paramètre 0.5 ne correspond pas toujours au milieu et 0.25 ne correspond pas toujours au premier quart d’une courbe ou d’une surface. Pour contourner cette limitation, les courbes possèdent un jeu supplémentaire de commandes de définition de paramètres qui vous permettent de trouver un point à des longueurs spécifiques le long d'une courbe.

Raccourci

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.

Syntaxe supplémentaire

Intervalles et séquences

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 :

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

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

3. 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 est 0..#15..2.

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

Intervalles avancés

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.

Création de listes et obtention d’éléments à partir d’une liste

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.

Exercice : Surface sinusoïdale

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.

1. Définissez un intervalle compris entre 0 et 1 et 50 divisions en tapant 0..1..#50 dans un nœud Code Block.

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

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

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

1. Lorsque vous effectuez une transposition sur l’intervalle de nombres, vous inversez la direction de l’onde du rideau : transposeList = List.Transpose(sineList);.

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

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

L'analogie bidimensionnelle d'une NurbsCurve est la NurbsSurface. Comme pour la NurbsCurve de forme libre, les NurbsSurfaces peuvent être construites selon deux méthodes de base : en entrant un ensemble de points de base et en utilisant Dynamo pour effectuer une interpolation entre eux, et en spécifiant explicitement les points de contrôle de la surface. De plus, comme les courbes de forme libre, les surfaces interpolées sont utiles lorsqu'un concepteur sait précisément la forme que doit avoir une surface ou lorsqu'une conception requiert que la surface traverse des points de contrainte. D'autre part, les surfaces créées à l'aide de points de contrôle peuvent être plus utiles pour les conceptions explorant différents niveaux de lissage.

Surface interpolée

Pour créer une surface interpolée, il suffit de générer un ensemble de points à deux dimensions qui se rapproche de la forme d'une surface. L’ensemble doit être rectangulaire, c’est-à-dire non irrégulier. La méthode NurbsSurface.ByPoints permet de construire une surface à partir de ces points.

Points de contrôle de surface

Vous pouvez également créer des NurbsSurfaces de forme libre en spécifiant les points de contrôle sous-jacents d'une surface. Comme les NurbsCurves, les points de contrôle peuvent être considérés comme représentant un maillage quadrilatéral avec des segments droits, qui, en fonction du degré de la surface, est lissé pour obtenir la forme de surface finale. Pour créer une NurbsSurface via des points de contrôle, incluez deux paramètres supplémentaires à NurbsSurface.ByPoints, indiquant les degrés des courbes sous-jacentes dans les deux directions de la surface.

Vous pouvez augmenter le degré de la NurbsSurface pour modifier la géométrie de la surface obtenue :

Surface de lissage

Tout comme les surfaces peuvent être créées en effectuant une interpolation entre un ensemble de points d'entrée, elles peuvent être créées en effectuant une interpolation entre un ensemble de courbes de base. On parle alors de lissage. Une courbe lissée est créée à l’aide du constructeur Surface.ByLoft, avec un ensemble de courbes d’entrée comme seul paramètre.

Révolution de surfaces

Les surfaces de révolution sont un type de surface supplémentaire créé en balayant une courbe de base autour d'un axe central. Si les surfaces interpolées sont l'analogie bidimensionnelle des courbes interpolées, les surfaces de révolution sont l'analogie bidimensionnelle des cercles et des arcs.

Les surfaces de révolution sont spécifiées par une courbe de base, représentant l’« arête » de la surface, par une origine d’axe, représentant le point de base de la surface, par une direction d’axe, représentant la direction du « noyau » central, par un angle de départ de balayage et par un angle de fin de balayage. Elles sont utilisées comme entrées du constructeur Surface.Revolve.

Les scripts Python suivants génèrent des réseaux de points pour plusieurs exemples. Ils doivent être collés dans un nœud de script Python comme suit :

python_points_1

python_points_2

python_points_3

python_points_4

python_points_5

​Python est un langage de programmation très répandu dont la popularité est liée à son style de syntaxe. Il est très lisible, ce qui facilite l’apprentissage de beaucoup d’autres langages. Python prend en charge les modules et les packages, et peut être intégré dans des applications existantes. Pour plus d’informations sur la façon d’utiliser Python, consultez la page sur .

Certains objets de géométrie peuvent être créés en spécifiant explicitement les coordonnées X, Y et Z dans un espace tridimensionnel. Plus souvent, cependant, la géométrie est placée dans sa position finale à l'aide de transformations géométriques sur l'objet lui-même ou sur son CoordinateSystem sous-jacent.

Translation

La transformation géométrique la plus simple est une conversion qui permet de déplacer un objet d’un nombre donné d’unités dans les directions X, Y et Z.

Rotation

Bien que tous les objets dans Dynamo puissent être convertis grâce à l’ajout de la méthode .Translate à la fin du nom de l’objet, des transformations plus complexes requièrent la transformation de l’objet d’un CoordinateSystem sous-jacent en un nouveau CoordinateSystem. Par exemple, pour faire pivoter un objet de 45 degrés autour de l’axe X, transformez l’objet de son CoordinateSystem existant sans rotation en un CoordinateSystem qui a été pivoté de 45 degrés autour de l’axe X à l’aide de la méthode .Transform :

Échelle

Outre la conversion et la rotation, les CoordinateSystems peuvent également être créés à l’échelle ou coupés. Un CoordinateSystem peut être mis à l’échelle à l’aide de la méthode .Scale :

Les CoordinateSystems coupés sont créés grâce à l’insertion de vecteurs non orthogonaux dans le constructeur CoordinateSystem.

Étant donné que la mise à l’échelle et le cisaillement sont des transformations géométriques plus complexes que la rotation et la conversion, les objets Dynamo ne peuvent pas tous faire l’objet de ces transformations. Le tableau suivant répertorie les objets Dynamo qui peuvent avoir un CoordinateSystem mis à l'échelle de façon non uniforme, et ceux qui peuvent avoir un CoordinateSystem coupé.

Les méthodes Intersect, Trim et SelectTrim sont principalement utilisées sur la géométrie dimensionnelle inférieure, comme les points, les courbes et les surfaces. La géométrie solide, en revanche, dispose d’un ensemble de méthodes supplémentaires pour modifier la forme après sa construction, en soustrayant de la matière de manière comparable à la méthode Trim et en combinant les éléments pour former un ensemble plus grand.

Réunion

La méthode Union prend deux objets solides et crée un objet solide unique à partir de l’espace couvert par les deux objets. L’espace de chevauchement entre les objets est combiné dans la forme finale. Cet exemple combine une sphère et un cuboïde en une forme de sphère-cube solide unique :

Différence

La méthode Difference, comme Trim, soustrait le contenu du solide de l’outil d’entrée du solide de base. Dans cet exemple, nous allons creuser une petite indentation dans une sphère :

Intersecter

La méthode Intersect renvoie le solide se chevauchant entre deux entrées de solide. Dans l’exemple suivant, la méthode Difference a été changée en Intersect et le solide résultant correspond au vide manquant initialement creusé :

Cette section comporte une série de leçons sur la création d'une géométrie à l'aide de DesignScript. Poursuivez en copiant l'exemple DesignScript dans des blocs de code Dynamo.

Python et Revit

Maintenant que vous savez comment utiliser les scripts Python dans Dynamo, découvrez comment connecter les bibliothèques Revit à l'environnement de script. Rappelez-vous que vous avez importé Python Standard et vos nœuds Dynamo Core avec les quatre premières lignes du bloc de code ci-dessous. Pour importer les nœuds Revit, les éléments Revit et le gestionnaire de documents Revit, il vous suffit d'ajouter quelques lignes supplémentaires :

Ces lignes vous donnent accès à l'API de Revit et vous offre des scripts personnalisés pour toutes les tâches Revit. La combinaison du processus de programmation visuelle et du script de l'API de Revit permet d'améliorer considérablement la collaboration et le développement des outils. Par exemple, un responsable BIM et un concepteur schématique peuvent travailler ensemble sur le même graphique. Dans le cadre de cette collaboration, ils peuvent améliorer la conception et l’exécution du modèle.

API spécifiques de la plate-forme

Exercice 1

Créez un projet Revit.

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 ces exercices, vous allez explorer les scripts élémentaires de Python dans Dynamo for Revit. Cet exercice est axé sur la gestion des fichiers et des éléments Revit, ainsi que sur la communication entre Revit et Dynamo.

Il s'agit d'une méthode de découpe et de séchage permettant de récupérer les éléments doc, uiapp et app du fichier Revit lié à votre session Dynamo. Les programmeurs qui ont déjà travaillé dans l'API de Revit reconnaîtront peut-être les éléments dans la liste d'observation. Si ces éléments ne vous semblent pas familiers, pas d'inquiétude. Vous allez utiliser d'autres exemples dans les exercices ci-dessous.

Voici comment importer les services Revit et récupérer les données du document dans Dynamo.

Examinez le nœud Python dans Dynamo. Vous pouvez également retrouver le code ci-dessous :

Exercice 2

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 courbe de modèle simple dans Revit à l'aide du nœud Dynamo Python.

Commencez par créer une famille de volumes conceptuels dans Revit.

Ouvrez le dossier Volume conceptuel et utilisez le fichier gabarit Metric Mass.rft.

Dans Revit, utilisez le raccourci clavier un pour afficher les paramètres Unité de projet et définir l’unité de longueur sur Mètres.

Lancez Dynamo et créez le jeu de nœuds dans l’image ci-dessous. Vous allez d’abord créer deux points de référence dans Revit à partir de nœuds Dynamo.

1. Créez un nœud Code Block et attribuez-lui la valeur de "0;".

2. Connectez cette valeur dans un nœud ReferencePoint.ByCoordinates pour les entrées X, Y et Z.

3. Créez trois curseurs, compris entre -100 et 100, avec une taille de pas de 1.

4. Connectez chaque curseur à un nœud ReferencePoint.ByCoordinates.

5. Ajoutez un nœud Python à l'espace de travail, cliquez sur le bouton "+" du nœud pour ajouter une autre entrée et connectez les deux points de référence dans chaque entrée. Ouvrez le nœud Python.

Examinez le nœud Python dans Dynamo. Recherchez le code complet ci-dessous.

1. System.Array : Revit requiert un réseau système comme entrée (et non une liste Python). Il s'agit juste d'une ligne de code supplémentaire, mais prêter attention aux types d'argument facilite la programmation Python dans Revit.

Dans Dynamo, vous avez créé deux points de référence avec une ligne les reliant à l’aide de Python. Le prochain exercice va vous permettre d’aller un peu plus loin.

Exercice 3

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 simple, mais il illustre les rubriques de connexion de données et de géométrie de Revit à Dynamo et vice-versa. Commencez par ouvrir Revit-StructuralFraming.rvt. Une fois ouvert, lancez Dynamo et ouvrez le fichier Revit-StructuralFraming.dyn.

Ce fichier Revit est des plus basiques. Il comporte deux courbes de référence : une sur le niveau 1 et l'autre sur le niveau 2. Votre objectif est d'intégrer ces courbes dans Dynamo et de conserver un lien actif.

Ce fichier contient un ensemble de nœuds connectés à cinq entrées d’un nœud Python.

1. Nœuds Select Model Element : cliquez sur le bouton Sélectionner de chaque nœud et sélectionnez une courbe correspondante dans Revit.

2. Code Block : à l'aide de la syntaxe 0..1..#x;, connectez un curseur de type entier compris entre 0 et 20 à l'entrée x. Celui-ci indique le nombre de poutres à dessiner entre les deux courbes.

3. Structural Framing Types : choisissez la poutre W12x26 par défaut dans le menu déroulant.

4. Levels : sélectionnez "Level 1".

Dans Python, ce code est un peu plus dense, mais les commentaires à l’intérieur du code décrivent ce qui se passe dans le processus :

Dans Revit, un réseau de poutres s’étend sur les deux courbes en tant qu’éléments structurels. Remarque : cet exemple n'est pas réaliste... Les éléments structurels sont utilisés comme exemple pour les occurrences Revit d'origine créées à partir de Dynamo.

Dans Dynamo, les résultats sont également visibles. Les poutres du nœud Watch3D font référence à la géométrie interrogée à partir des éléments Revit.

Il existe un processus continu de conversion des données de l’environnement Revit vers l’environnement Dynamo. En résumé, voici comment le processus se déroule :

1. Sélectionnez l'élément Revit.

2. Convertissez l'élément Revit en courbe Dynamo.

3. Divisez la courbe Dynamo en une série de points Dynamo.

4. Utilisez les points Dynamo entre deux courbes pour créer des lignes Dynamo.

5. Créez des poutres Revit en référençant les lignes Dynamo.

6. Générez des surfaces Dynamo en interrogeant la géométrie des poutres Revit.

Ce processus peut sembler compliqué, mais grâce au script, il est aussi simple de modifier la courbe dans Revit et exécuter à nouveau le solveur (pour ce faire, vous devrez peut-être supprimer les poutres précédentes). Cela est dû au placement des poutres dans Python, ce qui rompt l'association des nœuds OOTB.

Avec une mise à jour des courbes de référence dans Revit, vous obtenez un nouveau réseau de poutres.

Avec Dynamo 2.0, vous pouvez spécifier un gabarit par défaut (.py extension) à utiliser lors de la première ouverture de la fenêtre Python. Cette option a longtemps été attendue, car elle accélère l'utilisation de Python dans Dynamo. La possibilité d'utiliser un gabarit vous permet d'obtenir des importations par défaut prêtes à l'emploi lorsque vous voulez développer un script Python personnalisé.

Ce gabarit se trouve à l’emplacement APPDATA de votre installation de Dynamo.

L’emplacement habituel est le suivant : ( %appdata%\Dynamo\Dynamo Core\{version}\ ).

Configuration du gabarit

Pour utiliser cette fonctionnalité, vous devez ajouter la ligne suivante dans le fichier DynamoSettings.xml. (Modifier dans le bloc-notes)

Vous pouvez simplement remplacer <PythonTemplateFilePath /> par ce qui suit :

Ensuite, vous devez créer un gabarit en intégrant la fonctionnalité que vous voulez utiliser. Dans cet exemple, vous allez incorporer les importations liées à Revit et d'autres éléments que vous utilisez généralement lorsque vous travaillez avec Revit.

Vous pouvez ouvrir un document de bloc-notes vide et coller le code suivant à l'intérieur :

Une fois cela fait, enregistrez ce fichier sous le nom PythonTemplate.py à l’emplacement APPDATA.

Comportement du script Python par la suite

Une fois le gabarit Python défini, Dynamo le recherche à chaque fois qu’un nœud Python est positionné. Si le gabarit est introuvable, l’affichage sera comparable à la fenêtre Python par défaut.

Si Dynamo trouve le gabarit Python (par exemple, notre gabarit Revit), il affiche tous les éléments par défaut que vous avez intégrés.

Vous trouverez ici des informations supplémentaires sur cet ajout important (par Radu Gidei). https://github.com/DynamoDS/Dynamo/pull/8122

Pourquoi utiliser la programmation textuelle dans l’environnement de programmation visuelle de Dynamo ? La présente de nombreux avantages. Elle vous permet de créer des programmes sans avoir à apprendre la syntaxe spéciale dans une interface visuelle intuitive. Toutefois, un programme visuel peut être encombré et peut parfois ne pas fonctionner correctement. Par exemple, Python propose des méthodes beaucoup plus efficaces pour écrire des instructions conditionnelles (if/then) et des boucles. Python est un outil puissant qui permet d’étendre les capacités de Dynamo et de remplacer de nombreux nœuds par quelques lignes de code concises.

Programme visuel :

Programme textuel :

Nœud Python

Comme les blocs de code, les nœuds Python sont une interface de script au sein d'un environnement de programmation visuelle. Le nœud Python se trouve sous Script > Éditeur > Python Script dans la bibliothèque.

Un double-clic sur le nœud permet d’ouvrir l’éditeur de script Python (vous pouvez également cliquer avec le bouton droit sur le nœud et sélectionner Éditer…). Le texte réutilisable situé en haut de l’éditeur vous permet de référencer les bibliothèques dont vous aurez besoin. Les entrées sont stockées dans le réseau IN. Les valeurs sont renvoyées à Dynamo en étant affectées à la variable OUT.

Les méthodes comprennent des constructeurs tels que ByCoordinates, des actions telles que Add et des requêtes telles que les coordonnées X, Y et Z.

Exercice : Nœud personnalisé avec le nœud Python Script pour la création de motifs du module solide

Partie I : Configuration du nœud Python Script

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 exemple, vous allez écrire un script Python qui crée des motifs à partir d'un module solide, et le transformer en nœud personnalisé. Commencer par créer le module solide à l’aide de nœuds Dynamo.

1. Rectangle.ByWidthLength : créez un rectangle qui servira de base au solide.

2. Surface.ByPatch : connectez le rectangle à l’entrée « closedCurve » pour créer la surface inférieure.

1. Geometry.Translate : connectez le rectangle à l’entrée « geometry » pour le déplacer vers le haut, à l’aide d’un bloc de code pour spécifier l’épaisseur de base du solide.

2. Polygon.Points : interrogez le rectangle converti pour extraire les points de coin.

3. Geometry.Translate : utilisez un bloc de code pour créer une liste de quatre valeurs correspondant aux quatre points, en convertissant un coin du solide vers le haut.

4. Polygon.ByPoints : utilisez les points convertis pour reconstruire le polygone supérieur.

5. Surface.ByPatch : connectez le polygone pour créer la surface supérieure.

Maintenant que vous avez les surfaces supérieures et inférieures, effectuez un lissage entre les deux contours pour créer les côtés du solide.

1. List.Create: connectez le rectangle inférieur et le polygone supérieur aux entrées d’index.

2. Surface.ByLoft : lissez les deux contours pour créer les côtés du solide.

3. List.Create : connectez les surfaces supérieures, inférieures et latérales aux entrées d’index pour créer une liste de surfaces.

4. Solid.ByJoiningSurfaces : joignez les surfaces pour créer le module solide.

Maintenant que le solide est créé, déposez un nœud de script Python dans l’espace de travail.

1. Pour ajouter des entrées supplémentaires au nœud, cliquez sur l’icône + sur le nœud. Les entrées sont nommées IN[0], IN[1], etc. pour indiquer qu’elles représentent des éléments dans une liste.

Commencez par définir les entrées et la sortie. Double-cliquez sur le nœud pour ouvrir l'éditeur Python. Suivez le code ci-dessous pour modifier le code dans l’éditeur.

Ce code sera plus pertinent à mesure que vous progresserez dans l’exercice. Ensuite, identifiez les informations nécessaires pour la mise en réseau du module solide. Tout d'abord, vous devez connaître les cotes du solide pour déterminer la distance de conversion. En raison d’un bogue relatif à la zone de contour, utilisez la géométrie de courbe d’arête pour créer une zone de contour.

Examinez le nœud Python dans Dynamo. La syntaxe utilisée est la même que celle utilisée dans les titres des nœuds dans Dynamo. Consultez le code commenté ci-dessous.

Puisque vous allez convertir et faire pivoter les modules solides, utilisez l'opération Geometry.Transform. Examinez le nœud Geometry.Transform : vous savez que vous avez besoin d'un système de coordonnées source et d'un système de coordonnées cible pour transformer le solide. La source est le système de coordonnées contextuel du solide, alors que la cible est un système de coordonnées différent pour chaque module en réseau. Cela signifie que vous devez parcourir les valeurs x et y pour modifier le système de coordonnées à chaque fois.

Cliquez sur Exécuter, puis enregistrez le code. Connectez le nœud Python avec le script existant comme suit.

1. Connectez la sortie du nœud Solid.ByJoinedSurfaces comme première entrée du nœud Python et utilisez un nœud Code Block pour définir les autres entrées.

2. Créez un nœud Topology.Edges et utilisez la sortie du nœud Python comme son entrée.

3. Enfin, créez un nœud Edge.CurveGeometry et utilisez la sortie du nœud Topology.Edges comme son entrée.

Modifiez la valeur de départ pour créer différents motifs. Vous pouvez également modifier les paramètres du module solide lui-même pour créer différents effets.

Partie II : Conversion du nœud Python Script en nœud personnalisé

Maintenant que vous avez créé un script Python utile, enregistrez-le en tant que nœud personnalisé. Sélectionnez le nœud Python Script, cliquez avec le bouton droit sur Espace de travail et sélectionnez « Créer un nœud personnalisé ».

Attribuez un nom, une description et une catégorie.

Un nouvel espace de travail s’ouvre dans lequel vous pouvez modifier le nœud personnalisé.

1. Entrées : modifiez les noms d’entrée pour qu’ils soient plus descriptifs et ajoutez des types de données et des valeurs par défaut.

2. Sortie : modifier le nom de la sortie.

Enregistrez le nœud sous forme de fichier .dyf. Le nœud personnalisé doit maintenant refléter les modifications apportées.