> For the complete documentation index, see [llms.txt](https://primer2.dynamobim.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://primer2.dynamobim.org/fr/5_essential_nodes_and_concepts/index-of-nodes.md).
# 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 | |
|  | Color.ByARGB
Créer une couleur au moyen de composants alpha, rouges, verts et bleus.
|  |
|  | Intervalles de couleurs
Obtenir une couleur à partir d'un dégradé de couleurs entre une couleur de départ et une couleur de fin.
|  |
| | ACTIONS | |
|  | Color.Brightness
Obtient la valeur de luminosité de cette couleur.
|  |
|  | Color.Components
Répertorie les composants de la couleur dans l’ordre suivant : alpha, rouge, vert, bleu.
|  |
|  | Color.Saturation
Obtient la valeur de saturation de cette couleur.
|  |
|  | Color.Hue
Obtient la valeur de teinte de cette couleur.
|  |
| | REQUETE | |
|  | Color.Alpha
Rechercher le composant alpha d’une couleur, de 0 à 255.
|  |
|  | Color.Blue
Rechercher le composant bleu d’une couleur, de 0 à 255.
|  |
|  | Color.Green
Rechercher le composant vert d’une couleur, de 0 à 255.
|  |
|  | Color.Red
Rechercher le composant rouge d’une couleur, de 0 à 255.
|  |
| | | |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | GeometryColor.ByGeometryColor
Affiche la géométrie à l'aide d'une couleur.
|  |
### Watch
| | | |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | ACTIONS | |
|  | View\.Watch
Visualiser la sortie du nœud.
|  |
|  | View\.Watch 3D
Affiche un aperçu dynamique de la géométrie.
|  |
## Entrée
| | | |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | ACTIONS | |
|  | Opération booléenne
Sélection entre True et False.
|  |
|  | Code Block
Permet de créer le code DesignScript directement.
|  |
|  | Chemin de répertoire
Permet de sélectionner un répertoire sur le système pour obtenir son chemin d’accès
|  |
|  | Chemin du fichier
Permet de sélectionner un fichier sur le système, de façon à obtenir son nom de fichier
|  |
|  | Integer Slider
Curseur qui génère des valeurs entières.
|  |
|  | Nombre
Permet de créer un nombre.
|  |
|  | Curseur de nombre
Curseur qui génère des valeurs numériques.
|  |
|  | Chaîne
Crée une chaîne.
|  |
|  | Object.IsNull
Détermine si l’objet indiqué est nul.
|  |
## List
| | | |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | List.Create
Permet de créer une liste des entrées indiquées.
|  |
|  | List.Combine
Applique un combinateur à chaque élément en deux séquences
|  |
|  | Number Range
Crée une séquence de nombres dans l’intervalle spécifié
|  |
|  | Number Sequence
Crée une série de numéros.
|  |
| | ACTIONS | |
|  | List.Chop
Couper une liste en un ensemble de listes contenant chacune le nombre donné d’éléments.
|  |
|  | List.Count
Renvoie le nombre d’éléments stockés dans la liste indiquée.
|  |
|  | List.Flatten
Aplanit une liste imbriquée de listes en fonction d’une quantité spécifique.
|  |
|  | List.FilterByBoolMask
Filtre une séquence en recherchant les index correspondants dans une liste distincte de booléens.
|  |
|  | List.GetItemAtIndex
Obtient un élément de la liste indiquée qui se trouve au niveau de l’index spécifié.
|  |
| | List.Map
Applique une fonction sur tous les éléments d’une liste, générant une nouvelle liste à partir des résultats
|  |
| | List.Reverse
Crée une liste contenant les éléments de la liste indiquée, mais dans l’ordre inverse
|  |
|  | List.ReplaceItemAtIndex
Remplacer un élément de la liste indiquée qui se trouve au niveau de l’index spécifié
|  |
|  | List.ShiftIndices
Décale les index dans la liste vers la droite en fonction de la quantité indiquée
|  |
|  | List.TakeEveryNthItem
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é.
|  |
|  | List.Transpose
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
|  |
## Logique
| | | |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | ACTIONS | |
|  | Si
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.
|  |
## Math
| | | |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | ACTIONS | |
|  | Math.Cos
Trouve le cosinus d’un angle.
|  |
|  | Math.DegreesToRadians
Convertit un angle en degrés en angle en radians.
|  |
|  | Math.Pow
Élève un nombre à la puissance spécifiée.
|  |
|  | Math.RadiansToDegrees
Convertit un angle en radians en angle en degrés.
|  |
|  | Math.RemapRange
Ajuste l’intervalle d’une liste de nombres, tout en conservant le rapport de distribution.
|  |
|  | Math.Sin
Détermine le sinus d’un angle.
|  |
|  | Carte
Mappe une valeur dans un intervalle d’entrée
|  |
## String
| | | |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | ACTIONS | |
|  | String.Concat
Concatène plusieurs chaînes en une seule chaîne.
|  |
|  | String.Contains
Détermine si la chaîne indiquée contient la sous-chaîne indiquée.
|  |
|  | String.Join
Concatène plusieurs chaînes en une seule chaîne et insère le séparateur indiqué entre chaque chaîne jointe.
|  |
|  | String.Split
Divise une chaîne unique en une liste de chaînes, les chaînes de séparation indiquées déterminant les divisions.
|  |
|  | String.ToNumber
Convertit une chaîne en nombre entier ou double.
|  |
## Géométrie
### Circle
| | | |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | Circle.ByCenterPointRadius
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.
|  |
|  | Circle.ByPlaneRadius
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é.
|  |
| | | |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | CoordinateSystem.ByOrigin
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.
|  |
|  | CoordinateSystem.ByCylindricalCoordinates
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é
|  |
### Cuboid
| | | |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| | CREER | |
|  | Cuboid.ByLengths
Permet de créer un nœud Cuboid centré au niveau de l’origine SCG, avec une largeur, une longueur et une hauteur.
|  |
|  | Cuboid.ByLengths (origine)
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.
|  |
|  | Cuboid.ByLengths (coordinateSystem)
Permet de créer un nœud Cuboid centré au niveau de l’origine SCG, avec une largeur, une longueur et une hauteur.
|  |
|  | Cuboid.ByCorners
Permet de créer un nœud Cuboid compris entre un point bas et un point haut.
|  |
|  | Cuboid.Length
Permet de renvoyer les cotes d’entrée du nœud Cuboid, et NON les cotes réelles de l’espace univers. \*\*
|  |
|  | Cuboid.Width
Permet de renvoyer les cotes d’entrée du nœud Cuboid, et NON les cotes réelles de l’espace univers. \*\*
|  |
|  | Cuboid.Height
Permet de renvoyer les cotes d’entrée du nœud Cuboid, et NON les cotes réelles de l’espace univers. \*\*
|  |
|  | BoundingBox.ToCuboid
Permet d’obtenir la zone de délimitation en tant que cuboïde solide.
|  |
{% 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 | |
|  | Curve.Extrude (distance)
Extrude une Curve dans la direction du vecteur de la normale.
|  |
|  | Curve.PointAtParameter
Obtenir un point sur la Curve à un paramètre spécifié entre StartParameter() et EndParameter().
|  |
### Geometry Modifiers
| | | |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | ACTIONS | |
|  | Geometry.DistanceTo
Obtenir la distance entre cette géométrie et une autre.
|  |
|  | Geometry.Explode
Sépare les éléments composés ou non séparés dans leurs composants
|  |
|  | Geometry.ImportFromSAT
Liste des géométries importées
|  |
|  | Geometry.Rotate (basePlane)
Fait pivoter l’objet autour de l’origine et de la normale du plan en fonction d’un degré spécifié.
|  |
|  | Geometry.Translate
Convertit tout type de géométrie selon la distance donnée dans la direction donnée.
|  |
### Ligne
| | | |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | Line.ByBestFitThroughPoints
Crée une ligne représentant au mieux un diagramme de dispersion de points.
|  |
|  | Line.ByStartPointDirectionLength
Créer une ligne droite partant du point, s’étendant dans la direction du vecteur en fonction de la longueur spécifiée.
|  |
|  | Line.ByStartPointEndPoint
Crée une ligne droite entre deux points d’entrée.
|  |
|  | Line.ByTangency
Créer une ligne tangente à la Curve d’entrée, située sur le point paramétrique de la Curve d’entrée.
|  |
| | REQUETE | |
|  | Line.Direction
Direction de la Curve.
|  |
### NurbsCurve
| | | |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| | Créer | |
|  | NurbsCurve.ByControlPoints
Crée une BSplineCurve à l’aide de points de contrôle explicites.
|  |
|  | NurbsCurve.ByPoints
Créer une BSplineCurve par interpolation entre des points
|  |
### NurbsSurface
| | | |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | Créer | |
|  | NurbsSurface.ByControlPoints
Créer une NurbsSurface en utilisant des points de contrôle explicites avec les degrés U et V indiqués.
|  |
|  | NurbsSurface.ByPoints
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.
|  |
### Plan
| | | |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | Plane.ByOriginNormal
Créer un plan centré au niveau du point d’origine, avec le vecteur de la normal d’entrée.
|  |
|  | Plane.XY
Crée un plan dans l’univers XY
|  |
### Point
| | | |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | Point.ByCartesianCoordinates
Former un point dans le système de coordonnées indiqué avec trois coordonnées cartésiennes
|  |
|  | Point.ByCoordinates (2d)
Former un point dans le plan XY en fonction de deux coordonnées cartésiennes. Le composant Z est défini sur 0.
|  |
|  | Point.ByCoordinates (3d)
Former un point en fonction de 3 coordonnées cartésiennes.
|  |
|  | Point.Origin
Obtenir le point d'origine (0,0,0)
|  |
| | ACTIONS | |
|  | Point.Add
Ajouter un vecteur à un point. Il en va de même pour l’option Conversion (vecteur).
|  |
| | REQUETE | |
|  | Point.X
Obtenir le composant X d’un point
|  |
|  | Point.Y
Obtenir le composant Y d’un point
|  |
|  | Point.Z
Obtenir le composant Z d’un point
|  |
### Polycourbe
| | | |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | Polycurve.ByPoints
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.
|  |
### Rectangle
| | | |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| | CREER | |
|  | Rectangle.ByWidthLength (Plane)
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).
|  |
### Sphere
| | | |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| | CREER | |
|  | Sphere.ByCenterPointRadius
Créer une sphère solide centrée au niveau du point d’entrée, avec un rayon donné.
|  |
### Surface
| | | |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | Surface.ByLoft
Créer un nœud Surface par lissage entre les nœuds Curves de profil de coupe d’entrée
|  |
|  | Surface.ByPatch
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.
|  |
| | ACTIONS | |
|  | Surface.Offset
Décaler la surface dans la direction de la normale de surface selon une distance spécifiée
|  |
|  | Surface.PointAtParameter
Renvoyer le point avec les paramètres U et V indiqués.
|  |
|  | Surface.Thicken
É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.
|  |
### UV
| | | |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | UV.ByCoordinates
Créer un UV à partir de deux doubles.
|  |
### Vecteur
| | | |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| | CREER | |
|  | Vector.ByCoordinates
Former un vecteur à l’aide de 3 coordonnées euclidiennes
|  |
|  | Vector.XAxis
Obtient le vecteur d’axe X canonique (1,0,0)
|  |
|  | Vector.YAxis
Obtient le vecteur d’axe Y canonique (0,1,0)
|  |
|  | Vector.ZAxis
Obtient le vecteur d’axe Z canonique (0,0,1)
|  |
| | ACTIONS | |
|  | Vector.Normalized
Obtenir la version normalisée d’un vecteur
|  |
## CoordinateSystem
| | | |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | CREER | |
|  | CoordinateSystem.ByOrigin
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.
|  |
|  | CoordinateSystem.ByCylindricalCoordinates
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é
|  |
## Opérateurs
| | | |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|  | +
Addition
|  |
|  | -
Soustraction
|  |
|  | \*
Multiplication
|  |
|  | /
Division
|  |
|  | %
La division modulaire recherche le reste de la première entrée après la division par la deuxième entrée
|  |
|  | <
Inférieur à
|  |
|  | >
Supérieur à
|  |
|  | ==
L’égalité des deux valeurs est un test d’égalité.
| |