Python e Revit

Ora che è stato dimostrato come utilizzare gli script di Python in Dynamo, verrà esaminato il collegamento delle librerie di Revit nell'ambiente di scripting. Tenere presente che sono stati importati i nodi standard di Python e i nodi principali di Dynamo con le prime tre righe del blocco di codice riportato di seguito. Per importare i nodi di Revit, gli elementi di Revit e la gestione dei documenti di Revit, è necessario aggiungere solo alcune righe:

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

Questo consente di accedere all'API di Revit e offre scripting personalizzato per qualsiasi operazione di Revit. Combinando il processo di programmazione visiva con lo scripting, la collaborazione e lo sviluppo di strumenti dell'API di Revit, si ottiene un miglioramento significativo. Ad esempio, un responsabile BIM e un progettista di schemi possono lavorare insieme sullo stesso grafico. In questa collaborazione, possono migliorare la progettazione e l'esecuzione del modello.

API specifiche della piattaforma

Il piano che sta dietro al progetto di Dynamo è quello di ampliare l'ambito di implementazione della piattaforma. Poiché Dynamo aggiunge altri programmi all'elenco di casi, gli utenti potranno accedere alle API specifiche della piattaforma dall'ambiente di scripting di Python. Sebbene Revit sia il case study di questa sezione, è possibile prevedere altri capitoli in futuro che offrono esercitazioni complete sullo scripting in altre piattaforme. Inoltre, ora sono disponibili numerose librerie di IronPython, che possono essere importate in Dynamo.

Negli esempi riportati di seguito sono illustrati modi per implementare operazioni specifiche di Revit da Dynamo utilizzando Python. Per una revisione più dettagliata sulla relazione di Python con Dynamo e Revit, fare riferimento alla pagina Wiki di Dynamo. Un'altra utile risorsa per Python e Revit è il progetto Revit Python Shell.

Esercizio 1

Creare un nuovo progetto di Revit.

Scaricare il file di esempio facendo clic sul collegamento seguente.

Un elenco completo di file di esempio è disponibile nell'Appendice.

In questi esercizi, verranno esaminati gli script di Python elementari in Dynamo for Revit. L'esercizio si concentrerà sull'utilizzo di file ed elementi di Revit, nonché sulla comunicazione tra Revit e Dynamo.

Questo è un metodo molto semplice per il recupero di doc, uiapp e app del file di Revit collegato alla sessione di Dynamo. I programmatori che hanno lavorato in precedenza nell'API di Revit possono notare le voci dell'elenco di controllo. Se questi elementi non risultano familiari, sarà possibile utilizzare altri esempi negli esercizi riportati di seguito.

Di seguito è mostrato il modo in cui si importano i servizi di Revit e si recuperano i dati dei documenti in Dynamo.

Osservare il nodo Python in Dynamo. Il codice è disponibile anche di seguito:

# 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]

Esercizio 2

Scaricare il file di esempio facendo clic sul collegamento seguente.

Un elenco completo di file di esempio è disponibile nell'Appendice.

In questo esercizio, verrà creata una semplice curva di modello in Revit mediante il nodo Python di Dynamo.

Iniziare creando una nuova famiglia di masse concettuali in Revit.

Aprire la cartella Conceptual Mass e utilizzare il file modello Metric Mass.rft.

In Revit, utilizzare il tasto di scelta rapida un per visualizzare le impostazioni Unità di misura, quindi modificare l'unità di lunghezza in metri.

Avviare Dynamo e creare il gruppo di nodi nell'immagine riportata sotto. Innanzitutto, verranno creati due punti di riferimento in Revit dai nodi di Dynamo.

1. Creare un Code Block e assegnargli un valore di "0;".

2. Collegare questo valore ad un nodo ReferencePoint.ByCoordinates per gli input X, Y e Z.

3. Creare tre dispositivi di scorrimento, compresi tra -100 e 100, con una dimensione di incremento pari a 1.

4. Collegare ogni dispositivo di scorrimento ad un nodo ReferencePoint.ByCoordinates.

5. Aggiungere un nodo Python all'area di lavoro, fare clic sul pulsante + sul nodo per aggiungere un altro input e collegare i due punti di riferimento ad ogni input. Aprire il nodo Python.

Osservare il nodo Python in Dynamo. Per il codice completo, vedere di seguito.

1. System.Array: Revit richiede una matrice di sistema come input (anziché un elenco di Python). Si tratta solo di un'altra riga di codice, ma prestare attenzione ai tipi di argomento faciliterà la programmazione di Python in 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)

In Dynamo, sono stati creati due punti di riferimento con una linea che li collega utilizzando Python. Si aumenterà un po' il livello di complessità nel prossimo esercizio.

Esercizio 3

Scaricare il file di esempio facendo clic sul collegamento seguente.

Un elenco completo di file di esempio è disponibile nell'Appendice.

Questo esercizio semplifica la procedura, ma enfatizza gli argomenti relativi al collegamento di dati e geometria da Revit a Dynamo e viceversa. Per iniziare, aprire Revit-StructuralFraming.rvt. Una volta aperto il file, avviare Dynamo e aprire il file Revit-StructuralFraming.dyn.

Questo file di Revit contiene dati di base. Due curve di riferimento: una disegnata sul livello 1 e l'altra sul livello 2. Si desidera ottenere queste curve in Dynamo e mantenere un collegamento attivo.

In questo file è presente un gruppo di nodi che si collegano a cinque input di un nodo Python.

1. Nodi Select Model Element: fare clic sul pulsante Seleziona per ogni elemento e selezionare una curva corrispondente in Revit.

2. Code Block: utilizzando la sintassi 0..1..#x;, collegare un dispositivo di scorrimento di numeri interi compreso tra 0 e 20 all'input x. Questo indica il numero di travi da disegnare tra le due curve.

3. Structural Framing Types: dal menu a discesa, scegliere la trave di default W12x26.

4. Levels: selezionare "Livello 1".

Questo codice in Python è un po' più denso, ma i commenti all'interno del codice descrivono cosa sta accadendo nel processo:

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)

In Revit, è presente una serie di travi che si estendono sulle due curve come elementi strutturali. Nota: questo non è un esempio realistico; gli elementi strutturali vengono utilizzati come esempio per le istanze native di Revit create da Dynamo.

In Dynamo, è possibile visualizzare anche i risultati. Le travi del nodo Watch 3D fanno riferimento alla geometria sottoposta a query dagli elementi di Revit.

Notare che è presente un processo continuo di conversione dei dati dall'ambiente di Revit all'ambiente di Dynamo. In sintesi, ecco come viene riprodotto il processo:

1. Selezionare l'elemento di Revit.

2. Convertire l'elemento di Revit nella curva di Dynamo.

3. Dividere la curva di Dynamo in una serie di punti di Dynamo.

4. Utilizzare i punti di Dynamo tra due curve per creare le linee di Dynamo.

5. Creare le travi di Revit facendo riferimento alle linee di Dynamo.

6. Generare le superfici di Dynamo eseguendo una query sulla geometria delle travi di Revit.

Questo processo può sembrare un po' complicato, ma lo script lo rende semplice quanto la modifica della curva in Revit e la riesecuzione del risolutore (anche se potrebbe essere necessario eliminare le travi precedenti quando si esegue questa operazione). Ciò è dovuto al fatto che si stanno posizionando le travi in Python, interrompendo così l'associazione che hanno i nodi OOTB.

Con un aggiornamento delle curve di riferimento in Revit, si ottiene una nuova serie di travi.

Perché è opportuno utilizzare la programmazione testuale nell'ambiente di programmazione visiva di Dynamo? La offre molti vantaggi. Consente di creare programmi senza apprendere una sintassi speciale in un'interfaccia visiva intuitiva. Tuttavia, un programma visivo può diventare disordinato e a volte può risultare carente in termini di funzionalità. Ad esempio, Python offre metodi molto più facili da realizzare per la scrittura di istruzioni condizionali (if/then) e il loop. Python è un potente strumento in grado di ampliare le funzionalità di Dynamo e di consentire di sostituire molti nodi con alcune righe di codice concise.

Programma visivo:

Programma testuale:

Nodo Python

Come i blocchi di codice, i nodi Python sono un'interfaccia di script all'interno di un ambiente di programmazione visiva. Il nodo Python è disponibile in Script>Editor>Script Python nella libreria.

Facendo doppio clic sul nodo, viene aperto l'editor di script Python. È inoltre possibile fare clic con il pulsante destro del mouse sul nodo e scegliere Modifica. Si noterà del testo boilerplate in alto, che è utile per fare riferimento alle librerie necessarie. Gli input vengono memorizzati nella matrice IN. I valori vengono restituiti a Dynamo assegnandoli alla variabile OUT.

I metodi includono costruttori quali ByCoordinates, azioni quali Add e query quali le coordinate X, Y e Z.

Esercizio: Nodo personalizzato con script Python per la creazione di motivi da un modulo solido

Parte I: Impostazione dello script Python

Scaricare il file di esempio facendo clic sul collegamento seguente.

Un elenco completo di file di esempio è disponibile nell'Appendice.

In questo esempio, si scriverà uno script di Python che crea modelli da un modulo solido e lo si trasformerà in un nodo personalizzato. Innanzitutto, creare il modulo solido utilizzando i nodi di Dynamo.

1. Rectangle.ByWidthLength: creare un rettangolo che sarà la base del solido.

2. Surface.ByPatch: collegare il rettangolo all'input "closedCurve" per creare la superficie inferiore.

1. Geometry.Translate: collegate il rettangolo all'input "geometry" per spostarlo verso l'alto, utilizzando un blocco di codice per specificare lo spessore di base del solido.

2. Polygon.Points: eseguire la query sul rettangolo traslato per estrarre i punti degli angoli.

3. Geometry.Translate: utilizzare un blocco di codice per creare un elenco di quattro valori corrispondenti ai quattro punti, traslando un angolo del solido verso l'alto.

4. Polygon.ByPoints: utilizzare i punti traslati per ricreare il poligono superiore.

5. Surface.ByPatch: collegare il poligono per creare la superficie superiore.

Ora che sono presenti le superfici superiore e inferiore, creati i lati del solido tramite loft tra i due profili.

1. List.Create: collegare il rettangolo inferiore e il poligono superiore agli input dell'indice.

2. Surface.ByLoft: eseguire il loft dei due profili per creare i lati del solido.

3. List.Create: collegare le superfici superiore, laterale e inferiore agli input dell'indice per creare un elenco di superfici.

4. Solid.ByJoinedSurfaces: unire le superfici per creare il modulo solido.

Ora che è stato realizzato il solido, rilasciare un nodo Script Python nell'area di lavoro.

1. Per aggiungere altri input al nodo, fare clic sull'icona + sul nodo. Gli input sono denominati IN[0], IN[1] e così via per indicare che rappresentano le voci di un elenco.

Iniziare definendo gli input e l'output. Fare doppio clic sul nodo per aprire l'editor di Python. Seguire il codice riportato qui sotto per modificare il codice nell'editor.

Questo codice risulterà più utile mentre si prosegue nell'esercizio. Successivamente, occorre pensare alle informazioni necessarie per includere in una matrice il modulo solido. Per prima cosa, è necessario conoscere le quote del solido per determinare la distanza di traslazione. A causa di un bug del riquadro di delimitazione, è necessario utilizzare la geometria della curva dello spigolo per creare un riquadro di delimitazione.

Osservare il nodo Python in Dynamo. Si noti che viene utilizzata la stessa sintassi presente nei titoli dei nodi in Dynamo. Consultare il codice commentato qui sotto.

Poiché si eseguiranno sia la traslazione che la rotazione dei moduli solidi, utilizzare l'operazione Geometry.Transform. Guardando il nodo Geometry.Transform, si sa che per trasformare il solido sarà necessario un sistema di coordinate di origine e un sistema di coordinate di destinazione. L'origine è il sistema di coordinate contestuale del solido, mentre la destinazione sarà un sistema di coordinate diverso per ogni modulo incluso nella matrice. Ciò significa che si dovrà riprodurre a ciclo continuo i valori X e Y per trasformare il sistema di coordinate in modo diverso ogni volta.

Fare clic su Esegui, quindi salvare il codice. Collegare il nodo Python con lo script esistente come indicato di seguito.

1. Collegare l'output da Solid.ByJoinedSurfaces come primo input per il nodo Python e utilizzare un Code Block per definire gli altri input.

2. Creare un nodo Topology.Edges e utilizzare l'output del nodo Python come input.

3. Infine, creare un nodo Edge.CurveGeometry e utilizzare l'output di Topology.Edges come input.

Provare a modificare il valore iniziale (seme) per creare modelli diversi. È anche possibile modificare i parametri del modulo solido stesso per effetti differenti.

Parte II: Conversione del nodo dello script Python in nodo personalizzato

Dopo aver creato uno script di Python utile, salvarlo come nodo personalizzato. Selezionare il nodo dello script Python, fare clic con il pulsante destro del mouse su Area di lavoro e selezionare Crea nodo personalizzato.

Assegnare un nome, una descrizione e una categoria.

Verrà aperta una nuova area di lavoro in cui modificare il nodo personalizzato.

1. Input: modificare i nomi di input in modo che siano più descrittivi e aggiungere i tipi di dati e i valori di default.

2. Output: consente di modificare il nome di output.

Salvare il nodo come file .dyf e il nodo personalizzato dovrebbe riflettere le modifiche appena apportate.

Con Dynamo 2.0 è possibile specificare un modello di default (.py extension) da utilizzare all'apertura della finestra di Python per la prima volta. Questa è stata una richiesta a lungo desiderata perché consente di accelerare l'utilizzo di Python all'interno di Dynamo. La possibilità di utilizzare un modello consente di avere importazioni di default pronte per lo sviluppo di uno script Python personalizzato.

La posizione di questo modello è APPDATA per l'installazione di Dynamo.

In genere, è la seguente: ( %appdata%\Dynamo\Dynamo Core\{version}\ ).

Configurazione del modello

Per utilizzare questa funzionalità, è necessario aggiungere la seguente riga nel file DynamoSettings.xml. (Modifica nel Blocco note)

Dove è visibile la riga <PythonTemplateFilePath />, è sufficiente sostituirla con quanto segue:

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

Successivamente, è necessario creare un modello con le funzionalità incorporate che si desidera utilizzare. In questo caso, si incorporano le importazioni correlate a Revit e alcuni degli altri elementi tipici quando si utilizza Revit.

È possibile aprire un documento del Blocco note vuoto e incollare il seguente codice all'interno:

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

Al termine, salvare il file come PythonTemplate.py nella posizione APPDATA.

Funzionamento successivo dello script Python

D_o_po aver definito un modello di Python, verrà cercato in Dynamo ogni volta che viene posizionato un nodo Python. Se non viene trovato, sarà simile alla finestra di Python di default.

Se viene trovato il modello di Python (ad esempio, come il modello di Revit), verranno visualizzati tutti gli elementi di default incorporati.

Ulteriori informazioni su questa straordinaria aggiunta (di Radu Gidei) sono disponibili qui. https://github.com/DynamoDS/Dynamo/pull/8122

​Python è un linguaggio di programmazione ampiamente utilizzato, la cui popolarità ha molto a che fare con il suo stile di sintassi. È altamente leggibile, il che rende più semplice l'apprendimento di molti altri linguaggi. Python supporta moduli e pacchetti e può essere incorporato nelle applicazioni esistenti. Per informazioni su come iniziare ad utilizzare Python, una buona risorsa è la pagina "Getting Started" sul sito Python.org