​Python est un langage de programmation très répandu dont la popularité est liée à son style de syntaxe. Il est très lisible, ce qui facilite l’apprentissage de beaucoup d’autres langages. Python prend en charge les modules et les packages, et peut être intégré dans des applications existantes. Pour plus d’informations sur la façon d’utiliser Python, consultez la page « Mise en route » sur Python.org.

Python et Revit

Maintenant que vous savez comment utiliser les scripts Python dans Dynamo, découvrez comment connecter les bibliothèques Revit à l'environnement de script. Rappelez-vous que vous avez importé Python Standard et vos nœuds Dynamo Core avec les quatre premières lignes du bloc de code ci-dessous. Pour importer les nœuds Revit, les éléments Revit et le gestionnaire de documents Revit, il vous suffit d'ajouter quelques lignes supplémentaires :

import sys
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

# Import RevitNodes
clr.AddReference("RevitNodes")
import Revit

# Import Revit elements
from Revit.Elements import *

# Import DocumentManager
clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager

import System

Ces lignes vous donnent accès à l'API de Revit et vous offre des scripts personnalisés pour toutes les tâches Revit. La combinaison du processus de programmation visuelle et du script de l'API de Revit permet d'améliorer considérablement la collaboration et le développement des outils. Par exemple, un responsable BIM et un concepteur schématique peuvent travailler ensemble sur le même graphique. Dans le cadre de cette collaboration, ils peuvent améliorer la conception et l’exécution du modèle.

API spécifiques de la plate-forme

Le plan du projet Dynamo est d'élargir la portée de la mise en oeuvre de la plate-forme. Étant donné que Dynamo ajoute d'autres programmes au registre, les utilisateurs ont accès aux API spécifiques de la plate-forme depuis l'environnement de script Python. Même si l'étude de cas de cette section est consacrée à Revit, d'autres chapitres, offrant des didacticiels complets sur les scripts sur d'autres plates-formes, sont à prévoir. De plus, de nombreuses bibliothèques IronPython sont désormais accessibles et peuvent être importées dans Dynamo.

Les exemples ci-dessous montrent comment mettre en oeuvre des opérations spécifiques de Revit à partir de Dynamo et à l'aide de Python. Pour une révision plus détaillée des relations de Python avec Dynamo et Revit, reportez-vous à la page Wiki de Dynamo. Le projet Revit Python Shell constitue une autre ressource utile pour Python et Revit.

Exercice 1

Créez un projet Revit.

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.

Dans ces exercices, vous allez explorer les scripts élémentaires de Python dans Dynamo for Revit. Cet exercice est axé sur la gestion des fichiers et des éléments Revit, ainsi que sur la communication entre Revit et Dynamo.

Il s'agit d'une méthode de découpe et de séchage permettant de récupérer les éléments doc, uiapp et app du fichier Revit lié à votre session Dynamo. Les programmeurs qui ont déjà travaillé dans l'API de Revit reconnaîtront peut-être les éléments dans la liste d'observation. Si ces éléments ne vous semblent pas familiers, pas d'inquiétude. Vous allez utiliser d'autres exemples dans les exercices ci-dessous.

Voici comment importer les services Revit et récupérer les données du document dans Dynamo.

Examinez le nœud Python dans Dynamo. Vous pouvez également retrouver le code ci-dessous :

# Load the Python Standard and DesignScript Libraries
import sys
import clr

#Import DocumentManager
clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager

#Place your code below this line
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
app = uiapp.Application

#Assign your output to the OUT variable
OUT = [doc,uiapp,app]

Exercice 2

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.

Dans cet exercice, vous allez créer une courbe de modèle simple dans Revit à l'aide du nœud Dynamo Python.

Commencez par créer une famille de volumes conceptuels dans Revit.

Ouvrez le dossier Volume conceptuel et utilisez le fichier gabarit Metric Mass.rft.

Dans Revit, utilisez le raccourci clavier un pour afficher les paramètres Unité de projet et définir l’unité de longueur sur Mètres.

Lancez Dynamo et créez le jeu de nœuds dans l’image ci-dessous. Vous allez d’abord créer deux points de référence dans Revit à partir de nœuds Dynamo.

1. Créez un nœud Code Block et attribuez-lui la valeur de "0;".

2. Connectez cette valeur dans un nœud ReferencePoint.ByCoordinates pour les entrées X, Y et Z.

3. Créez trois curseurs, compris entre -100 et 100, avec une taille de pas de 1.

4. Connectez chaque curseur à un nœud ReferencePoint.ByCoordinates.

5. Ajoutez un nœud Python à l'espace de travail, cliquez sur le bouton "+" du nœud pour ajouter une autre entrée et connectez les deux points de référence dans chaque entrée. Ouvrez le nœud Python.

Examinez le nœud Python dans Dynamo. Recherchez le code complet ci-dessous.

1. System.Array : Revit requiert un réseau système comme entrée (et non une liste Python). Il s'agit juste d'une ligne de code supplémentaire, mais prêter attention aux types d'argument facilite la programmation Python dans Revit.

import sys
import clr

# Import RevitNodes
clr.AddReference("RevitNodes")
import Revit
#Import Revit elements
from Revit.Elements import *
import System

#define inputs
startRefPt = IN[0]
endRefPt = IN[1]

#define system array to match with required inputs
refPtArray = System.Array[ReferencePoint]([startRefPt, endRefPt])

#create curve by reference points in Revit
OUT = CurveByPoints.ByReferencePoints(refPtArray)

Dans Dynamo, vous avez créé deux points de référence avec une ligne les reliant à l’aide de Python. Le prochain exercice va vous permettre d’aller un peu plus loin.

Exercice 3

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 simple, mais il illustre les rubriques de connexion de données et de géométrie de Revit à Dynamo et vice-versa. Commencez par ouvrir Revit-StructuralFraming.rvt. Une fois ouvert, lancez Dynamo et ouvrez le fichier Revit-StructuralFraming.dyn.

Ce fichier Revit est des plus basiques. Il comporte deux courbes de référence : une sur le niveau 1 et l'autre sur le niveau 2. Votre objectif est d'intégrer ces courbes dans Dynamo et de conserver un lien actif.

Ce fichier contient un ensemble de nœuds connectés à cinq entrées d’un nœud Python.

1. Nœuds Select Model Element : cliquez sur le bouton Sélectionner de chaque nœud et sélectionnez une courbe correspondante dans Revit.

2. Code Block : à l'aide de la syntaxe 0..1..#x;, connectez un curseur de type entier compris entre 0 et 20 à l'entrée x. Celui-ci indique le nombre de poutres à dessiner entre les deux courbes.

3. Structural Framing Types : choisissez la poutre W12x26 par défaut dans le menu déroulant.

4. Levels : sélectionnez "Level 1".

Dans Python, ce code est un peu plus dense, mais les commentaires à l’intérieur du code décrivent ce qui se passe dans le processus :

import clr
#import Dynamo Geometry
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
# Import RevitNodes
clr.AddReference("RevitNodes")
import Revit
# Import Revit elements
from Revit.Elements import *
import System

#Query Revit elements and convert them to Dynamo Curves
crvA=IN[0].Curves[0]
crvB=IN[1].Curves[0]

#Define input Parameters
framingType=IN[3]
designLevel=IN[4]

#Define "out" as a list
OUT=[]

for val in IN[2]:
	#Define Dynamo Points on each curve
	ptA=Curve.PointAtParameter(crvA,val)
	ptB=Curve.PointAtParameter(crvB,val)
	#Create Dynamo line
	beamCrv=Line.ByStartPointEndPoint(ptA,ptB)
	#create Revit Element from Dynamo Curves
	beam = StructuralFraming.BeamByCurve(beamCrv,designLevel,framingType)
	#convert Revit Element into list of Dynamo Surfaces
	OUT.append(beam.Faces)

Dans Revit, un réseau de poutres s’étend sur les deux courbes en tant qu’éléments structurels. Remarque : cet exemple n'est pas réaliste... Les éléments structurels sont utilisés comme exemple pour les occurrences Revit d'origine créées à partir de Dynamo.

Dans Dynamo, les résultats sont également visibles. Les poutres du nœud Watch3D font référence à la géométrie interrogée à partir des éléments Revit.

Il existe un processus continu de conversion des données de l’environnement Revit vers l’environnement Dynamo. En résumé, voici comment le processus se déroule :

1. Sélectionnez l'élément Revit.

2. Convertissez l'élément Revit en courbe Dynamo.

3. Divisez la courbe Dynamo en une série de points Dynamo.

4. Utilisez les points Dynamo entre deux courbes pour créer des lignes Dynamo.

5. Créez des poutres Revit en référençant les lignes Dynamo.

6. Générez des surfaces Dynamo en interrogeant la géométrie des poutres Revit.

Ce processus peut sembler compliqué, mais grâce au script, il est aussi simple de modifier la courbe dans Revit et exécuter à nouveau le solveur (pour ce faire, vous devrez peut-être supprimer les poutres précédentes). Cela est dû au placement des poutres dans Python, ce qui rompt l'association des nœuds OOTB.

Avec une mise à jour des courbes de référence dans Revit, vous obtenez un nouveau réseau de poutres.

Avec Dynamo 2.0, vous pouvez spécifier un gabarit par défaut (.py extension) à utiliser lors de la première ouverture de la fenêtre Python. Cette option a longtemps été attendue, car elle accélère l'utilisation de Python dans Dynamo. La possibilité d'utiliser un gabarit vous permet d'obtenir des importations par défaut prêtes à l'emploi lorsque vous voulez développer un script Python personnalisé.

Ce gabarit se trouve à l’emplacement APPDATA de votre installation de Dynamo.

L’emplacement habituel est le suivant : ( %appdata%\Dynamo\Dynamo Core\{version}\ ).

Configuration du gabarit

Pour utiliser cette fonctionnalité, vous devez ajouter la ligne suivante dans le fichier DynamoSettings.xml. (Modifier dans le bloc-notes)

Vous pouvez simplement remplacer <PythonTemplateFilePath /> par ce qui suit :

<PythonTemplateFilePath>
<string>C:\Users\CURRENTUSER\AppData\Roaming\Dynamo\Dynamo Core\2.0\PythonTemplate.py</string>
</PythonTemplateFilePath>

Ensuite, vous devez créer un gabarit en intégrant la fonctionnalité que vous voulez utiliser. Dans cet exemple, vous allez incorporer les importations liées à Revit et d'autres éléments que vous utilisez généralement lorsque vous travaillez avec Revit.

Vous pouvez ouvrir un document de bloc-notes vide et coller le code suivant à l'intérieur :

import clr

clr.AddReference('RevitAPI')
from Autodesk.Revit.DB import *
from Autodesk.Revit.DB.Structure import *

clr.AddReference('RevitAPIUI')
from Autodesk.Revit.UI import *

clr.AddReference('System')
from System.Collections.Generic import List

clr.AddReference('RevitNodes')
import Revit
clr.ImportExtensions(Revit.GeometryConversion)
clr.ImportExtensions(Revit.Elements)

clr.AddReference('RevitServices')
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager

doc = DocumentManager.Instance.CurrentDBDocument
uidoc=DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument

#Preparing input from dynamo to revit
element = UnwrapElement(IN[0])

#Do some action in a Transaction
TransactionManager.Instance.EnsureInTransaction(doc)

TransactionManager.Instance.TransactionTaskDone()

OUT = element

Une fois cela fait, enregistrez ce fichier sous le nom PythonTemplate.py à l’emplacement APPDATA.

Comportement du script Python par la suite

Une fois le gabarit Python défini, Dynamo le recherche à chaque fois qu’un nœud Python est positionné. Si le gabarit est introuvable, l’affichage sera comparable à la fenêtre Python par défaut.

Si Dynamo trouve le gabarit Python (par exemple, notre gabarit Revit), il affiche tous les éléments par défaut que vous avez intégrés.

Vous trouverez ici des informations supplémentaires sur cet ajout important (par Radu Gidei). https://github.com/DynamoDS/Dynamo/pull/8122

Pourquoi utiliser la programmation textuelle dans l’environnement de programmation visuelle de Dynamo ? La programmation visuelle présente de nombreux avantages. Elle vous permet de créer des programmes sans avoir à apprendre la syntaxe spéciale dans une interface visuelle intuitive. Toutefois, un programme visuel peut être encombré et peut parfois ne pas fonctionner correctement. Par exemple, Python propose des méthodes beaucoup plus efficaces pour écrire des instructions conditionnelles (if/then) et des boucles. Python est un outil puissant qui permet d’étendre les capacités de Dynamo et de remplacer de nombreux nœuds par quelques lignes de code concises.

Programme visuel :

Programme textuel :

import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

solid = IN[0]
seed = IN[1]
xCount = IN[2]
yCount = IN[3]

solids = []

yDist = solid.BoundingBox.MaxPoint.Y-solid.BoundingBox.MinPoint.Y
xDist = solid.BoundingBox.MaxPoint.X-solid.BoundingBox.MinPoint.X

for i in xRange:
	for j in yRange:
		fromCoord = solid.ContextCoordinateSystem
		toCoord = fromCoord.Rotate(solid.ContextCoordinateSystem.Origin,Vector.ByCoordinates(0,0,1),(90*(i+j%val)))
		vec = Vector.ByCoordinates((xDist*i),(yDist*j),0)
		toCoord = toCoord.Translate(vec)
		solids.append(solid.Transform(fromCoord,toCoord))

OUT = solids

Nœud Python

Comme les blocs de code, les nœuds Python sont une interface de script au sein d'un environnement de programmation visuelle. Le nœud Python se trouve sous Script > Éditeur > Python Script dans la bibliothèque.

Un double-clic sur le nœud permet d’ouvrir l’éditeur de script Python (vous pouvez également cliquer avec le bouton droit sur le nœud et sélectionner Éditer…). Le texte réutilisable situé en haut de l’éditeur vous permet de référencer les bibliothèques dont vous aurez besoin. Les entrées sont stockées dans le réseau IN. Les valeurs sont renvoyées à Dynamo en étant affectées à la variable OUT.

La bibliothèque Autodesk.DesignScript.Geometry vous permet d’utiliser la notation par points de manière similaire aux blocs de code. Pour plus d’informations sur la syntaxe de Dynamo, reportez-vous à la rubrique https://github.com/DynamoDS/DynamoPrimerNew/blob/master-fra/coding-in-dynamo/7_code-blocks-and-design-script/7-2_design-script-syntax.md et au document Guide de DesignScript (pour télécharger ce document PDF, cliquez avec le bouton droit de la souris sur le lien et choisissez « Enregistrer le lien sous… »). Si vous tapez un type de géométrie tel que « Point », une liste de méthodes permettant de créer et d’interroger des points s’affiche.

Les méthodes comprennent des constructeurs tels que ByCoordinates, des actions telles que Add et des requêtes telles que les coordonnées X, Y et Z.

Exercice : Nœud personnalisé avec le nœud Python Script pour la création de motifs du module solide

Partie I : Configuration du nœud Python Script

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.

Dans cet exemple, vous allez écrire un script Python qui crée des motifs à partir d'un module solide, et le transformer en nœud personnalisé. Commencer par créer le module solide à l’aide de nœuds Dynamo.

1. Rectangle.ByWidthLength : créez un rectangle qui servira de base au solide.

2. Surface.ByPatch : connectez le rectangle à l’entrée « closedCurve » pour créer la surface inférieure.

1. Geometry.Translate : connectez le rectangle à l’entrée « geometry » pour le déplacer vers le haut, à l’aide d’un bloc de code pour spécifier l’épaisseur de base du solide.

2. Polygon.Points : interrogez le rectangle converti pour extraire les points de coin.

3. Geometry.Translate : utilisez un bloc de code pour créer une liste de quatre valeurs correspondant aux quatre points, en convertissant un coin du solide vers le haut.

4. Polygon.ByPoints : utilisez les points convertis pour reconstruire le polygone supérieur.

5. Surface.ByPatch : connectez le polygone pour créer la surface supérieure.

Maintenant que vous avez les surfaces supérieures et inférieures, effectuez un lissage entre les deux contours pour créer les côtés du solide.

1. List.Create: connectez le rectangle inférieur et le polygone supérieur aux entrées d’index.

2. Surface.ByLoft : lissez les deux contours pour créer les côtés du solide.

3. List.Create : connectez les surfaces supérieures, inférieures et latérales aux entrées d’index pour créer une liste de surfaces.

4. Solid.ByJoiningSurfaces : joignez les surfaces pour créer le module solide.

Maintenant que le solide est créé, déposez un nœud de script Python dans l’espace de travail.

1. Pour ajouter des entrées supplémentaires au nœud, cliquez sur l’icône + sur le nœud. Les entrées sont nommées IN[0], IN[1], etc. pour indiquer qu’elles représentent des éléments dans une liste.

Commencez par définir les entrées et la sortie. Double-cliquez sur le nœud pour ouvrir l'éditeur Python. Suivez le code ci-dessous pour modifier le code dans l’éditeur.

# Load the Python Standard and DesignScript Libraries
import sys
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

# The inputs to this node will be stored as a list in the IN variables.
#The solid module to be arrayed
solid = IN[0]

#A Number that determines which rotation pattern to use
seed = IN[1]

#The number of solids to array in the X and Y axes
xCount = IN[2]
yCount = IN[3]

#Create an empty list for the arrayed solids
solids = []

# Place your code below this line


# Assign your output to the OUT variable.
OUT = solids

Ce code sera plus pertinent à mesure que vous progresserez dans l’exercice. Ensuite, identifiez les informations nécessaires pour la mise en réseau du module solide. Tout d'abord, vous devez connaître les cotes du solide pour déterminer la distance de conversion. En raison d’un bogue relatif à la zone de contour, utilisez la géométrie de courbe d’arête pour créer une zone de contour.

Examinez le nœud Python dans Dynamo. La syntaxe utilisée est la même que celle utilisée dans les titres des nœuds dans Dynamo. Consultez le code commenté ci-dessous.

# Load the Python Standard and DesignScript Libraries
import sys
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

# The inputs to this node will be stored as a list in the IN variables.
#The solid module to be arrayed
solid = IN[0]

#A Number that determines which rotation pattern to use
seed = IN[1]

#The number of solids to array in the X and Y axes
xCount = IN[2]
yCount = IN[3]

#Create an empty list for the arrayed solids
solids = []
#Create an empty list for the edge curves
crvs = []

# Place your code below this line
#Loop through edges an append corresponding curve geometry to the list
for edge in solid.Edges:
    crvs.append(edge.CurveGeometry)

#Get the bounding box of the curves
bbox = BoundingBox.ByGeometry(crvs)

#Get the x and y translation distance based on the bounding box
yDist = bbox.MaxPoint.Y-bbox.MinPoint.Y
xDist = bbox.MaxPoint.X-bbox.MinPoint.X

# Assign your output to the OUT variable.
OUT = solids

Puisque vous allez convertir et faire pivoter les modules solides, utilisez l'opération Geometry.Transform. Examinez le nœud Geometry.Transform : vous savez que vous avez besoin d'un système de coordonnées source et d'un système de coordonnées cible pour transformer le solide. La source est le système de coordonnées contextuel du solide, alors que la cible est un système de coordonnées différent pour chaque module en réseau. Cela signifie que vous devez parcourir les valeurs x et y pour modifier le système de coordonnées à chaque fois.

# Load the Python Standard and DesignScript Libraries
import sys
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

# The inputs to this node will be stored as a list in the IN variables.
#The solid module to be arrayed
solid = IN[0]

#A Number that determines which rotation pattern to use
seed = IN[1]

#The number of solids to array in the X and Y axes
xCount = IN[2]
yCount = IN[3]

#Create an empty list for the arrayed solids
solids = []
#Create an empty list for the edge curves
crvs = []

# Place your code below this line
#Loop through edges an append corresponding curve geometry to the list
for edge in solid.Edges:
    crvs.append(edge.CurveGeometry)

#Get the bounding box of the curves
bbox = BoundingBox.ByGeometry(crvs)

#Get the x and y translation distance based on the bounding box
yDist = bbox.MaxPoint.Y-bbox.MinPoint.Y
xDist = bbox.MaxPoint.X-bbox.MinPoint.X

#Get the source coordinate system
fromCoord = solid.ContextCoordinateSystem

#Loop through x and y
for i in range(xCount):
    for j in range(yCount):
        #Rotate and translate the coordinate system
        toCoord = fromCoord.Rotate(solid.ContextCoordinateSystem.Origin, Vector.ByCoordinates(0,0,1), (90*(i+j%seed)))
        vec = Vector.ByCoordinates((xDist*i),(yDist*j),0)
        toCoord = toCoord.Translate(vec)
        #Transform the solid from the source coord syste, to the target coord system and append to the list
        solids.append(solid.Transform(fromCoord,toCoord))

# Assign your output to the OUT variable.
OUT = solids

Cliquez sur Exécuter, puis enregistrez le code. Connectez le nœud Python avec le script existant comme suit.

1. Connectez la sortie du nœud Solid.ByJoinedSurfaces comme première entrée du nœud Python et utilisez un nœud Code Block pour définir les autres entrées.

2. Créez un nœud Topology.Edges et utilisez la sortie du nœud Python comme son entrée.

3. Enfin, créez un nœud Edge.CurveGeometry et utilisez la sortie du nœud Topology.Edges comme son entrée.

Modifiez la valeur de départ pour créer différents motifs. Vous pouvez également modifier les paramètres du module solide lui-même pour créer différents effets.

Partie II : Conversion du nœud Python Script en nœud personnalisé

Maintenant que vous avez créé un script Python utile, enregistrez-le en tant que nœud personnalisé. Sélectionnez le nœud Python Script, cliquez avec le bouton droit sur Espace de travail et sélectionnez « Créer un nœud personnalisé ».

Attribuez un nom, une description et une catégorie.

Un nouvel espace de travail s’ouvre dans lequel vous pouvez modifier le nœud personnalisé.

1. Entrées : modifiez les noms d’entrée pour qu’ils soient plus descriptifs et ajoutez des types de données et des valeurs par défaut.

2. Sortie : modifier le nom de la sortie.

Enregistrez le nœud sous forme de fichier .dyf. Le nœud personnalisé doit maintenant refléter les modifications apportées.