Dernière mise à jour le 30 avril 2021 par LMD

Grasshopper offre un ensemble d’outils pour structurer les flux de données (dans leur diversité). Les données circulant de paramètre en composant et de composant en composant sont structurés. Grasshopper dispose de 2 structures permettant leurs organisation:
les listes et les arbres de données(non traités ici).

LES LISTES
Une liste est un contenant stockant les informations créées dans gh que ce soit des géométries ou des données. Les listes dans gh possèdent un indice, sont ordonnées et débutent en 0 (le premier item d’une liste est donc l’item 0 – et non 1). Le dernier indice d’une liste constituée de n items est n-1 !

Les composants pour la gestion des listes se trouvent dans Sets>List

CRÉATION D’UN MODÈLE PARAMÉTRIQUE GÉNÉRANT DES LISTES DE DONNÉES

OBJECTIF: Division d’une ligne en 5 portions à partir de points A & B GROUPES
Coordonnées Points A&B
Division ligne
COMPOSANTS
Vector<Point<Construct Point
Curve<Primitive<Ligne
Curve<Division<Divide Curve
Display<Dimension<Tag
Params> Input>Number slider
Params>input>Panel

DÉROULÉ
La division sera réalisée grâce au composant Curve> Division>Divide Curve dont l’entrée C sera connectée à la sortie L du composant Line afin de récupérer la géométrie à diviser. Le nombre de divisions est à définir via un composant Number Slider variant de 1 à 10. Cette opération permet d’obtenir 6 points équidistants situés sur la ligne.
La modification du nombre de divisions entraînera la génération de nouveaux points et la disparition des sommets précédents. Les points sont marqués au niveau de la géométrie par des croix..
Dupliquez la ligne pour avoir deux lignes

Les points sont aussi affichés au niveau de l’algorithme sous la forme d’une liste indexée visualisable en connectant la sortie P (intégrant les points) à l’entrée d’un composant Params>Input>Panel.

Composant Params>Input>Panel

Chaque ligne du Panel correspond à un point avec un ordre qui permet d’identifier chaque élément de la liste. Cet identifiant appelé indice ou index est un entier qui commence à 0 comme identifiant du premier élément de la liste (le point A). Le sixième et dernier élément de la liste situé à la sixième ligne est caractérisé par son identifiant 5 (le point B). Pour chacun des points, Grasshopper affiche les coordonnées X, Y et Z avec une écriture bien précise entre crochets, {X, Y, Z}, potentiellement exploitable pour structurer de nouvelles activités de création ou d’analyse de géométries. L’affichage de cet ordre ne se fait que via le composant Panel et non directement dans la géométrie
affichée dans l’environnement Rhinoceros.
Pour contourner ce problème, il est conseillé d’utiliser l’outil Display>Vector>Point List pour afficher cet ordre (indice) aussi sur la géométrie.
Il y a ainsi une parfaite correspondance entre la liste des points et leur localisation au niveau de la géométrie.

LES MODES DE TRAITEMENTS DES LISTES PAR LES COMPOSANTS Gh

Les composants Grasshopper proposent différents modes de traitement des listes. Ces modes dépendent particulièrement du nombre d’éléments (géométriques ou autres) qui figurent dans les listes.

Dans le premier cas, le nombre d’éléments est le même dans les listes A et B.
Le composant reliant ces deux listes reliera chaque élément de la liste A à l’élément correspondant (ayant le même ordre de classement) dans la liste B.

Dans le deuxième cas, le nombre d’éléments dans la liste A est supérieur à celui de la liste B (6 contre 4).

Le composant reliant ces deux listes reliera chaque élément de la liste A à l’élément correspondant (ayant le même ordre de classement) jusqu’au dernier élément de liste B (le 4e).Le reste des éléments de la liste A sera connecté répétitivement au dernier élément de la liste B

Dans le troisième cas, la liste A comporte 6 éléments alors que la liste B n’en contient qu’un seul.
Ce dernier sera connecté à l’ensemble des éléments de la liste A.
La permutation entre la liste A et la liste B n’a aucun effet sur la gestion des liens entre les deux listes d’origine.

SÉLECTION PAR IDENTIFIANT (INDICE)

Composant List Item

L’ outil de gestion de listes (l’un des plus exploités) Sets>List>List Item
permet de sélectionner un ou plusieurs éléments d’une liste en exploitant leur indice (ordre de classement dans la liste).
Le schéma de fonctionnement de cet outil est assez simple, il suffit de le connecter à une liste d’éléments (tout type d’élément) et de définir un ou plusieurs indices (ordre) d’éléments. Chaque élément de la liste dont l’indice est mentionné sera sélectionné.
Le composant List Item fait partie des composants qui ne génèrent pas de géométrie, mais traitent différents types de données. La liste traitée sera connectée à l’entrée L du composant List Item. Cet outil permet de sélectionner un élément de la liste ce qui implique la définition d’un indice (nombre entier) à connecter à l’entrée i. Cet indice peut
être défini via un composant Number Slider générant des entiers connectés à la même entrée ou un composant Panel dans lequel est saisi la valeur correspondant à l’indice.
Notez la possibilité à l’aide d’un zoom et du + de lister les items i+1, i+2. Préférez cette méthode à celle consistant à ajouter 2 composants List Item côte à côte…..
L’entrée w(wrap) enrouler permet à l’indice, si celui-ci est supérieur à la valeur du dernier indice, de « revenir » au début de la liste. Ce paramètre booléen (Vrai/Faux) est vrai par défaut.

Le composant List Item offre la possibilité de sélectionner plusieurs éléments d’une même liste en indiquant différents indices simultanément à l’entrée i. Il est possible de réaliser cette tâche
en connectant plusieurs composants Number Slider à l’entrée i. Cependant, ce mode ne permet pas de bien définir l’ordre des connexions. Nous conseillons d’utiliser le composant Sets>Tree>Merge qui permet de rassembler plusieurs entrées en une seule en offrant le choix de l’ordre des connexions.

Cette sélection multiple est aussi possible via le composant Panel qui subira une transformation pour intégrer plusieurs lignes de données. Pour réaliser cette transformation, il convient d’effectuer un clic droit au centre du composant Panel et de choisir ensuite l’option Multiline
Data. Pour saisir les indices, il suffit de double-cliquer au centre du composant Panel, de saisir chaque valeur, puis de le valider en cliquant en dehors du composant Panel. Attention à ne pas valider la dernière valeur saisie en appuyant sur la touche Entrée, ce qui risque de créer une
ligne de données vide (indiquée Empty).

EX2: Liaison entre un groupe de points et un autre point unique,
Matérialisation:
Nous utilisons le composant List Item pour extraire un point ayant l’indice n° 0 de la liste A’B’. Ce dernier sera ensuite relié à l’ensemble (les 6 points) de la liste AB.

EX3: Relier par alternance les deux groupes de points AB et A’B’ (un point sur deux)
Matérialisation:
Nous exploitons le composant List Item lié à un Panel pour indiquer les identifiants des points à sélectionner pour créer les segments de droites. Ces derniers ont les indices suivants : 0, 2 et 4.

EX4: Relier par alternance les deux groupes de points AB et A’B’ (un point sur deux) avec des segments de droites obliques reliant les points 0, 2 et 4 du groupe AB et les points 1, 3 et 5 du groupe A’B’..

SÉLECTION PAR ÉTAT

Composant Sets>Sequence>Cull Pattern

permet de définir un rythme de sélection et de non-sélection définie par un état (opération booléenne)
Si la donnée d’entrée est égale à vrai (True), l’élément est sélectionné ;
Si cette valeur est égale à faux (False), il ne l’est pas.
Cet outil permet d’appliquer ce mode de sélection à l’ensemble des éléments de la liste d’entrées en suivant le même rythme. Dans le premier cas, l’état True est appliqué à l’ensemble des éléments de la liste d’entrées ce qui permet de les sélectionner tous.
Concrètement, à l’entrée L du composant est connectée la liste des éléments, tandis que son entrée P reçoit les états logiques de sélection, générés ici par un composant Panel.
À la sortie L, ce composant va restituer les seuls éléments sélectionnés, conformément à la logique d’états affichés sur l’entrée P.

Lorsque l’état False est appliqué à l’ensemble des éléments de la liste d’entrées aucun élément n’est sélectionné.

Une alternance entre l’état True et False appliquée à l’ensemble des éléments de la liste d’entrées permet de sélectionner le premier élément, de refuser le suivant et ceci de façon répétitive jusqu’au dernier élément. La reproduction du rythme s’effectue même si le nombre d’éléments de la liste dispose d’une parité différente de celle du nombre d’états.
Ce qui différencie le composant Cull Pattern du composant List Item c’est sa capacité à s’adapter à une modification au niveau de la liste des entrées.

Composant Sets>Sequence>Dispatch

L’usage du composant Cull Pattern est intéressant pour les sélections, mais il limite les applications possibles dans la mesure où il exclut (supprime) une partie des objets qui ne vérifient pas les conditions. Pour mettre en place une démarche de sélection encore plus dynamique,
nous allons utiliser un composant d’aiguillage des données selon leurs états respectifs.
Il s’agit du composant Sets>List>Dispatch qui filtre les objets et les aiguille :
• sortie A : si état = True (vrai) ;
• sortie B : si état = False (faux).
Si un seul état True est appliqué à l’ensemble des éléments, tous sont aiguillés vers la sortie A.

Dans le cas où un seul état False est appliqué à l’ensemble des éléments, tous sont aiguillés vers la sortie B.

Si une alternance d’états True/False est appliquée aux éléments d’une liste d’entrées, l’état True est appliqué à l’élément 0 afin de le diriger vers la sortie A, et l’état False est appliqué à l’élément 1 pour le diriger vers la sortie B et ainsi de suite, jusqu’au dernier élément de la liste.
En appliquant cette alternance, le composant Dispatch permet de diriger les éléments 0, 2 et 4 vers la sortie A et les éléments 1, 3 et 5 vers la sortie B.

exemple: gestion sphères et cubes sur une ligne
Nous appliquons ce composant dans une logique de sélection conditionnée de points, mais cette fois en essayant de les répartir en deux groupes avec des traitements visuels différents :
• groupe 1 : points qui vérifient la condition avec un marquage par des sphères ;
• groupe 2 : points qui ne vérifient pas la condition avec un marquage par des cubes (Surface>Primitive>Center Box).
Pour obtenir les deux groupes de points, nous allons récupérer la dernière chaîne paramétrique réalisée et remplacer le composant Cull Pattern par le composant Dispatch. Il suffit ensuite de connecter la sortie A du composant Dispatch à l’entrée B du composant Sphere et la sortie B à l’entrée du composant Center Box

Composant List Length (Longueur de la liste)

EX1: Liaison entre deux groupes de points (nombre de points différents entre les deux groupes)
Matérialisation
Reliez par des segments de droite deux listes intégrant un nombre de points différents. Nous utilisons le composant List Item pour extraire les points ayant les indices n° 0, 1, 2 et 3 de la liste A’B’. Les points sélectionnés sont ensuite reliés à l’ensemble (les 6 points) de la liste AB.
Le composant List Length permet d’obtenir le nombre d’items d’une liste. L’indice du dernier item d’une liste de N, dont aucun item n’a été supprimé à l’aide de composant CULL par exemple, est N-1. Ainsi dans l’exemple ci-dessous, la liste est constituée de 5 items dont l’indice du dernier est 4.

Composant Cross reference

relié au composant Divide de chaque courbe et suivi du composant Lenght, le composant Cross Reference permet de relier chaque point d’une courbe à chaque point d’une autre courbe.

Composant Reverse List (Inverser ordre de la Liste)

Reverse liste permet d’inverser l’ordre des items d’une liste. Le premier item devient le dernier, et inversement. Ainsi dans l’exemple suivant, la liste le dernier item valeur ‘3’ se place en début de liste à l’indice 0.

Split List (Diviser Liste)

Split List permet de scinder une liste en 2

DÉCALAGE D’ÉLÉMENTS D’UNE LISTE

Composant Shift List (Décaler Liste)

Dans cette section, nous abordons un outil de transformation qui affecte l’ordre et le nombre d’éléments d’une liste. Ainsi, le composant Sets>List>Shift List crée un décalage positif ou négatif d’un élément d’une liste avec une option de suppression sur sa troisième entrée (notée W pour wrap, monter ou descendre le rang d’un élément). Le nombre de pas de décalage est fixé sur sa deuxième entrée (notée S, comme Shift).
Dans l’exemple ci-dessous, la liste de 6 items est décalée de 3 positions. Ainsi la valeur 3 passe de la position 3 à la position 0. La valeur 4 passe à la position 1.
Avec l’option W (rap) vrai (True) activée par défaut, l’item 0 se positionne derrière la dernière valeur de la liste initiale (5) en position 3. Avec l’option W(rap) désactivée (Faux) la liste est tronquée des 3 premières valeurs de la liste.

Dans le cas où le décalage est de 1 avec la fonction de boucle activée,
le composant Shift décale la liste de 1 vers le haut, ce qui permet de décaler l’élément 0 de rang 1 au rang 6 en gardant le même nombre total d’éléments.

Dans le cas où le décalage est de -1 avec la fonction de boucle activée, le composant Shift décale la liste de 1 vers le bas, ce qui permet de décaler l’élément 0 de rang 1 au rang 2 en gardant le même nombre total de points.

Dans le cas où le décalage est de 2 avec la fonction de boucle activée, le composant Shiftdécale la liste de 2 vers le haut, ce qui permet de décaler l’élément 0 de rang 1 au rang 5 et l’élément 1 de rang 2 au rang 6 en gardant le même nombre total de points.

Dans le cas où le décalage est de 1 avec la fonction de boucle non activée, le composant Shift décale la liste de 1 vers le haut, ce qui permet de supprimer l’élément 0 de rang 1 de la liste.
L’élément 1 de rang 2 passe ainsi au rang 1.

RÉCAPITULATIF DES ÉLÉMENTS DE GESTION DE LISTES IMPORTANTS

MODÈLE PARAMÉTRIQUE DE DEUX CERCLES DIVISÉS EN 10 PORTIONS

Pour créer le 1er cercle, nous utilisons le composant Curve>Primitive>Circle. Ce dernier sera placé sur le plan XY matérialisé par le composant Vector>Plane>XY Plane. Ce plan sera par défaut placé à l’origine des axes. La sortie P, unique, du composant XY Plane représente
le repère cartésien local (nommé « plane ») facilitant le repérage des coordonnées des objets dans cette partie de l’espace. Cette sortie sera connectée à l’entrée P du composant Circle. Le rayon du cercle est défini par un Number Slider (variant de 0 à 10), connecté à l’entrée R du composant Circle. Pour nommer ce cercle, nous utilisons le composant Display>Dimensions>Text Tag connecté à un composant Panel et comportant la lettre A.
Nous divisons ce cercle en 10 portions en exploitant le composant Curve>Division>Divide Curve.
Par ailleurs, nous exploitons le composant Display>Vector>Point List pour marquer les points délimitant les tronçons. Son entrée P est connectée à la liste de points de division, et son entrée S à un composant Number Slider pour définir la taille d’affichage des indices des points.

Nous dupliquons cette chaîne paramétrique pour créer un deuxième cercle portant les mêmes propriétés de division et d’affichage des sommets. Ce cercle sera déplacé de 4 unités dans la direction de l’axe Z en exploitant le composant Transform>Euclidean>Move dont l’entrée G
sera liée à la sortie C du premier cercle créé. L’entrée T sera en revanche reliée à un composant générant un vecteur dans l’axe Z (composant Vector>Vector>Unit Z) dont l’amplitude est définie via un composant Number Slider. La division du deuxième cercle et l’affichage des
points de division seront effectués selon le même scénario que pour le premier cercle.

lier les deux listes de points de division avec un décalage de 1 pas de la
liste B

Si le décalage vaut 2, les segments sont inclinés. Une fois reliés entre eux, ils génèrent un hyperboloïde plus accentué.

POUR VOUS ENTRAÎNER…

EXERCICE A
A partir de deux cercles divisés par des points, générez les figures ci dessus en vous servant des listes et de leurs outils.

Remarque: les cercles importés de rhino seront dessinés tous les deux avec le même départ.

COMPOSANTS
Figure 2&3
SET>LIST>SHIFT LIST
PARAMS>INPUT>PANEL

Figure 4
SET>LIST>CULL
PARAMS>INPUT>PANEL

Figure 5
SET>LIST>JITTER

Figure 6
SET>LIST>CULL
PARAMS>INPUT>PANEL

Figure 7
SET>LIST>REVERSE LIST

Figure 8
SET>LIST>CULL
SET>LIST>SHIFT LIST
PARAMS>INPUT>PANEL

EXERCICE 8: PLIAGES

EXERCICE 6 : voir page GH-MODÉLISATION GÉOMÉTRIQUE D’UNE TOUR

EXERCICE 7 Parametric Bench (Rhino Grasshopper Tutorial)

OBJECTIF
Modéliser un banc constitué de sections paramétrables à partir d’un volume importé de Rhino3D. Les sections seront produites dans Grasshopper et reliées par des tubes.

Étape 1_modéliser le solide.
Dessiner une boîte dans Rhino 3D grâce à l’outil « SolidptOn » pour pouvoir changer la forme de la boîte.
En sélectionnant et en déplaçant les points sur les coins de la boîte nous pouvons changer la hauteur ou la longueur de celui-ci. Ici, nous sélectionnons les points inférieurs et utilisons le manipulateur pour les mettre à l’échelle.
_Modifier le solide avec l’outil « Cage Edit » pour modifier le volume grâce à une boîte englobante.
Paramétrages de la fenêtre:
Pour « Select control object », on choisit « BoundingBox »,
Pour le « Coordinate system », on choisit « World »,
Pour les « Cage parameters » qui définissent le nombre de points en direction X, Y et Z, on choisit 5 points en direction X et 2 points en direction Y et Z, pour avoir une déformation lisse sur le solide.
Pour la « région à modifier », choisir Global. Maintenant, nous avons nos points de contrôle et nous pouvons les déplacer pour changer la forme. Une fois ces changements faits, nous pouvons désactiver les points de contrôle et supprimer la boîte limitative.
Pour donner à cette forme une certaine stabilité, nous pouvons extruder les deux extrémités du banc dans la direction X. Pour ce faire, nous maintenons Ctrl et Maj et nous cliquons sur la surface que nous voulons extruder. Ensuite, nous utilisons le manipulateur en cliquant sur le petit cercle dans la direction X et donnons la dimension d’extrusion voulue. Nous pouvons le faire pour les deux côtés du banc et nous avons la forme à utiliser dans Grashopper à partir d’un Brep.

Étape 2_ Produire une série de sections sur ce volume.
Dans Intersection > Mathématical, nous avons deux options : Contour et « Brep|Plane ». Ici, nous utilisons Brep|Plane. Le composant Contour a besoin d’un point de départ et d’une distance, donc si nous n’avons pas la longueur exacte du banc et ne définissons pas la distance en fonction de la longueur, la dernière section ne s’aligne pas avec l’autre côté du banc, et nous allons avoir une distance plus ou moins grande entre nos sections à la fin.
Le composant Brep|Plane a besoin de plans de section en entrée. Pour définir ces plans, nous devons d’abord tracer une ligne avec la longueur du banc dans Rhino. Importez cette ligne comme courbe dans Grasshopper. Dans l’onglet Curv, nous utilisons le composant « Perp Frames » qui génère des cadres perpendiculaires à la courbe donnée et utilise ces cadres comme plans de section pour le composant Brep|Plane.
Pour rendre ces sections plus lisses, nous allons utiliser le composant Fillet >Curve > Util. En augmentant le nombre que nous donnons à l’entrée Radius du composant Fillet, nous pouvons avoir des sections plus lisses.

Étape 3_ Définir les tuyaux.
Nous obtenons deux points symétriques pour le centre des tuyaux en utilisant le composant Miroir >Transformer > Euclidien.
Nous commençons par définir deux points en utilisant le composant Point. L’un correspond au centre de l’un des tuyaux et l’autre à l’origine d’un plan pour la symétrie.
Pour définir l’axe des tuyaux, nous allons utiliser le composant Line SDL > Curve > Primitive. Le point de départ sera les deux points, la direction sera la direction X en utilisant le composant Unit X, et pour la longueur, nous pouvons utiliser la longueur de la ligne de base que nous avions pour la section. Pour obtenir la longueur de cette courbe, nous pouvons simplement donner la courbe comme entrée au composant Number >Params > Primitive et l’utiliser pour la longueur de la ligne SDL.
Pour allonger ces lignes le long du banc paramétrique, nous utilisons le composant Extend Curve : Curve > Util. La saisie de début sera la longueur que nous avons donnée à la ligne SDL et la saisie de fin serait 0.
Pour transformer ces lignes en tuyaux, nous utilisons le composant Pipe : Surface > Freeform en donnant un rayon.
Ensuite, nous allons définir l’intersection entre ces tuyaux et les plans de section en utilisant le même composant Brep|Plane que nous avions auparavant, nous pouvons copier et coller le composant Brep |Plane que nous avons dans la définition mais cette fois-ci donner ces tuyaux comme Brep.

Étape 4_ Définir les surfaces des sections.
Nous avons maintenant les courbes limites des plans de section et les courbes d’intersection que nous devrions transformer en surface. Pour ce faire, nous pouvons utiliser le composant Boundary Surface >Surface > Freeform. Pour que ce composant fonctionne correctement, nous devons aplatir l’entrée.

Étape 5_ extruder les surfaces des sections de façon à ce que les plans de section se trouvent au milieu de l’extrusion.
Nous déplaçons ces plans de section dans la direction X. L’entrée de Move sera l’épaisseur divisée par 2. Nous pouvons donner un nombre arbitraire (par exemple 2.2) à l’entrée de facteur du composant Unit X, puis faire un clic droit sur l’entrée M du composant Move et lui donner une expression x/2. Nous extrudons la surface déplacée en utilisant le composant Extrude : Surface > Freeform. Comme l’extrusion se produit dans la même direction du déplacement des plans de section, nous devons faire un clic droit sur l’entrée D du composant Extrude et lui donner une expression –x.

Étape 6- longueur des tuyaux
Celle-ci est plus grande que le banc paramétrique. Nous devons diviser les tuyaux et ne garder que la partie médiane. Nous pouvons utiliser Split with brep avec le composant Brep >Intersect > Région et diviser l’axe des tuyaux à l’aide de la forme de base du banc paramétrique que nous avons importé de Rhino sous forme de Brep. Ensuite, nous devons utiliser le composant List Item>Sets > List pour choisir les parties centrales et les transformer en tuyaux.