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
  • Version bêta de Dynamo dans Forma
    • Configurer Dynamo Player dans Forma
    • Ajouter et partager des graphes dans Dynamo Player
    • Exécuter des graphes dans Dynamo Player
    • Différences entre les services de calcul Dynamo et Dynamo Desktop
  • 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 for 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
  • Surface interpolée
  • Points de contrôle de surface
  • Surface de lissage
  • Révolution de surfaces
Edit on GitHub
Export as PDF
  1. Codage dans Dynamo
  2. Géométrie avec DesignScript

Surfaces : interpolation, points de contrôle, lissage, révolution

PreviousConversion, rotation et autres transformationsNextDéfinition des paramètres géométriques

Last updated 2 years ago

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

Surface interpolée

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

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

surf = NurbsSurface.ByPoints(python_points_1);

Points de contrôle de surface

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

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

// create a surface of degree 2 with smooth segments
surf = NurbsSurface.ByPoints(python_points_1, 2, 2);

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

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

// create a surface of degree 6
surf = NurbsSurface.ByPoints(python_points_1, 6, 6);

Surface de lissage

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

// python_points_2, 3, and 4 are generated with
// Python scripts found in Chapter 12, Section 10

c1 = NurbsCurve.ByPoints(python_points_2);
c2 = NurbsCurve.ByPoints(python_points_3);
c3 = NurbsCurve.ByPoints(python_points_4);

loft = Surface.ByLoft([c1, c2, c3]);

Révolution de surfaces

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

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

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

crv = NurbsCurve.ByPoints(pts);

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

surf = Surface.ByRevolve(crv, axis_origin, axis, 0,
    360);