Com o Dynamo 2.0, podemos especificar um modelo padrão (.py extension) para usar ao abrir a janela do Python pela primeira vez. Essa foi uma solicitação muito desejada, pois isso acelera o uso do Python no Dynamo. Ter a capacidade de usar um modelo nos permite ter as importações padrão prontas para serem usadas quando quisermos desenvolver um script Python personalizado.

A localização desse modelo está em APPDATA da instalação do Dynamo.

Normalmente, é ( %appdata%\Dynamo\Dynamo Core\{version}\ ).

Configurar o modelo

Para usar essa funcionalidade, é necessário adicionar a seguinte linha em nosso arquivo DynamoSettings.xml. (Editar no bloco de notas)

Onde vemos <PythonTemplateFilePath />, basta substituir por:

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

Em seguida, precisamos criar um modelo com a funcionalidade que desejamos usar incorporada. Em nosso caso, vamos incorporar as importações relacionadas ao Revit e alguns dos outros itens típicos ao trabalhar com o Revit.

É possível iniciar um documento do bloco de notas em branco e colar o seguinte código:

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

Uma vez feito isso, salve o arquivo como PythonTemplate.py na localização APPDATA.

Comportamento posterior do script Python

Após o modelo do Python ser definido, o Dynamo procurará esses dados sempre que um nó do Python for inserido. Se não forem encontrados, será semelhante à janela padrão do Python.

Se o modelo do Python for encontrado (como nosso modelo do Revit, por exemplo), será possível ver todos os itens padrão incorporados.

Você pode obter mais informações sobre esta grande inclusão (desenvolvida por Radu Gidei) aqui. https://github.com/DynamoDS/Dynamo/pull/8122

​O Python é uma linguagem de programação amplamente usada, cuja popularidade tem muito a ver com seu estilo de sintaxe. É altamente legível, o que a torna mais fácil de aprender do que muitas outras linguagens. O Python oferece suporte a módulos e pacotes e pode ser incorporado em aplicativos existentes. Para obter informações sobre como começar a usar o Python, um bom recurso é a página “Getting Started” (Introdução) em Python.org.

Por que você usaria a programação textual no ambiente de programação visual do Dynamo? A tem muitas vantagens. Ela permite que você crie programas sem aprender sintaxe especial em uma interface visual intuitiva. No entanto, um programa visual pode se tornar confuso e, às vezes, pode ter funcionalidade insatisfatória. Por exemplo, o Python oferece métodos muito mais simples de escrever declarações condicionais (if/then) e loops. O Python é uma ferramenta avançada que pode ampliar os recursos do Dynamo e permitir que você substitua muitos nós por algumas linhas concisas de código.

Programa visual:

Programa textual:

O nó do Python

Como os blocos de código, os nós do Python são uma interface de scripts dentro de um ambiente de programação visual. O nó do Python pode ser encontrado em Script>Editor>Script do Python na biblioteca.

Clicando duas vezes no nó, é aberto o editor de scripts do Python (também é possível clicar com o botão direito do mouse no nó e selecionar Editar...). Você observará algum texto padronizado na parte superior, que pretende ajudar você a consultar as bibliotecas necessárias. As entradas estão armazenadas na matriz IN. Os valores são retornados ao Dynamo quando são atribuídos à variável OUT

Os métodos incluem construtores como ByCoordinates, ações como Add e consultas como as coordenadas X, Y e Z.

Exercício: Nó personalizado com o script do Python para criar padrões com base no módulo sólido

Parte I: Configurar o script do Python

Faça o download do arquivo de exemplo clicando no link abaixo.

É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.

Neste exemplo, escreveremos um script Python que cria padrões de um módulo sólido e o transforma em um nó personalizado. Primeiro, vamos criar nosso módulo sólido usando os nós do Dynamo.

1. Rectangle.ByWidthLength: crie um retângulo que será a base do nosso sólido.

2. Surface.ByPatch: conecte o retângulo à entrada “closedCurve” para criar a superfície inferior.

1. Geometry.Translate: conecte o retângulo à entrada “geometry” para movê-lo para cima, usando um bloco de código para especificar a espessura da base do nosso sólido.

2. Polygon.Points: consulte o retângulo convertido para extrair os pontos de canto.

3. Geometry.Translate: use um bloco de código para criar uma lista de quatro valores correspondentes aos quatro pontos, convertendo um canto do sólido para cima.

4. Polygon.ByPoints: use os pontos convertidos para reconstruir o polígono superior.

5. Surface.ByPatch: conecte o polígono para criar a superfície superior.

Agora que temos as superfícies superior e inferior, vamos elevar os dois perfis para criar os lados do sólido.

1. List.Create: conecte o retângulo inferior e o polígono superior às entradas do índice.

2. Surface.ByLoft: eleve os dois perfis para criar os lados do sólido.

3. List.Create: conecte as superfícies superior, laterais e inferior às entradas do índice para criar uma lista de superfícies.

4. Solid.ByJoinedSurfaces: una as superfícies para criar o módulo sólido.

Agora que temos nosso sólido, vamos colocar um nó do script do Python no espaço de trabalho.

1. Para adicionar mais entradas ao nó, clique no ícone + no nó. As entradas são nomeadas IN[0], IN[1], etc. para indicar que representam itens em uma lista.

Vamos começar definindo nossas entradas e saídas. Clique duas vezes no nó para abrir o editor do Python. Siga o código abaixo para modificar o código no editor.

Esse código fará mais sentido à medida que progredirmos no exercício. Em seguida, precisaremos pensar sobre quais informações são necessárias para organizar o módulo de sólido. Primeiro, precisamos conhecer as dimensões do sólido para determinar a distância de conversão. Devido a uma falha da caixa delimitadora, será necessário usar a geometria de curva de aresta para criar uma caixa delimitadora.

Veja o nó do Python no Dynamo. Observe que estamos usando a mesma sintaxe que vemos nos títulos dos nós no Dynamo. Confira o código comentado abaixo.

Como vamos converter e girar os módulos de sólido, usaremos a operação Geometry.Transform. Observando o nó Geometry.Transform, sabemos que precisaremos de um sistema de coordenadas de origem e um sistema de coordenadas de destino para transformar o sólido. A origem é o sistema de coordenadas do contexto do nosso sólido, enquanto o destino será um sistema de coordenadas diferente para cada módulo com matriz. Isso significa que teremos que fazer um loop pelos valores x e y para transformar o sistema de coordenadas de forma diferente a cada vez.

Clique em Executar e, em seguida, salve o código. Conecte o nó do Python ao nosso script existente da seguinte maneira.

1. Conecte a saída de Solid.ByJoinedSurfaces como a primeira entrada para o nó do Python e use um bloco de código para definir as outras entradas.

2. Crie um nó Topology.Edges e use a saída do nó do Python como entrada.

3. Por fim, crie um nó Edge.CurveGeometry e use a saída de Topology.Edges como entrada.

Tente alterar o valor gerador para criar diferentes padrões. Também é possível alterar os parâmetros do próprio módulo sólido para obter diferentes efeitos.

Parte II: Transformar o nó do script do Python em nó personalizado

Agora que criamos um script Python útil, vamos salvá-lo como um nó personalizado. Selecione o nó do script do Python, clique com o botão direito do mouse no espaço de trabalho e selecione “Criar nó personalizado”.

Atribua um nome, uma descrição e uma categoria.

Isso abrirá um novo espaço de trabalho no qual o nó personalizado será editado.

1. Entradas: altere os nomes das entradas para que sejam mais descritivos e adicione tipos de dados e valores padrão.

2. Saída: altere o nome da saída

Salve o nó como um arquivo .dyf. Em seguida, você deverá ver que o nó personalizado reflete as alterações que acabamos de fazer.

Python e Revit

Agora que demonstramos como usar scripts Python no Dynamo, vamos analisar como conectar as bibliotecas do Revit ao ambiente de scripts. Lembre-se, importamos os nós do núcleo padrão do Python e os nossos do Dynamo com as quatro primeiras linhas do bloco de código abaixo. Para importar os nós, os elementos e o gerenciador de documentos do Revit, só precisamos adicionar mais algumas linhas:

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

Isso nos fornece acesso à API do Revit e oferece scripts personalizados para qualquer tarefa do Revit. Ao combinar o processo de programação visual com scripts da API do Revit, a colaboração e o desenvolvimento de ferramentas melhoram significativamente. Por exemplo, um gerente do BIM e um projetista esquemático podem trabalhar juntos no mesmo gráfico. Nessa colaboração, eles podem aprimorar o projeto e a execução do modelo.

APIs específicas da plataforma

O plano por trás do projeto do Dynamo é ampliar o escopo da implementação da plataforma. À medida que o Dynamo adiciona mais programas ao registro, os usuários obterão acesso a APIs específicas de plataforma do ambiente de scripts Python. Embora o Revit seja o estudo de caso desta seção, podemos prever mais capítulos que oferecem tutoriais abrangentes sobre scripts em outras plataformas. Além disso, agora há muitas bibliotecas IronPython acessíveis que podem ser importadas para o Dynamo.

Os exemplos abaixo demonstram as maneiras de implementar operações específicas do Revit no Dynamo usando o Python. Para obter uma análise mais detalhada sobre a relação do Python com o Dynamo e o Revit, consulte a página Wiki do Dynamo. Outro recurso útil para o Python e o Revit é o projeto Revit Python Shell.

Exercício 1

Crie um novo projeto do Revit.

Faça o download do arquivo de exemplo clicando no link abaixo.

É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.

Nestes exercícios, vamos explorar os scripts Python elementares no Dynamo for Revit. O exercício se concentrará em lidar com os arquivos e elementos do Revit, bem como na comunicação entre o Revit e o Dynamo.

Esse é um método preparado previamente para recuperar o doc, uiapp e app do arquivo do Revit vinculado à sessão do Dynamo. Os programadores que já trabalharam na API do Revit podem observar os itens na lista de inspeção. Se esses itens não parecerem familiares, não há problema, usaremos outros exemplos nos exercícios abaixo.

Confira a seguir como importamos serviços do Revit e recuperamos os dados do documento no Dynamo.

Veja o nó do Python no Dynamo. Você também pode encontrar o código abaixo:

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

Exercício 2

Faça o download do arquivo de exemplo clicando no link abaixo.

É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.

Neste exercício, vamos criar uma curva de modelo simples no Revit usando o nó do Python do Dynamo.

Comece criando uma nova família de massa conceitual no Revit.

Abra a Pasta de massa conceitual e use o arquivo de modelo Metric Mass.rft.

No Revit, use o atalho de teclado un para abrir as configurações da unidade do projeto e altere a unidade de comprimento para metros.

Inicie o Dynamo e crie o conjunto de nós na imagem abaixo. Primeiro, criaremos dois pontos de referência no Revit com base nos nós do Dynamo.

1. Crie um bloco de código e atribua o valor "0;"

2. Conecte esse valor a um nó ReferencePoint.ByCoordinates para as entradas X, Y e Z.

3. Crie três controles deslizantes, variando de -100 a 100 com um tamanho de etapa de 1.

4. Conecte cada controle deslizante a um nó ReferencePoint.ByCoordinates.

5. Adicione um nó do Python ao espaço de trabalho, clique no botão “+” no nó para adicionar outra entrada e conecte os dois pontos de referência em cada entrada. Abra o nó do Python.

Veja o nó do Python no Dynamo. Encontre o código completo abaixo.

1. System.Array: o Revit precisa de uma matriz do sistema como uma entrada (em vez de uma lista do Python). Isso é apenas mais uma linha de código, mas prestar atenção aos tipos de argumentos facilitará a programação em Python no 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)

No Dynamo, criamos dois pontos de referência com uma linha que os conecta usando o Python. Vamos aprofundar isso um pouco no próximo exercício.

Exercício 3

Faça o download do arquivo de exemplo clicando no link abaixo.

É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.

Este exercício mantém a simplicidade, mas esclarece os tópicos de conexão de dados e a geometria do Revit para o Dynamo e vice-versa. Começaremos abrindo o Revit-StructuralFraming.rvt. Depois de aberto, inicie o Dynamo e abra o arquivo Revit-StructuralFraming.dyn.

Esse arquivo do Revit é o mais básico possível. Duas curvas de referência: uma desenhada no Nível 1 e outra desenhada no Nível 2. Queremos inserir essas curvas no Dynamo e manter um vínculo dinâmico.

Nesse arquivo, temos um conjunto de nós que se conectam a cinco entradas de um nó do Python.

1. Nós Selecionar elemento do modelo: clique no botão de seleção para cada um e selecione uma curva correspondente no Revit.

2. Bloco de código:: usando a sintaxe 0..1..#x;, conecte um controle deslizante de número inteiro que varia entre 0 e 20 à entrada x. Isso especifica o número de vigas a serem desenhadas entre as duas curvas.

3. Tipos de framing estrutural: escolheremos a viga padrão W12x26 na opção do menu suspenso.

4. Níveis: selecione “Nível 1”.

Esse código no Python é um pouco mais denso, mas os comentários no código descrevem o que está acontecendo no 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)

No Revit, temos uma matriz de vigas que se estendem pelas duas curvas como elementos estruturais. Observação: Este exemplo não é realista... os elementos estruturais são usados como um exemplo para instâncias nativas do Revit criadas no Dynamo.

No Dynamo, também podemos ver os resultados. As vigas no nó Watch3D se referem à geometria consultada dos elementos do Revit.

Observe que temos um processo contínuo de conversão de dados do ambiente do Revit para o ambiente do Dynamo. Em resumo, veja como o processo é realizado:

1. Selecionar o elemento do Revit

2. Converter o elemento do Revit em curva do Dynamo

3. Dividir a curva do Dynamo em uma série de pontos do Dynamo

4. Usar os pontos do Dynamo entre duas curvas para criar linhas do Dynamo

5. Criar vigas do Revit referenciando linhas do Dynamo

6. Gerar saída de superfícies do Dynamo ao consultar a geometria de vigas do Revit

Isso pode parecer um pouco severo, mas o script torna isso tão simples quando editar a curva no Revit e executar novamente o solucionador (embora você possa precisar excluir as vigas anteriores ao fazer isso). Isso se deve ao fato de que estamos colocando vigas no Python e, portanto, quebrando a associação que os nós prontos para uso têm.

Com uma atualização das curvas de referência no Revit, obtemos uma nova matriz de vigas.