# Index des nœuds

Cet index fournit des informations supplémentaires sur tous les nœuds utilisés dans ce guide, ainsi que sur les autres composants que vous trouverez utiles. Il s'agit juste d'une introduction de quelques-uns des 500 nœuds disponibles dans Dynamo.

## Affichage

### Color

|   |                                                                                                                                                             |   |
| - | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                                       |   |
|   | <p><strong>Color.ByARGB</strong><br>Créer une couleur au moyen de composants alpha, rouges, verts et bleus.</p>                                             | ! |
| ! | <p><strong>Intervalles de couleurs</strong><br>Obtenir une couleur à partir d'un dégradé de couleurs entre une couleur de départ et une couleur de fin.</p> |   |
|   | ACTIONS                                                                                                                                                     |   |
|   | <p><strong>Color.Brightness</strong><br>Obtient la valeur de luminosité de cette couleur.</p>                                                               |   |
| ! | <p><strong>Color.Components</strong><br>Répertorie les composants de la couleur dans l’ordre suivant : alpha, rouge, vert, bleu.</p>                        | ! |
|   | <p><strong>Color.Saturation</strong><br>Obtient la valeur de saturation de cette couleur.</p>                                                               | ! |
|   | <p><strong>Color.Hue</strong><br>Obtient la valeur de teinte de cette couleur.</p>                                                                          | ! |
|   | REQUETE                                                                                                                                                     |   |
| ! | <p><strong>Color.Alpha</strong><br>Rechercher le composant alpha d’une couleur, de 0 à 255.</p>                                                             | ! |
|   | <p><strong>Color.Blue</strong><br>Rechercher le composant bleu d’une couleur, de 0 à 255.</p>                                                               | ! |
|   | <p><strong>Color.Green</strong><br>Rechercher le composant vert d’une couleur, de 0 à 255.</p>                                                              | ! |
|   | <p><strong>Color.Red</strong><br>Rechercher le composant rouge d’une couleur, de 0 à 255.</p>                                                               | ! |

|   |                                                                                                       |   |
| - | ----------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                 |   |
|   | <p><strong>GeometryColor.ByGeometryColor</strong><br>Affiche la géométrie à l'aide d'une couleur.</p> | ! |

### Watch

|   |                                                                                        |   |
| - | -------------------------------------------------------------------------------------- | - |
|   | ACTIONS                                                                                |   |
| ! | <p><strong>View\.Watch</strong><br>Visualiser la sortie du nœud.</p>                   | ! |
| ! | <p><strong>View\.Watch 3D</strong><br>Affiche un aperçu dynamique de la géométrie.</p> | ! |

## Entrée

|   |                                                                                                                                      |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------ | - |
|   | ACTIONS                                                                                                                              |   |
|   | <p><strong>Opération booléenne</strong><br>Sélection entre True et False.</p>                                                        | ! |
| ! | <p><strong>Code Block</strong><br>Permet de créer le code DesignScript directement.</p>                                              | ! |
| ! | <p><strong>Chemin de répertoire</strong><br>Permet de sélectionner un répertoire sur le système pour obtenir son chemin d’accès</p>  | ! |
| ! | <p><strong>Chemin du fichier</strong><br>Permet de sélectionner un fichier sur le système, de façon à obtenir son nom de fichier</p> | ! |
| ! | <p><strong>Integer Slider</strong><br>Curseur qui génère des valeurs entières.</p>                                                   | ! |
|   | <p><strong>Nombre</strong><br>Permet de créer un nombre.</p>                                                                         |   |
| ! | <p><strong>Curseur de nombre</strong><br>Curseur qui génère des valeurs numériques.</p>                                              | ! |
|   | <p><strong>Chaîne</strong><br>Crée une chaîne.</p>                                                                                   | ! |
| ! | <p><strong>Object.IsNull</strong><br>Détermine si l’objet indiqué est nul.</p>                                                       | ! |

## List

|   |                                                                                                                                                                                                                                                                                      |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | - |
|   | CREER                                                                                                                                                                                                                                                                                |   |
| ! | <p><strong>List.Create</strong><br>Permet de créer une liste des entrées indiquées.</p>                                                                                                                                                                                              | ! |
| ! | <p><strong>List.Combine</strong><br>Applique un combinateur à chaque élément en deux séquences</p>                                                                                                                                                                                   | ! |
|   | <p><strong>Number Range</strong><br>Crée une séquence de nombres dans l’intervalle spécifié</p>                                                                                                                                                                                      |   |
|   | <p><strong>Number Sequence</strong><br>Crée une série de numéros.</p>                                                                                                                                                                                                                | ! |
|   | ACTIONS                                                                                                                                                                                                                                                                              |   |
| ! | <p><strong>List.Chop</strong><br>Couper une liste en un ensemble de listes contenant chacune le nombre donné d’éléments.</p>                                                                                                                                                         | ! |
|   | <p><strong>List.Count</strong><br>Renvoie le nombre d’éléments stockés dans la liste indiquée.</p>                                                                                                                                                                                   | ! |
| ! | <p><strong>List.Flatten</strong><br>Aplanit une liste imbriquée de listes en fonction d’une quantité spécifique.</p>                                                                                                                                                                 | ! |
| ! | <p><strong>List.FilterByBoolMask</strong><br>Filtre une séquence en recherchant les index correspondants dans une liste distincte de booléens.</p>                                                                                                                                   | ! |
| ! | <p><strong>List.GetItemAtIndex</strong><br>Obtient un élément de la liste indiquée qui se trouve au niveau de l’index spécifié.</p>                                                                                                                                                  | ! |
|   | <p><strong>List.Map</strong><br>Applique une fonction sur tous les éléments d’une liste, générant une nouvelle liste à partir des résultats</p>                                                                                                                                      | ! |
|   | <p><strong>List.Reverse</strong><br>Crée une liste contenant les éléments de la liste indiquée, mais dans l’ordre inverse</p>                                                                                                                                                        | ! |
| ! | <p><strong>List.ReplaceItemAtIndex</strong><br>Remplacer un élément de la liste indiquée qui se trouve au niveau de l’index spécifié</p>                                                                                                                                             | ! |
| ! | <p><strong>List.ShiftIndices</strong><br>Décale les index dans la liste vers la droite en fonction de la quantité indiquée</p>                                                                                                                                                       | ! |
| ! | <p><strong>List.TakeEveryNthItem</strong><br>Récupère les éléments de la liste indiquée aux index qui sont des multiples de la valeur indiquée, après le décalage indiqué.</p>                                                                                                       | ! |
| ! | <p><strong>List.Transpose</strong><br>Permute les lignes et les colonnes d’une liste de listes. Si certaines lignes sont plus courtes que d’autres, des valeurs nulles sont insérées en tant qu’espaces réservés dans le réseau résultant afin qu’il soit toujours rectangulaire</p> | ! |

## Logique

|                                                                                                                                                                                                  |                                                                                                                                                                                                                       |   |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|                                                                                                                                                                                                  | ACTIONS                                                                                                                                                                                                               |   |
| ![](https://769651524-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FYIQUByzZePieC1Y9fHzi%2Fuploads%2Fgit-blob-7309f56b92340e49cf9390a21ead106bcb987a0d%2FIf.jpg?alt=media) | <p><strong>Si</strong><br>Instruction conditionnelle. Vérifie la valeur booléenne de l'entrée de test. Si l’entrée de test est True, le résultat génère la valeur True, sinon le résultat génère la valeur False.</p> | ! |

## Math

|   |                                                                                                                                       |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | ACTIONS                                                                                                                               |   |
| ! | <p><strong>Math.Cos</strong><br>Trouve le cosinus d’un angle.</p>                                                                     | ! |
| ! | <p><strong>Math.DegreesToRadians</strong><br>Convertit un angle en degrés en angle en radians.</p>                                    | ! |
| ! | <p><strong>Math.Pow</strong><br>Élève un nombre à la puissance spécifiée.</p>                                                         | ! |
| ! | <p><strong>Math.RadiansToDegrees</strong><br>Convertit un angle en radians en angle en degrés.</p>                                    | ! |
| ! | <p><strong>Math.RemapRange</strong><br>Ajuste l’intervalle d’une liste de nombres, tout en conservant le rapport de distribution.</p> | ! |
| ! | <p><strong>Math.Sin</strong><br>Détermine le sinus d’un angle.</p>                                                                    | ! |
|   | <p><strong>Carte</strong><br>Mappe une valeur dans un intervalle d’entrée</p>                                                         | ! |

## String

|   |                                                                                                                                                          |   |
| - | -------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | ACTIONS                                                                                                                                                  |   |
| ! | <p><strong>String.Concat</strong><br>Concatène plusieurs chaînes en une seule chaîne.</p>                                                                | ! |
| ! | <p><strong>String.Contains</strong><br>Détermine si la chaîne indiquée contient la sous-chaîne indiquée.</p>                                             | ! |
| ! | <p><strong>String.Join</strong><br>Concatène plusieurs chaînes en une seule chaîne et insère le séparateur indiqué entre chaque chaîne jointe.</p>       | ! |
| ! | <p><strong>String.Split</strong><br>Divise une chaîne unique en une liste de chaînes, les chaînes de séparation indiquées déterminant les divisions.</p> | ! |
| ! | <p><strong>String.ToNumber</strong><br>Convertit une chaîne en nombre entier ou double.</p>                                                              | ! |

## Géométrie

### Circle

|   |                                                                                                                                                                           |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                                                     |   |
| ! | <p><strong>Circle.ByCenterPointRadius</strong><br>Crée un Circle à l'aide d'un point central d'entrée et un rayon dans le plan XY univers, avec l'univers Z standard.</p> | ! |
| ! | <p><strong>Circle.ByPlaneRadius</strong><br>Créer un Circle centré au niveau de l'origine du plan d'entrée (racine), dans le plan d'entrée, avec un rayon donné.</p>      | ! |

|   |                                                                                                                                                                                                               |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                                                                                         |   |
| ! | <p><strong>CoordinateSystem.ByOrigin</strong><br>Créer un CoordinateSystem avec une origine au point d’entrée, avec les axes X et Y définis en tant qu’axes X et Y SCG.</p>                                   | ! |
|   | <p><strong>CoordinateSystem.ByCylindricalCoordinates</strong><br>Crée un CoordinateSystem en fonction des paramètres de coordonnées cylindriques spécifiés par rapport au système de coordonnées spécifié</p> | ! |

### Cuboid

|   |                                                                                                                                                                                    |   |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                                                              |   |
| ! | <p><strong>Cuboid.ByLengths</strong><br>Permet de créer un nœud Cuboid centré au niveau de l’origine SCG, avec une largeur, une longueur et une hauteur.</p>                       | ! |
|   | <p><strong>Cuboid.ByLengths</strong> (origine)</p><p>Créer un Cuboid centré au point d'entrée, en fonction de la largeur, de la longueur et de la hauteur spécifiées.</p>          | ! |
|   | <p><strong>Cuboid.ByLengths</strong> (coordinateSystem)</p><p>Permet de créer un nœud Cuboid centré au niveau de l’origine SCG, avec une largeur, une longueur et une hauteur.</p> | ! |
|   | <p><strong>Cuboid.ByCorners</strong></p><p>Permet de créer un nœud Cuboid compris entre un point bas et un point haut.</p>                                                         | ! |
| ! | <p><strong>Cuboid.Length</strong></p><p>Permet de renvoyer les cotes d’entrée du nœud Cuboid, et NON les cotes réelles de l’espace univers. \*\*</p>                               | ! |
|   | <p><strong>Cuboid.Width</strong></p><p>Permet de renvoyer les cotes d’entrée du nœud Cuboid, et NON les cotes réelles de l’espace univers. \*\*</p>                                | ! |
|   | <p><strong>Cuboid.Height</strong></p><p>Permet de renvoyer les cotes d’entrée du nœud Cuboid, et NON les cotes réelles de l’espace univers. \*\*</p>                               | ! |
| ! | <p><strong>BoundingBox.ToCuboid</strong></p><p>Permet d’obtenir la zone de délimitation en tant que cuboïde solide.</p>                                                            | ! |

{% hint style="warning" %}
\*En d’autres termes, si vous créez un nœud Cuboid avec la largeur de l’axe X et la longueur 10, puis le transformez en CoordinateSystem avec une échelle de 2 dans X, la largeur sera toujours 10. ASM ne vous permet pas d’extraire les sommets d’un corps dans un ordre prévisible. Il est donc impossible de déterminer les cotes après une transformation.
{% endhint %}

### Curve

|   |                                                                                                                                                   |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | ACTIONS                                                                                                                                           |   |
| ! | <p><strong>Curve.Extrude</strong> (distance)<br>Extrude une Curve dans la direction du vecteur de la normale.</p>                                 | ! |
| ! | <p><strong>Curve.PointAtParameter</strong><br>Obtenir un point sur la Curve à un paramètre spécifié entre StartParameter() et EndParameter().</p> | ! |

### Geometry Modifiers

|   |                                                                                                                                                           |   |
| - | --------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | ACTIONS                                                                                                                                                   |   |
| ! | <p><strong>Geometry.DistanceTo</strong><br>Obtenir la distance entre cette géométrie et une autre.</p>                                                    | ! |
| ! | <p><strong>Geometry.Explode</strong><br>Sépare les éléments composés ou non séparés dans leurs composants</p>                                             | ! |
| ! | <p><strong>Geometry.ImportFromSAT</strong><br>Liste des géométries importées</p>                                                                          | ! |
| ! | <p><strong>Geometry.Rotate</strong> (basePlane)<br>Fait pivoter l’objet autour de l’origine et de la normale du plan en fonction d’un degré spécifié.</p> | ! |
| ! | <p><strong>Geometry.Translate</strong><br>Convertit tout type de géométrie selon la distance donnée dans la direction donnée.</p>                         | ! |

### Ligne

|   |                                                                                                                                                                                    |   |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                                                              |   |
| ! | <p><strong>Line.ByBestFitThroughPoints</strong><br>Crée une ligne représentant au mieux un diagramme de dispersion de points.</p>                                                  | ! |
| ! | <p><strong>Line.ByStartPointDirectionLength</strong><br>Créer une ligne droite partant du point, s’étendant dans la direction du vecteur en fonction de la longueur spécifiée.</p> | ! |
| ! | <p><strong>Line.ByStartPointEndPoint</strong><br>Crée une ligne droite entre deux points d’entrée.</p>                                                                             | ! |
| ! | <p><strong>Line.ByTangency</strong><br>Créer une ligne tangente à la Curve d’entrée, située sur le point paramétrique de la Curve d’entrée.</p>                                    | ! |
|   | REQUETE                                                                                                                                                                            |   |
| ! | <p><strong>Line.Direction</strong><br>Direction de la Curve.</p>                                                                                                                   | ! |

### NurbsCurve

|   |                                                                                                                        |   |
| - | ---------------------------------------------------------------------------------------------------------------------- | - |
|   | Créer                                                                                                                  |   |
| ! | <p><strong>NurbsCurve.ByControlPoints</strong><br>Crée une BSplineCurve à l’aide de points de contrôle explicites.</p> | ! |
| ! | <p><strong>NurbsCurve.ByPoints</strong><br>Créer une BSplineCurve par interpolation entre des points</p>               | ! |

### NurbsSurface

|   |                                                                                                                                                                                      |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | - |
|   | Créer                                                                                                                                                                                |   |
| ! | <p><strong>NurbsSurface.ByControlPoints</strong><br>Créer une NurbsSurface en utilisant des points de contrôle explicites avec les degrés U et V indiqués.</p>                       | ! |
| ! | <p><strong>NurbsSurface.ByPoints</strong><br>Crée une NurbsSurface avec des points interpolés et des degrés U et V spécifiés. La surface résultante passera par tous les points.</p> | ! |

### Plan

|   |                                                                                                                                           |   |
| - | ----------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                     |   |
| ! | <p><strong>Plane.ByOriginNormal</strong><br>Créer un plan centré au niveau du point d’origine, avec le vecteur de la normal d’entrée.</p> | ! |
| ! | <p><strong>Plane.XY</strong><br>Crée un plan dans l’univers XY</p>                                                                        | ! |

### Point

|   |                                                                                                                                                                    |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | - |
|   | CREER                                                                                                                                                              |   |
| ! | <p><strong>Point.ByCartesianCoordinates</strong><br>Former un point dans le système de coordonnées indiqué avec trois coordonnées cartésiennes</p>                 | ! |
| ! | <p><strong>Point.ByCoordinates</strong> (2d)<br>Former un point dans le plan XY en fonction de deux coordonnées cartésiennes. Le composant Z est défini sur 0.</p> | ! |
| ! | <p><strong>Point.ByCoordinates</strong> (3d)<br>Former un point en fonction de 3 coordonnées cartésiennes.</p>                                                     | ! |
| ! | <p><strong>Point.Origin</strong><br>Obtenir le point d’origine (0,0,0)</p>                                                                                         | ! |
|   | ACTIONS                                                                                                                                                            |   |
| ! | <p><strong>Point.Add</strong><br>Ajouter un vecteur à un point. Il en va de même pour l’option Conversion (vecteur).</p>                                           | ! |
|   | REQUETE                                                                                                                                                            |   |
| ! | <p><strong>Point.X</strong><br>Obtenir le composant X d’un point</p>                                                                                               | ! |
| ! | <p><strong>Point.Y</strong><br>Obtenir le composant Y d’un point</p>                                                                                               | ! |
| ! | <p><strong>Point.Z</strong><br>Obtenir le composant Z d’un point</p>                                                                                               | ! |

### Polycourbe

|   |                                                                                                                                                                                                                       |   |
| - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                                                                                                 |   |
| ! | <p><strong>Polycurve.ByPoints</strong><br>Créer une polycourbe à partir d’une séquence de lignes connectant des points. Pour la courbe fermée, le dernier point doit être au même endroit que le point de départ.</p> | ! |

### Rectangle

|   |                                                                                                                                                                                                                                             |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                                                                                                                       |   |
| ! | <p><strong>Rectangle.ByWidthLength</strong> (Plane)<br>Créer un rectangle centré au niveau de la racine du plan d'entrée, avec la largeur d'entrée (longueur de l'axe X du plan) et la longueur d'entrée (longueur de l'axe Y du plan).</p> | ! |

### Sphere

|   |                                                                                                                                         |   |
| - | --------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                   |   |
| ! | <p><strong>Sphere.ByCenterPointRadius</strong><br>Créer une sphère solide centrée au niveau du point d’entrée, avec un rayon donné.</p> | ! |

### Surface

|   |                                                                                                                                                                                          |   |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                                                                    |   |
| ! | <p><strong>Surface.ByLoft</strong><br>Créer un nœud Surface par lissage entre les nœuds Curves de profil de coupe d’entrée</p>                                                           | ! |
| ! | <p><strong>Surface.ByPatch</strong><br>Créer un nœud Surface en remplissant l’intérieur d’un contour fermé défini par les nœuds Curves d’entrée.</p>                                     |   |
|   | ACTIONS                                                                                                                                                                                  |   |
| ! | <p><strong>Surface.Offset</strong><br>Décaler la surface dans la direction de la normale de surface selon une distance spécifiée</p>                                                     | ! |
|   | <p><strong>Surface.PointAtParameter</strong><br>Renvoyer le point avec les paramètres U et V indiqués.</p>                                                                               | ! |
|   | <p><strong>Surface.Thicken</strong><br>Épaissir la surface dans un solide, en réalisant une extrusion dans la direction des normales de la surface sur les deux côtés de la surface.</p> | ! |

### UV

|   |                                                                                   |   |
| - | --------------------------------------------------------------------------------- | - |
|   | CREER                                                                             |   |
| ! | <p><strong>UV.ByCoordinates</strong><br>Créer un UV à partir de deux doubles.</p> | ! |

### Vecteur

|   |                                                                                                          |   |
| - | -------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                    |   |
| ! | <p><strong>Vector.ByCoordinates</strong><br>Former un vecteur à l’aide de 3 coordonnées euclidiennes</p> | ! |
|   | <p><strong>Vector.XAxis</strong><br>Obtient le vecteur d’axe X canonique (1,0,0)</p>                     | ! |
|   | <p><strong>Vector.YAxis</strong><br>Obtient le vecteur d’axe Y canonique (0,1,0)</p>                     | ! |
|   | <p><strong>Vector.ZAxis</strong><br>Obtient le vecteur d’axe Z canonique (0,0,1)</p>                     | ! |
|   | ACTIONS                                                                                                  |   |
| ! | <p><strong>Vector.Normalized</strong><br>Obtenir la version normalisée d’un vecteur</p>                  | ! |

## CoordinateSystem

|   |                                                                                                                                                                                                               |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CREER                                                                                                                                                                                                         |   |
| ! | <p><strong>CoordinateSystem.ByOrigin</strong><br>Créer un CoordinateSystem avec une origine au point d’entrée, avec les axes X et Y définis en tant qu’axes X et Y SCG.</p>                                   | ! |
|   | <p><strong>CoordinateSystem.ByCylindricalCoordinates</strong><br>Crée un CoordinateSystem en fonction des paramètres de coordonnées cylindriques spécifiés par rapport au système de coordonnées spécifié</p> | ! |

## Opérateurs

|   |                                                                                                                                      |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------ | - |
| ! | <p><strong>+</strong><br>Addition</p>                                                                                                | ! |
| ! | <p><strong>-</strong><br>Soustraction</p>                                                                                            | ! |
| ! | <p><strong>\*</strong><br>Multiplication</p>                                                                                         | ! |
| ! | <p><strong>/</strong><br>Division</p>                                                                                                | ! |
|   | <p><strong>%</strong><br>La division modulaire recherche le reste de la première entrée après la division par la deuxième entrée</p> | ! |
|   | <p><strong><</strong><br>Inférieur à</p>                                                                                             | ! |
| ! | <p><strong>></strong><br>Supérieur à</p>                                                                                             | ! |
| ! | <p><strong>==</strong><br>L’égalité des deux valeurs est un test d’égalité.</p>                                                      | ! |
