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
  • Documentation de l’API
  • Modèle de code
  • Exemple
  • Objectif
  • Ensemble de données
  • Présentation de la solution
  • Consulter la documentation relative à l’API
  • Obtenir tous les bassins versants
  • Déballer des objets
  • Script Python
  • Créer des polycourbes
  • Résultat
  • Comparaison entre IronPython et CPython
Edit on GitHub
Export as PDF
  1. Dynamo for Civil 3D
  2. Concepts avancés

Python et Civil 3D

PreviousLiaison d’objetNextLecteur Dynamo

Last updated 1 month ago

Bien que Dynamo soit un outil de extrêmement puissant, il est également possible d’aller au-delà des nœuds et des fils et d’écrire du code sous forme de texte. Vous pouvez procéder de deux manières :

  1. écrire en DesignScript à l’aide d’un bloc de code ;

  2. écrire en Python à l’aide d’un nœud Python.

Cette section se concentre sur la manière d’exploiter le langage Python dans l’environnement Civil 3D afin de tirer parti des API .NET d’AutoCAD et de Civil 3D.

Consultez la section Python pour plus d’informations sur l’utilisation du Python dans Dynamo.

Documentation de l’API

AutoCAD et Civil 3D disposent de plusieurs API qui permettent aux développeurs comme vous d’étendre le produit principal avec des fonctionnalités personnalisées. Dans le contexte de Dynamo, ce sont les API .NET gérées qui sont pertinentes. Les liens suivants sont essentiels pour comprendre la structure des API et leur fonctionnement.

Au fur et à mesure que vous avancez dans cette section, il est possible que vous rencontriez des concepts que vous ne connaissez pas, tels que les bases de données, les transactions, les méthodes, les propriétés, etc. La plupart de ces concepts sont essentiels pour travailler avec les API .NET et ne sont pas spécifiques à Dynamo ou au Python. Cette section du guide n’a pas pour objet d’examiner ces éléments en détail. Nous vous recommandons donc de vous reporter fréquemment aux liens ci-dessus pour plus d’informations.

Modèle de code

Lorsque vous modifiez un nouveau nœud Python pour la première fois, il est prérempli avec un modèle de code pour vous aider à démarrer. Voici une analyse du modèle avec des explications sur chaque bloc.

  1. Importe les modules sys et clr, qui sont tous deux nécessaires au bon fonctionnement de l’interpréteur Python. En particulier, le module clr permet de traiter les espaces nom .NET essentiellement comme des packages Python.

  2. Charge les assemblages standard (par exemple, les DLL) pour utiliser les API .NET gérées pour AutoCAD et Civil 3D.

  3. Ajoute des références aux espaces nom AutoCAD et Civil 3D standard. Celles-ci sont équivalentes aux directives using ou Imports en C# ou VB.NET (respectivement).

  4. Les ports d’entrée du nœud sont accessibles à l’aide d’une liste prédéfinie appelée IN. Vous pouvez accéder aux données d’un port spécifique à l’aide de son numéro d’index, par exemple dataInFirstPort = IN[0].

  5. Extrait le document et l’éditeur actifs.

  6. Verrouille le document et lance une transaction de base de données.

  7. Vous devez insérer l’essentiel de la logique de votre script ici.

  8. Supprimez le commentaire de cette ligne pour valider la transaction une fois votre travail principal terminé.

  9. Si vous souhaitez générer des données à partir du nœud, affectez-les à la variable OUT à la fin de votre script.

Envie de personnaliser ? Vous pouvez modifier le modèle Python par défaut en modifiant le fichier PythonTemplate.py situé dans C:\ProgramData\Autodesk\C3D <version>\Dynamo.

Exemple

Examinons un exemple pour démontrer certains des concepts essentiels de l’écriture de scripts Python dans Dynamo for Civil 3D.

Objectif

Ensemble de données

Voici des exemples de fichiers qui peuvent vous servir de référence pour cet exercice.

Présentation de la solution

Voici une présentation de la logique de ce graphique.

  1. Consulter la documentation relative à l’API Civil 3D

  2. Sélectionner tous les bassins versants du document par nom de calque

  3. « Déballer » les objets Dynamo pour accéder aux membres internes de l’API Civil 3D

  4. Créer des points Dynamo à partir de points AutoCAD

  5. Créer des polycourbes à partir des points

Allons-y !

Consulter la documentation relative à l’API

Obtenir tous les bassins versants

Vous pouvez maintenant commencer à construire la logique graphique. La première chose à faire est d’obtenir une liste de tous les bassins versants du document. Des nœuds sont disponibles pour cela, il n’est donc pas nécessaire de l’inclure dans le script en Python. L’utilisation de nœuds permet une meilleure visibilité pour quiconque lirait le graphique (au lieu d’ajouter beaucoup de code dans un script Python), et cela permet également au script Python de se concentrer sur une seule chose : renvoyer les points de limite des bassins versants.

Notez ici que la sortie du nœud Tous les objets du calque est une liste de CivilObjects. En effet, Dynamo for Civil 3D ne dispose pas actuellement de nœuds pour travailler avec des bassins versants, ce qui explique pourquoi nous devons accéder à l’API en Python.

Déballer des objets

Type Dynamo
Enveloppes

Objet Autodesk.AutoCAD.DynamoNodes.Object

Entité Autodesk.AutoCAD.DatabaseServices.Entity

CivilObject Autodesk.Civil.DynamoNodes.CivilObject

Entité Autodesk.Civil.DatabaseServices.Entity

En règle générale, il est plus sûr d’obtenir l’ID de l’objet à l’aide de la propriété InternalObjectId, puis d’accéder à l’objet enveloppé dans une transaction. En effet, la propriété InternalDBObject renvoie un objet DBObject AutoCAD qui n’est pas accessible en écriture.

Script Python

Voici le script Python complet qui permet d’accéder aux objets internes du bassin versant et d’obtenir leurs point de limite. Les lignes en surbrillance représentent celles qui sont modifiées/ajoutées par rapport au modèle de code par défaut.

Cliquez sur le texte souligné dans le script pour obtenir une explication sur chaque ligne.

# Charger les bibliothèques standard de Python et DesignScript
import sys
import clr

# Ajouter des assemblages pour AutoCAD et Civil 3D
clr.AddReference(’AcMgd’)
clr.AddReference(’AcCoreMgd’)
clr.AddReference(’AcDbMgd’)
clr.AddReference(’AecBaseMgd’)
clr.AddReference(’AecPropDataMgd’)
clr.AddReference(’AeccDbMgd’)



# Importer des références à partir d’AutoCAD
from Autodesk.AutoCAD.Runtime import *
from Autodesk.AutoCAD.ApplicationServices import *
from Autodesk.AutoCAD.EditorInput import *
from Autodesk.AutoCAD.DatabaseServices import *
from Autodesk.AutoCAD.Geometry import *

# Importer des références à partir de Civil 3D
from Autodesk.Civil.ApplicationServices import *
from Autodesk.Civil.DatabaseServices import *



# Les entrées de ce nœud seront stockées sous forme de liste dans les variables IN.
 = 

 


    


    
    
adoc = Application.DocumentManager.MdiActiveDocument
editor = adoc.Editor

with adoc.LockDocument():
    with adoc.Database as db:
        
        with db.TransactionManager.StartTransaction() as t:
                          
                
                                
                
                    
                                        
                    
                    
                        
                        
                    
            
            # Valider avant de terminer la transaction
            
            pass
            
# Attribuer la sortie à la variable OUT.

En règle générale, il est recommandé d’inclure l’essentiel de la logique de votre script dans une transaction. Cela garantit un accès sécurisé aux objets que votre script lit/écrit. Dans de nombreux cas, l’omission d’une transaction peut provoquer une erreur irrécupérable.

Créer des polycourbes

À ce stade, le script Python doit produire une liste de points Dynamo que vous pouvez voir dans l’aperçu en arrière-plan. La dernière étape consiste simplement à créer des polycourbes à partir des points. Notez que cette opération pourrait également être réalisée directement dans le script Python, mais vous l’avez intentionnellement placée en dehors du script dans un nœud afin qu’elle soit plus visible. Voici à quoi ressemble le graphique final.

Résultat

Et voici la géométrie Dynamo finale.

Comparaison entre IronPython et CPython

Une petite remarque avant de conclure. Selon la version de Civil 3D que vous utilisez, le nœud Python peut être configuré différemment. Dans Civil 3D 2020 et 2021, Dynamo utilisait un outil appelé IronPython pour déplacer des données entre des objets .NET et des scripts Python. Cependant, dans Civil 3D 2022, Dynamo est passé à l’utilisation de l’interpréteur Python natif standard (également appelé CPython) qui utilisent Python 3. Les avantages de cette transition comprennent l’accès aux bibliothèques modernes les plus populaires et aux nouvelles fonctionnalités de la plateforme, la maintenance essentielle et les correctifs de sécurité.

permet d’obtenir la géométrie des limites de contour de tous les bassins versants d’un dessin.

Avant de commencer à créer le graphique et à écrire le code, il est conseillé de consulter la documentation relative à l’API Civil 3D et de se familiariser avec ses fonctionnalités. Dans ce cas, il existe une qui renvoie les points de limite du contour du bassin versant. Notez que cette propriété renvoie un objet Point3dCollection, que Dynamo ne saura pas traiter En d’autres termes, vous ne pourrez pas créer de polycourbe à partir d’un Point3dCollection. Par conséquent, vous devrez éventuellement tout convertir en points Dynamo. Nous y reviendrons plus tard.

Avant d’aller plus loin, il convient d’aborder brièvement un concept important. Dans la section , nous avons vu comment les objets CivilObjects sont liés. Pour apporter un peu plus de détails, un objet Dynamo est un wrapper autour d’une entité AutoCAD. De même, un CivilObject Dynamo est un wrapper autour d’une entité Civil 3D. Vous pouvez « déballer » un objet en accédant à ses propriétés InternalDBObject ou InternalObjectId.

Mission accomplie !

Pour en savoir plus sur cette transition et sur la manière de mettre à jour les scripts existants, consultez le . Si vous souhaitez continuer à utiliser IronPython, il vous suffit d’installer le package DynamoIronPython2.7 à l’aide du gestionnaire de package Dynamo.

🎯
🎉
propriété dans la classe Bassin versant
node-library.md
blog Dynamo
programmation visuelle
Guide du développeur de l’API .NET d’AutoCAD
Guide de référence de l’API .NET d’AutoCAD
Guide du développeur de l’API .NET de Civil 3D
Guide de référence de l’API .NET de Civil 3D
15KB
Python_Catchments.dyn
961KB
Python_Catchments.dwg
Modèle Python par défaut dans Civil 3D
Obtention de tous les bassins versants du document par calque
Graphique final
Polycourbes Dynamo obtenues pour les limites du bassin versant