Dynamo
Primer for v2.0
Français
Français
  • À propos
  • Introduction
    • Qu’est-ce que Dynamo et comment fonctionne-t-il ?
    • Manuel d’utilisation du guide, communauté et plate-forme Dynamo
  • Configuration de Dynamo
  • Interface utilisateur
    • Espace de travail
    • Bibliothèque
  • Nœuds et fils
  • Nœuds et concepts essentiels
    • Index des nœuds
    • Géométrie pour la conception informatique
      • Présentation de la géométrie
      • Vecteur, plan et système de coordonnées
      • Points
      • Courbes
      • Surfaces
      • Solides
      • Maillages
    • Blocs de construction des programmes
      • Données
      • Math
      • Logique
      • Chaînes
      • Couleur
    • Conception avec des listes
      • Qu’est-ce qu’une liste
      • Utilisation des listes
      • Listes de listes
      • Listes à n dimensions
    • Dictionnaires dans Dynamo
      • Qu’est-ce qu’un dictionnaire ?
      • Nœuds de dictionnaire
      • Dictionnaires dans les blocs de code
      • Cas d’utilisation de Revit
  • Packages et nœuds personnalisés
    • Nœuds personnalisés
      • Présentation des nœuds personnalisés
      • Création d’un nœud personnalisé
      • Publication dans votre bibliothèque
    • Packages
      • Présentation des packages
      • Étude de cas de package – Mesh Toolkit
      • Développement d'un package
      • Publication d’un package
      • Importation Zero-Touch
  • Dynamo pour Revit
    • La connexion Revit
    • Sélection
    • Édition
    • Création
    • Personnalisation
    • Documentation
  • Dynamo for Civil 3D
    • La connexion de Civil 3D
    • Mise en route
    • Bibliothèque de nœuds
    • Exemples de workflows
      • Routes
        • Positionnement des lampadaires
      • Terrain
        • Positionnement des services
      • Réseaux techniques
        • Renommer des structures
      • Rail
        • Zone de dégagement
      • Topographie
        • Gestion des groupes de points
    • Concepts avancés
      • Liaison d’objet
      • Python et Civil 3D
    • Lecteur Dynamo
    • Packages utiles
    • Ressources
  • Codage dans Dynamo
    • Nœuds Code Block et DesignScript
      • Qu’est-ce qu’un bloc de code ?
      • Syntaxe DesignScript
      • Raccourci
      • Fonctions
    • Géométrie avec DesignScript
      • Concepts de base de la géométrie DesignScript
      • Primitives géométriques
      • Calcul vectoriel
      • Courbes : points de contrôle et interpolés
      • Conversion, rotation et autres transformations
      • Surfaces : interpolation, points de contrôle, lissage, révolution
      • Définition des paramètres géométriques
      • Intersection et ajustement
      • Opérations booléennes géométriques
      • Générateurs de points Python
    • Python
      • Nœuds Python
      • Python et Revit
      • Configuration de votre propre gabarit Python
    • Changements relatifs au langage
  • Conseils d’utilisation
    • Stratégies de graphiques
    • Stratégies de script
    • Références concernant la création et la gestion des scripts
    • Gestion de votre programme
    • Utilisation efficace de jeux de données volumineux dans Dynamo
  • Exemples de workflows
    • Workflows de mise en route
      • Vase paramétrique
      • Points d’attraction
    • Index de concept
  • Guide du développeur
    • Générer Dynamo à partir de la source
      • Générer DynamoRevit à partir de la source
      • Gestion et mise à jour des dépendances dans Dynamo
    • Développer pour Dynamo
      • Mise en route
      • Étude de cas Zero-Touch : nœud grille
      • Exécuter des scripts Python dans des nœuds Zero-Touch (C#)
      • Aller plus loin avec le Zero-Touch
      • Personnalisation avancée des nœuds Dynamo
      • Utilisation de types COM (interopérabilité) dans les packages Dynamo
      • Étude de cas de modèle de nœud : interface utilisateur personnalisée
      • Mise à jour des packages et des bibliothèques Dynamo pour Dynamo 2.x
      • Mise à jour des packages et des bibliothèques Dynamo pour Dynamo 3.x
      • Extensions
      • Définition de l’organisation des packages personnalisés pour Dynamo 2.0+
      • Interface en ligne de commande Dynamo
      • Intégration Dynamo
      • Développement pour Dynamo pour Revit
      • Publier un package
      • Générer un package à partir de Visual Studio
      • Extensions en tant que packages
    • Demandes de tirage
    • Test des attentes
    • Exemples
  • Annexe
    • Questions fréquemment posées
    • Programmation visuelle et Dynamo
    • Ressources
    • Informations sur la nouvelle version
    • Packages utiles
    • Fichiers d’exemple
    • Carte d’intégration de l’hôte
    • Télécharger le PDF
    • Raccourcis clavier de Dynamo
Powered by GitBook
On this page
  • Mappage et combinaisons
  • Exercice - Listes 2D - Basique
  • Exercice - Listes 2D - Avancé
  • Exercice - Listes 3D
Edit on GitHub
Export as PDF
  1. Nœuds et concepts essentiels
  2. Conception avec des listes

Listes à n dimensions

PreviousListes de listesNextDictionnaires dans Dynamo

Last updated 2 years ago

Pour compliquer la tâche, vous allez ajouter encore plus de niveaux à la hiérarchie. La structure des données peut s'étendre au-delà d'une liste bidimensionnelle de listes. Étant donné que les listes sont des éléments dans Dynamo, vous pouvez créer des données avec autant de dimensions que possible.

L'analogie utilisée ici est celle des poupées russes. Chaque liste peut être considérée comme un conteneur contenant plusieurs éléments. Chaque liste possède ses propres propriétés et est considérée comme son propre objet.

L’ensemble de poupées russes (photo de ) est une analogie pour les listes dimensionnelles. Chaque couche représente une liste et chaque liste contient des éléments. Dans le cas de Dynamo, chaque conteneur peut contenir plusieurs conteneurs (représentant les éléments de chaque liste).

Les listes à n dimensions sont difficiles à expliquer visuellement, mais vous allez découvrir dans ce chapitre quelques exercices axés sur des listes de plus de deux dimensions.

Mappage et combinaisons

Le mappage est sans doute la partie la plus complexe de la gestion des données dans Dynamo, et est particulièrement utile lorsque vous travaillez avec des hiérarchies de listes complexes. Grâce à la série d’exercices ci-dessous, vous allez découvrir quand utiliser le mappage et les combinaisons à mesure que les données deviennent multidimensionnelles.

Les nœuds List.Map et List.Combine sont présentés dans la section précédente. Dans le dernier exercice ci-dessous, vous allez utiliser ces nœuds sur une structure de données complexe.

Exercice - Listes 2D - Basique

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 le premier d'une série de trois exercices axés sur l'articulation de la géométrie importée. Chaque partie de cette série d’exercices va accroître la complexité de la structure des données.

  1. Commencez par le fichier .sat dans le dossier des fichiers d’exercice. Vous pouvez sélectionner ce fichier à l’aide du nœud File Path.

  2. Avec Geometry.ImportFromSAT, la géométrie est importée dans l’aperçu Dynamo en tant que deux surfaces.

Dans le cadre de cet exercice, utilisez l’une des surfaces pour faire simple.

  1. Sélectionnez l’index de 1 pour sélectionner la surface supérieure. Pour ce faire, utilisez le nœud List.GetItemAtIndex.

  2. Désactivez l’aperçu de la géométrie à partir de l’aperçu de Geometry.ImportFromSAT.

L’étape suivante consiste à diviser la surface en une grille de points.

1. À l’aide d’un nœud Code Block, insérez les deux lignes de code suivantes : 0..1..#10; 0..1..#5;

2. Avec le nœud Surface.PointAtParameter, connectez les deux valeurs de Code Block à u et v. Définissez la combinaison de ce nœud sur « Produit vectoriel ».

3. La sortie révèle la structure des données, également visible dans l’aperçu Dynamo.

Ensuite, utilisez les points de la dernière étape pour générer dix courbes le long de la surface.

  1. Pour voir comment la structure de données est organisée, connectez un nœud NurbsCurve.ByPoints à la sortie de Surface.PointAtParameter.

  2. Vous pouvez désactiver l’aperçu du nœud List.GetItemAtIndex pour obtenir un résultat plus clair.

  1. Un nœud List.Transpose de base permet d’inverser les colonnes et les lignes d’une liste de listes.

  2. Lorsque vous connectez la sortie de List.Transpose à NurbsCurve.ByPoints, vous obtenez cinq courbes placées horizontalement sur la surface.

  3. Vous pouvez désactiver l’aperçu du nœud NurbsCurve.ByPoints à l’étape précédente pour obtenir le même résultat dans l’image.

Exercice - Listes 2D - Avancé

Passons aux choses sérieuses. Imaginez que vous souhaitiez effectuer une opération sur les courbes créées lors de l'exercice précédent. Vous devrez peut-être lier ces courbes à une autre surface et effectuer un lissage entre elles. Pour ce faire, il convient d’accorder une plus grande attention à la structure des données, même si la logique sous-jacente est la même.

  1. Commencez par une étape de l’exercice précédent : isolez la surface supérieure de la géométrie importée grâce au nœud List.GetItemAtIndex.

  1. À l’aide du nœud Surface.Offset, décalez la surface par une valeur de 10.

  1. De la même façon que dans l’exercice précédent, définissez un nœud Code Block avec les deux lignes de code suivantes : 0..1..#10; 0..1..#5;

  2. Connectez ces sorties à deux nœuds Surface.PointAtParameter dont la combinaison est définie sur « Produit vectoriel ». L’un de ces nœuds est connecté à la surface d’origine, tandis que l’autre est connecté à la surface décalée.

  1. Désactivez l’aperçu de ces surfaces.

  2. Comme dans l’exercice précédent, connectez les sorties à deux nœuds NurbsCurve.ByPoints. Le résultat affiche les courbes correspondant à deux surfaces.

  1. Le nœud List.Create vous permet de combiner les deux jeux de courbes en une liste de listes.

  2. La sortie affiche deux listes contenant chacune dix éléments, représentant chaque ensemble de connexions de courbes NURBS.

  3. Grâce au nœud Surface.ByLoft, vous pouvez visualiser cette structure de données. Le nœud lisse toutes les courbes de chaque sous-liste.

  1. Désactivez l’aperçu du nœud Surface.ByLoft à l’étape précédente.

  2. Si vous utilisez le nœud List.Transpose, n’oubliez pas qu’il permet de retourner toutes les colonnes et les lignes. Ce nœud convertit deux listes de dix courbes en dix listes de deux courbes. Chaque courbe NURBS est désormais liée à la courbe voisine sur l’autre surface.

  3. Le nœud Surface.ByLoft vous permet d’obtenir une structure nervurée.

Vous allez ensuite découvrir un autre processus pour atteindre ce résultat.

  1. Avant de commencer, désactivez l’aperçu de Surface.ByLoft à l’étape précédente pour éviter toute confusion.

  2. Le nœud List.Combine constitue une alternative au nœud List.Transpose. Il exécute un « combinateur » sur chaque sous-liste.

  3. Dans ce cas, vous utilisez List.Create en tant que « combinateur » qui va créer une liste de chaque élément dans les sous-listes.

  4. Le nœud Surface.ByLoft vous permet d’obtenir les mêmes surfaces que lors de l’étape précédente. L’option Transposer est plus facile à utiliser dans ce cas, mais lorsque la structure de données devient encore plus complexe, le nœud List.Combine s’avère plus fiable.

  1. Si vous souhaitez inverser l’orientation des courbes dans la structure nervurée, utilisez un nœud List.Transpose avant de les connecter à NurbsCurve.ByPoints. Cette action permet d’inverser les colonnes et les lignes et d’obtenir 5 nervures horizontales.

Exercice - Listes 3D

Vous allez désormais aller encore un peu plus loin. Dans cet exercice, vous allez travailler avec les deux surfaces importées et créer une hiérarchie de données complexe. L'objectif est néanmoins d'effectuer la même opération avec la même logique sous-jacente.

Commencez par le fichier importé de l’exercice précédent.

  1. Comme dans l’exercice précédent, utilisez le nœud Surface.Offset pour effectuer un décalage d’une valeur de 10.

  2. Dans la sortie, vous pouvez voir que le nœud de décalage a créé deux surfaces.

  1. De la même façon que dans l’exercice précédent, définissez un nœud Code Block avec les deux lignes de code suivantes : 0..1..#20; 0..1..#20;

  2. Connectez ces sorties à deux nœuds Surface.PointAtParameter dont la combinaison est définie sur « Produit vectoriel ». L’un de ces nœuds est connecté aux surfaces d’origine, tandis que l’autre est connecté aux surfaces décalées.

  1. Comme dans l’exercice précédent, connectez les sorties à deux nœuds NurbsCurve.ByPoints.

  2. Observez la sortie de NurbsCurve.ByPoints : il s’agit d’une liste de deux listes, ce qui est plus complexe que l’exercice précédent. Étant donné que les données sont classées par la surface sous-jacente, un autre niveau a été ajouté à la structure des données.

  3. Les choses deviennent plus complexes dans le nœud Surface.PointAtParameter. Dans ce cas, vous avez une liste de listes de listes.

  1. Avant de continuer, désactivez l’aperçu des surfaces existantes.

  2. À l’aide du nœud List.Create, fusionnez les courbes NURBS en une structure de données, créant ainsi une liste de listes de listes.

  3. Lorsque vous connectez un nœud Surface.ByLoft, vous obtenez une version des surfaces d’origine, car elles restent toutes dans leur propre liste telle qu’elle a été créée à partir de la structure de données d’origine.

  1. Dans l’exercice précédent, le fichier List.Transpose a été utilisé pour créer une structure nervurée. Ce ne sera pas possible ici. Vous devez utiliser une transposition sur une liste bidimensionnelle. Étant donné que vous avez une liste tridimensionnelle, une opération de « basculement des colonnes et des lignes » ne fonctionnera pas aussi facilement. N’oubliez pas que les listes sont des objets. Par conséquent, le nœud List.Transpose inverse vos listes sans les sous-listes, mais n’inverse pas les courbes NURBS d’une liste plus bas dans la hiérarchie.

  1. Le nœud List.Combine fonctionne mieux ici. Lorsque vous obtenez des structures de données plus complexes, utilisez les nœuds List.Map et List.Combine.

  2. L’utilisation du nœud List.Create comme « combinateur » vous permet de créer une structure de données plus appropriée.

  1. La structure de données doit toujours être transposée à une étape inférieure de la hiérarchie. Pour ce faire, utilisez List.Map. Ce nœud fonctionne comme List.Combine, sauf qu’il utilise une liste d’entrées, au lieu de deux listes ou plus.

  2. La fonction appliquée à List.Map est List.Transpose, permettant d’inverser les colonnes et les lignes des sous-listes dans la liste principale.

  1. Enfin, vous pouvez lisser les courbes NURBS avec une hiérarchie de données correcte. Vous obtenez ainsi une structure nervurée.

  1. Ajoutez de la profondeur à la géométrie à l’aide d’un nœud Surface.Thicken avec les paramètres d’entrée, comme indiqué.

  1. Il peut être utile d’ajouter un support de surface à deux de ces structures. Ajoutez un autre nœud Surface.ByLoft et utilisez la première sortie de NurbsCurve.ByPoints d’une étape précédente comme entrée.

  2. Comme l’aperçu est de plus en plus encombré, désactivez l’aperçu de ces nœuds en cliquant avec le bouton droit sur chacun d’eux et désélectionnez l’option « Aperçu » pour mieux voir le résultat.

  1. L’articulation se termine lorsque vous avez épaissi les surfaces sélectionnées.

Ce n’est pas la chaise à bascule la plus confortable au monde, mais elle contient de nombreuses données.

Pour la dernière étape, inversez la direction des éléments striés. Dans l’exercice précédent, vous avez utilisé l’option Transposer. La procédure à suivre est similaire ici.

  1. Étant donné qu’un niveau supplémentaire a été ajouté à la hiérarchie, vous devez utiliser List.Map avec une fonction List.Tranpose pour modifier la direction des courbes Nurbs.

  1. Augmentez le nombre de girons de façon à pouvoir modifier le nœud Code Block comme suit : 0..1..#20; 0..1..#30;

La première version de la chaise à bascule était lisse. Le second modèle propose une chaise à bascule sportive originale.

Zeta
33KB
n-Dimensional-Lists.zip
archive
Poupées
Exercice