O bloco de código é um recurso exclusivo no Dynamo que vincula dinamicamente um ambiente de programação visual com um baseado em texto. O bloco de código tem acesso a todos os nós do Dynamo e pode definir um gráfico completo em um nó. Leia este capítulo com atenção, já que o bloco de código é um bloco de construção fundamental do Dynamo.

Abreviação

Existem alguns métodos de abreviação básicos no bloco de código que, em termos simples, facilitam muito o gerenciamento de dados. Vamos explicar os conceitos básicos abaixo e discutir como a abreviação pode ser usada para criar e consultar dados.

Sintaxe adicional

Intervalos e sequências

É possível reduzir o método para definir intervalos e sequências para a abreviação básica. Use a imagem abaixo como um guia para a sintaxe “...” para definir uma lista de dados numéricos com o bloco de código. Após obter o travamento dessa notação, a criação de dados numéricos é um processo realmente eficiente:

1. Neste exemplo, um intervalo de números é substituído pela sintaxe básica do Bloco de código que define beginning..end..step-size; . Representados numericamente, temos: 0..10..1;

2. Observe que a sintaxe 0..10..1; é equivalente a 0..10; Um tamanho de etapa de 1 é o valor padrão para a notação abreviada. Assim, 0..10; será fornecida uma sequência de 0 a 10 com um tamanho de etapa de 1.

3. O exemplo de Sequência é semelhante, exceto se usarmos “#” para indicar que desejamos 15 valores na lista em vez de uma lista que vai até 15. Neste caso, estamos definindo: beginning..#ofSteps..step-size: A sintaxe real para a sequência é 0..#15..2

4. Usando o símbolo “#” da etapa anterior, agora o colocamos na parte “step-size” da sintaxe. Agora, temos um intervalo de números que se estende de “beginning” até “end”, e a notação “step-size” distribui uniformemente alguns valores entre os dois: beginning..end..#ofSteps

Intervalos avançados

A criação de intervalos avançados nos permite trabalhar com uma lista de listas de forma simples. Nos exemplos abaixo, vamos isolar uma variável da notação do intervalo principal e criar outro intervalo dessa lista.

1. Criando intervalos aninhados, compare a notação com “#” e a notação sem. A mesma lógica se aplica a intervalos básicos, exceto pelo fato de que fica um pouco mais complexo.

2. Podemos definir um subintervalo em qualquer lugar dentro do intervalo principal e observar que também podemos ter dois subintervalos.

3. Controlando o valor “end” em um intervalo, criamos mais intervalos de comprimentos diferentes.

Como um exercício lógico, compare as duas abreviações acima e tente analisar como os subintervalos e a notação # controlam a saída resultante.

Criar listas e obter itens de uma lista

Além de criar listas com abreviações, podemos criar listas imediatamente. Essas listas podem conter um amplo intervalo de tipos de elementos e também podem ser consultadas (lembre-se: as próprias listas são objetos). Para resumir, com o bloco de código você faz listas e consulta itens de uma lista com colchetes :

1. Crie listas rapidamente com sequências de caracteres e consulte-as usando o índice do item.

2. Crie listas com variáveis e consulte usando a notação de abreviação de intervalo.

O gerenciamento com listas aninhadas é um processo semelhante. Esteja ciente da ordem da lista e chame de volta usando vários conjuntos de colchetes:

1. Defina uma lista de listas.

2. Consulte uma lista com uma notação de colchete único.

3. Consulte um item com uma notação de colchete duplo.

Exercício: Superfície senoidal

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, flexibilizaremos nossas novas habilidades de abreviação para criar uma superfície de casca de ovo moderna definida por intervalos e fórmulas. Durante este exercício, observe como usamos o bloco de código e os nós do Dynamo existentes em conjunto: usamos o bloco de código para o levantamento de dados pesados enquanto os nós do Dynamo são visualmente dispostos para a legibilidade da definição.

Comece criando uma superfície conectando os nós acima. Em vez de usar um nó de número para definir a largura e o comprimento, clique duas vezes na tela e digite 100; em um bloco de código

1. Defina um intervalo entre 0 e 1 com 50 divisões digitando 0..1..#50 em um Bloco de código.

2. Conecte o intervalo a Surface.PointAtParameter, que usa os valores u e v entre 0 e 1 na superfície. Lembre-se de alterar a Amarra para Produto transversal clicando com o botão direito do mouse no nó Surface.PointAtParameter.

Nesta etapa, empregamos nossa primeira função para mover o eixo de pontos para cima no Z. Esse eixo controlará uma superfície gerada com base na função subjacente. Adicione novos nós, como mostrado na imagem abaixo

1. Em vez de usar um nó de fórmula, usamos um Bloco de código com a linha: (0..Math.Sin(x*360)..#50)*5;. Para analisar isso rapidamente, definimos um intervalo com uma fórmula dentro dele. Essa fórmula é a função Seno. A função seno recebe entradas de grau no Dynamo, portanto, para obter uma onda senoidal completa, multiplicamos nossos valores de x (essa é a entrada de intervalo de 0 a 1) por 360. Em seguida, queremos o mesmo número de divisões que os pontos de eixo de controle para cada linha, portanto, definimos cinquenta subdivisões com #50. Finalmente, o multiplicador de 5 simplesmente aumenta a amplitude da conversão para que possamos ver o efeito na Visualização do Dynamo.

1. Apesar de o Bloco de código anterior funcionar bem, não era completamente paramétrico. Queremos controlar os parâmetros dinamicamente; portanto, substituiremos a linha da etapa anterior por (0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;. Isso nos oferece a capacidade de definir esses valores com base nas entradas.

Alterando os controles deslizantes (de 0 a 10), obtemos resultados interessantes.

1. Efetuando uma transposição no intervalo de números, inverteremos a direção da onda da cortina: transposeList = List.Transpose(sineList);

1. Obtemos uma superfície de casca de ovo distorcida quando adicionamos sineList e tranposeList: eggShellList = sineList+transposeList;

Vamos alterar os valores dos controles deslizantes especificados abaixo para “acalmar as águas” deste algoritmo.

Por último, vamos consultar partes isoladas dos dados com o bloco de código. Para regenerar a superfície com um intervalo específico de pontos, adicione o bloco de código acima entre os nós Geometry.Translate e NurbsSurface.ByPoints. Isso tem a linha de texto: sineStrips[0..15..1];. Isso selecionará as primeiras 16 linhas de pontos (de 50). Recriando a superfície, podemos ver que geramos uma parte isolada do eixo de pontos.

1. Na etapa final, para tornar esse Bloco de código mais paramétrico, controlaremos a consulta usando um controle deslizante que varia entre 0 e 1. Fazemos isso com esta linha de código: sineStrips[0..((List.Count(sineStrips)-1)*u)];. Isso pode parecer confuso, mas a linha de código nos fornece uma forma rápida de dimensionar o comprimento da lista em um multiplicador entre 0 e 1.

Um valor de 0.53 no controle deslizante cria uma superfície logo após o ponto central do eixo.

E, conforme esperado, um controle deslizante de 1 cria uma superfície com base no eixo completo de pontos.

Analisando o gráfico visual, podemos realçar os blocos de código e ver cada uma de suas funções.

1. O primeiro Bloco de código substitui o nó Número.

2. O segundo Bloco de código substitui o nó Intervalo de números.

3. O terceiro Bloco de código substitui o nó Fórmula (assim como List.Transpose, List.Count e Intervalo de números).

4. O quarto Bloco de código consulta uma lista de listas, substituindo o nó List.GetItemAtIndex.

As funções podem ser criadas em um Code Block e chamadas em outro lugar da definição do Dynamo. Isto cria outra camada de controle em um arquivo paramétrico e pode ser visualizado como uma versão com base em texto de um nó personalizado. Neste caso, o Code Block "principal" é facilmente acessível e pode ser localizado em qualquer lugar do gráfico. Não é necessário fio!

Principal

A primeira linha tem a palavra-chave "def", depois o nome da função e, a seguir, os nomes das entradas entre parênteses. Os contraventamentos definem o corpo da função. Retorne um valor com "return =". Os Blocos de código que definem uma função não possuem portas de entrada ou saída porque eles são chamados de outros Blocos de código.

Secundários

Chame a função com outro Code Block no mesmo arquivo fornecendo o mesmo nome e o mesmo número de argumentos. Funciona da mesma forma que os nós prontos para uso da sua biblioteca.

Exercício: Esfera por Z

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 definição genérica que irá criar esferas a partir de uma lista de entrada de pontos. O raio dessas esferas é conduzido pela propriedade Z de cada ponto.

Vamos começar com um intervalo de números de dez valores , de 0 a 100. Conecte-os a um nó Point.ByCoordinates para criar uma linha diagonal.

Crie um Bloco de código e insira a nossa definição.

1. Use estas linhas de código:

O inputPt é o nome que atribuímos para representar os pontos que guiarão a função. Por agora, a função não está fazendo nada, mas vamos desenvolver essa função nas etapas a seguir.

1. Quando a função Bloco de código é adicionada, colocamos um comentário e uma variável sphereRadius que consulta a posição Z de cada ponto. Lembre-se de que inputPt.Z não precisa de parênteses como um método. Essa é uma consulta das propriedades de um elemento existente; portanto, nenhuma entrada é necessária:

1. Agora, vamos recordar a função que criamos em outro Bloco de código. Se clicarmos duas vezes na tela para criar um novo bloco de código e digitarmos sphereB, notamos que o Dynamo sugere a função sphereByZ que foi definida. A função foi adicionada à biblioteca intellisense. Muito legal.

1. Agora, chamamos a função e criamos uma variável chamada Pt para conectar os pontos criados nas etapas anteriores:
2. Observe que, na saída, temos todos os valores nulos. Por que isso ocorre? Quando definimos a função, estamos calculando a variável sphereRadius, mas não definimos o que a função deve ser retornada como uma saída. Podemos corrigir isso na próxima etapa.

1. Uma etapa importante: é necessário definir a saída da função adicionando a linha return = sphereRadius; à função sphereByZ.

2. Agora, vemos que a saída do Bloco de código nos fornece as coordenadas Z de cada ponto.

Agora, vamos criar esferas reais editando a função Principal.

1. Primeiro definimos uma esfera com a linha de código: sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);

2. Em seguida, alteramos o valor de retorno para sphere em vez de sphereRadius: return = sphere; Isso nos fornece algumas esferas gigantes em nossa visualização do Dynamo.

1. Para reduzir o tamanho dessas esferas, vamos atualizar o valor sphereRadius adicionando um divisor: sphereRadius = inputPt.Z/20; Agora podemos ver as esferas separadas e começar a entender a relação entre o raio e o valor Z.

1. No nó Point.ByCoordinates, alterando a amarra de Lista mais curta para Produto transversal, criamos uma grade de pontos. A função sphereByZ ainda está em pleno efeito, de modo que todos os pontos criam esferas com raios com base em valores Z.

1. E apenas para efeitos de teste, conectamos a lista original de números à entrada X para Point.ByCoordinates. Agora temos um cubo de esferas.

2. Observação: Se isso levar muito tempo para ser calculado no computador, tente alterar #10 para algo como #5.

Lembre-se: A função sphereByZ que foi criada é uma função genérica, para que possamos recuperar a hélice de uma lição anterior e aplicar a função a ela.

Uma etapa final: vamos conduzir a relação do raio com um parâmetro definido pelo usuário. Para fazer isso, é necessário criar uma nova entrada para a função e também substituir o divisor 20 por um parâmetro.

1. Atualize a definição de sphereByZ para:
2. Atualize o Bloco de código secundário adicionando uma variável de relação à entrada: sphereByZ(Pt,ratio); Conecte um controle deslizante à entrada do Bloco de código recém-criado e varie o tamanho dos raios com base na relação de raio.

Os blocos de código são uma janela localizada no DesignScript, a linguagem de programação principal do Dynamo. Desenvolvido do zero para suportar fluxos de trabalho de projeto exploratório, o DesignScript é uma linguagem legível e concisa que oferece comentários imediatos a pequenos bits de código e também é dimensionado para interações grandes e complexas. O DesignScript também forma a espinha dorsal do mecanismo que motiva a maioria dos aspectos do Dynamo “essenciais”. Como quase todas as funções encontradas nos nós e nas interações do Dynamo têm uma relação estreita com a linguagem de scripts, há oportunidades únicas para alternar o uso entre as interações baseadas em nós e os scripts de uma forma fluida.

Para iniciantes, os nós podem ser convertidos automaticamente em sintaxe de texto para ajudar a aprender o DesignScript ou simplesmente para reduzir o tamanho de seções maiores de gráficos. Isso é feito usando um processo denominado “Nó para código”, que é descrito com mais detalhes na seção . Os usuários mais experientes podem usar os blocos de código para criar mashups personalizados de relacionamentos existentes de usuários e funcionalidades, usando muitos paradigmas de codificação padrão. Entre o usuário iniciante e o avançado, há um grande número de atalhos e fragmentos de código que aceleram seus projetos. Embora o termo “bloco de código” possa ser um pouco intimidador para não programadores, é fácil de usar e robusto. Um iniciante pode usar o bloco de código de forma eficiente com codificação mínima, e um usuário avançado pode definir definições de script para serem chamadas em outro lugar em uma definição do Dynamo.

Bloco de código: uma breve visão geral

Em resumo, os blocos de código são uma interface de scripts de texto em um ambiente de scripts visuais. Eles podem ser usados como números, sequências de caracteres, fórmulas e outros tipos de dados. O bloco de código é projetado para o Dynamo, portanto, é possível definir variáveis arbitrárias no bloco de código, e essas variáveis são automaticamente adicionadas às entradas do nó:

Com os blocos de código, um usuário tem a flexibilidade de decidir como especificar as entradas. Confira a seguir várias maneiras de criar um ponto básico com coordenadas (10, 5, 0):

À medida que você aprende mais sobre as funções disponíveis na biblioteca, lembre-se de que digitar “Point.ByCoordinates” é mais rápido do que pesquisar na biblioteca e localizar o nó apropriado. Quando você digita “Point.”, por exemplo, o Dynamo exibirá uma lista de possíveis funções para aplicar a um ponto. Isso torna o script mais intuitivo e ajudará no processo de aprendizagem de como aplicar funções no Dynamo.

Criar nós de bloco de código

O bloco de código pode ser encontrado em Core>Input>Actions>Code Block. Mas existe um modo mais rápido: basta clicar duas vezes na tela e o bloco de código aparece. Esse nó é usado com tanta frequência que recebeu o privilégio de ser acionado com duplo clique.

Números, sequências de caracteres e fórmulas

Os blocos de código também são flexíveis em relação aos tipos de dados. O usuário pode definir rapidamente os números, as sequências e as fórmulas, e o bloco de código fornecerá o resultado desejado.

Na imagem abaixo, é possível ver que a forma de fazer as coisas “à moda antiga” é um pouco demorada: o usuário procura o nó desejado na interface, adiciona o nó à tela e insere os dados. Com o bloco de código, o usuário pode clicar duas vezes na tela para abrir o nó e digitar o tipo de dados correto com sintaxe básica.

Os nós número, sequência de caracteres e fórmula são três exemplos de nós do Dynamo que são provavelmente obsoletos em comparação ao bloco de código.

1. “Tradicional”

2. Blocos de código

O Dynamo é uma ótima porta de entrada para a escrita de códigos para o mundo AEC. Você pode ter interesse em algumas destas seções para iniciar sua jornada de codificação:

CoordinateSystem

Embora o Dynamo seja capaz de criar uma variedade de formas geométricas complexas, as primitivas geométricas simples formam a espinha dorsal de qualquer projeto de cálculo: expressas diretamente na forma final projetada ou usadas como pontos de partida dos quais é gerada uma geometria mais complexa.

Embora não seja estritamente uma geometria, o CoordinateSystem é uma ferramenta importante para construir a geometria. Um objeto CoordinateSystem mantém o controlo das transformações de posição e geométricas, como rotação, cisalhamento e escala.

Criar um CoordinateSystem centralizado em um ponto com x = 0, y = 0, z = 0, sem rotações, escala ou transformações de cisalhamento, requer simplesmente a chamada do construtor Identity:

// create a CoordinateSystem at x = 0, y = 0, z = 0,
// no rotations, scaling, or sheering transformations

cs = CoordinateSystem.Identity();

Os CoordinateSystems com transformações geométricas estão fora do escopo deste capítulo, embora outro construtor permita criar um sistema de coordenadas em um ponto específico, CoordinateSystem.ByOriginVectors:

// create a CoordinateSystem at a specific location,
// no rotations, scaling, or sheering transformations
x_pos = 3.6;
y_pos = 9.4;
z_pos = 13.0;

origin = Point.ByCoordinates(x_pos, y_pos, z_pos);
identity = CoordinateSystem.Identity();

cs = CoordinateSystem.ByOriginVectors(origin,
    identity.XAxis, identity.YAxis, identity.ZAxis);

Ponto

A primitiva geométrica mais simples é um Ponto, representando uma localização de dimensão zero no espaço tridimensional. Como mencionado anteriormente, há diversas formas de criar um ponto em um determinado sistema de coordenadas: Point.ByCoordinates cria um ponto com as coordenadas x, y e x especificadas; Point.ByCartesianCoordinates cria um ponto com as coordenadas x, y e x especificadas em um sistema de coordenadas específico; Point.ByCylindricalCoordinates cria um ponto sobre um cilindro com o raio, o ângulo de rotação e a altura; e Point.BySphericalCoordinates cria um ponto sobre uma esfera com o raio e dois ângulos de rotação.

Este exemplo mostra pontos criados em vários sistemas de coordenadas:

// create a point with x, y, and z coordinates
x_pos = 1;
y_pos = 2;
z_pos = 3;

pCoord = Point.ByCoordinates(x_pos, y_pos, z_pos);

// create a point in a specific coordinate system
cs = CoordinateSystem.Identity();
pCoordSystem = Point.ByCartesianCoordinates(cs, x_pos,
    y_pos, z_pos);

// create a point on a cylinder with the following
// radius and height
radius = 5;
height = 15;
theta = 75.5;

pCyl = Point.ByCylindricalCoordinates(cs, radius, theta,
    height);

// create a point on a sphere with radius and two angles

phi = 120.3;

pSphere = Point.BySphericalCoordinates(cs, radius,
    theta, phi);

Linha

A próxima primitiva dimensional superior do Dynamo é um segmento de linha, representando um número infinito de pontos entre dois pontos finais. É possível criar as linhas explicitamente especificando os dois pontos de limite com o construtor Line.ByStartPointEndPoint ou especificando um ponto inicial, uma direção e um comprimento nessa direção, Line.ByStartPointDirectionLength.

p1 = Point.ByCoordinates(-2, -5, -10);
p2 = Point.ByCoordinates(6, 8, 10);

// a line segment between two points
l2pts = Line.ByStartPointEndPoint(p1, p2);

// a line segment at p1 in direction 1, 1, 1 with
// length 10
lDir = Line.ByStartPointDirectionLength(p1,
    Vector.ByCoordinates(1, 1, 1), 10);

Primitivos 3D – cuboide, cone, cilindro, esfera etc.

O Dynamo tem objetos que representam os tipos mais básicos de primitivas geométricas em três dimensões: cuboides, criados com Cuboid.ByLengths; cones, criados com Cone.ByPointsRadius e Cone.ByPointsRadii; cilindros, criados com Cylinder.ByRadiusHeight; e esferas, criadas com Sphere.ByCenterPointRadius.

// create a cuboid with specified lengths
cs = CoordinateSystem.Identity();

cub = Cuboid.ByLengths(cs, 5, 15, 2);

// create several cones
p1 = Point.ByCoordinates(0, 0, 10);
p2 = Point.ByCoordinates(0, 0, 20);
p3 = Point.ByCoordinates(0, 0, 30);

cone1 = Cone.ByPointsRadii(p1, p2, 10, 6);
cone2 = Cone.ByPointsRadii(p2, p3, 6, 0);

// make a cylinder
cylCS = cs.Translate(10, 0, 0);

cyl = Cylinder.ByRadiusHeight(cylCS, 3, 10);

// make a sphere
centerP = Point.ByCoordinates(-10, -10, 0);

sph = Sphere.ByCenterPointRadius(centerP, 5);

Em projetos de cálculo, as curvas e as superfícies são usadas com frequência como o esboço subjacente para construir a geometria subsequente. Para que esta geometria inicial seja usada como uma fundação para a geometria posterior, o script deve ser capaz de extrair qualidades como a posição e a orientação através de toda a área do objeto. As curvas e as superfícies suportam essa extração, que é chamada de parametrização.

Todos os pontos em uma curva podem ser considerados como tendo um parâmetro único variando de 0 a 1. Se fôssemos criar uma NurbsCurve com base em diversos pontos de controle ou interpolados, o primeiro ponto teria o parâmetro 0 e o último ponto teria o parâmetro 1. É impossível saber antecipadamente qual é o parâmetro exato que qualquer ponto intermediário representa, o que pode parecer uma limitação severa, embora seja atenuada por uma série de funções de utilitários. As superfícies têm uma parametrização semelhante às curvas, mas com dois parâmetros em vez de um, chamados u e v. Se criássemos uma superfície com os seguintes pontos:

p1 teria o parâmetro u = 0 v = 0, enquanto p9 teria os parâmetros u = 1 v = 1.

A parametrização não é particularmente útil ao determinar os pontos usados para gerar curvas, seu principal uso será determinar as localizações se os pontos intermediários forem gerados pelos construtores NurbsCurve e NurbsSurface.

As curvas têm um método PointAtParameter, que assume um único argumento duplo entre 0 e 1, e retorna o objeto de ponto naquele parâmetro. Por exemplo, esse script localiza os pontos nos parâmetros 0, .1, .2, .3, .4, .5, .6, .7, .8, .9 e 1:

De forma similar, as superfícies têm um método PointAtParameter que assume dois argumentos, os parâmetros u e v do ponto gerado.

Embora a extração de pontos individuais em uma curva e superfície possa ser útil, os scripts geralmente exigem o conhecimento das características geométricas específicas de um parâmetro, como a direção da curva ou da superfície. O método CoordinateSystemAtParameter localiza não somente a posição como também um CoordinateSystem orientado no parâmetro de uma curva ou superfície. Por exemplo, o script a seguir extrai o CoordinateSystems orientado ao longo de uma superfície de revolução e usa a orientação do CoordinateSystems para gerar linhas que se destacam normalmente na superfície:

Como mencionado anteriormente, a parametrização nem sempre é uniforme ao longo do comprimento de uma curva ou superfície, o que significa que o parâmetro 0,5 nem sempre corresponde ao ponto central, e 0,25 nem sempre corresponde ao ponto um quarto ao longo de uma curva ou superfície. Para contornar essa limitação, as curvas têm um conjunto adicional de comandos de parametrização que permite encontrar um ponto em comprimentos específicos ao longo de uma curva.

Você pode ter notado um tema comum nos nomes dos nós no Dynamo: cada nó usa uma sintaxe de “.” sem espaços. Isso ocorre porque o texto na parte superior de cada nó representa a sintaxe real dos scripts, e “.” (ou notação de ponto) separa um elemento dos métodos possíveis que podemos chamar. Isso cria uma conversão fácil de scripts visuais em scripts baseados em texto.

Como uma analogia geral da notação de ponto, como podemos lidar com uma maçã paramétrica no Dynamo? Abaixo estão alguns métodos que iremos executar na maçã antes de decidir comê-la. (Observação: Estes não são métodos reais do Dynamo):

Não sei o que você acha, mas com base nos resultados da tabela acima, parece uma maçã saborosa. Acho que vou nomeá-la Apple.eat().

Notação de ponto no bloco de código

Com a analogia da maçã em mente, vamos examinar Point.ByCoordinates e mostrar como podemos criar um ponto usando o bloco de código.

A sintaxe do bloco de código Point.ByCoordinates(0,10); fornece o mesmo resultado que um nó Point.ByCoordinates no Dynamo, exceto que podemos criar um ponto usando um nó. Isso é mais eficiente do que fazer a conexão com um nó separado em “X” e “Y”.

1. Usando Point.ByCoordinates no bloco de código, estamos especificando as entradas na mesma ordem que o nó pronto para uso (X,Y).

Nós de chamada – Criar, Ações, Consulta

É possível chamar qualquer nó normal na biblioteca através de um bloco de código, desde que o nó não seja um nó da “IU” especial: aqueles com um recurso especial da interface do usuário. Por exemplo, é possível chamar Circle.ByCenterPointRadius, mas não faria muito sentido chamar um nó Watch 3D.

Os nós normais (a maioria da biblioteca) geralmente são de três tipos. Você verá que a biblioteca está organizada tendo em mente essas categorias. Os métodos ou nós desses três tipos são tratados de forma diferente quando executados dentro de um bloco de código.

1. Criar – Cria (ou constrói) algo

2. Ação – Realiza uma ação sobre algo

3. Consulta – Obtém uma propriedade de algo que já existe

Criar

A categoria “Criar” construirá a geometria do zero. Inserimos valores no bloco de código da esquerda para a direita. Essas entradas estão na mesma ordem que as entradas no nó de cima para baixo.

Comparando o nó Line.ByStartPointEndPoint e a sintaxe correspondente no bloco de código, obtemos os mesmos resultados.

Ação

Uma ação é algo que você faz em relação a um objeto desse tipo. O Dynamo usa a notação de ponto, comum a muitas linguagens de codificação, para aplicar uma ação a um item. Uma vez que você tenha o item, digite um ponto e, em seguida, o nome da ação. A entrada do método do tipo de ação é colocada entre parênteses como acontece nos métodos do tipo de criação, com a diferença de não ser necessário especificar a primeira entrada que você vê no nó correspondente. Em vez disso, especificamos o elemento no qual estamos executando a ação:

1. O nó Point.Add é um nó de tipo de ação, de modo que a sintaxe funciona de forma um pouco diferente.

2. As entradas são (1) o ponto e (2) o vetor a ser adicionado. Em um Bloco de código, nomeamos o ponto (o item) “pt”. Para adicionar um vetor chamado *“vec” * a “pt”, podemos escrever pt.Add(vec) ou: item, ponto, ação. A ação Adicionar tem somente uma entrada ou todas as entradas do nó Point.Add, menos a primeira. A primeira entrada do nó Point.Add é o ponto em si.

Consulta

Os métodos de tipo consulta obtêm uma propriedade de um objeto. Como o próprio objeto é a entrada, não é necessário especificar nenhuma entrada. Nenhum parêntese é necessário.

E a amarra?

A amarra com nós é um pouco diferente da amarra com bloco de código. Com nós, o usuário clica com o botão direito do mouse no nó e seleciona a opção de amarra a ser executada. Com o bloco de código, o usuário tem muito mais controle sobre como os dados são estruturados. O método abreviado do bloco de código usa guias de replicação para definir como várias listas unidimensionais devem ser emparelhadas. Os números entre colchetes angulares “<>” definem a hierarquia da lista aninhada resultante: <1>,<2>,<3> etc.

1. Neste exemplo, usaremos uma abreviação para definir dois intervalos (obtenha mais informações sobre abreviação na seção seguinte deste capítulo). Em resumo, 0..1; é equivalente a {0,1} e -3..-7 é equivalente a {-3,-4,-5,-6,-7}. O resultado nos fornece listas de dois valores x e cinco valores y. Se não usarmos guias de replicação com estas listas não coincidentes, obteremos uma lista de dois pontos, que é o comprimento da lista mais curta. Usando guias de replicação, podemos encontrar todas as possíveis combinações de coordenadas 2 e 5 (ou um Produto transversal).

2. Usando a sintaxe Point.ByCoordinates(x_vals<1>,y_vals<2>);, obtemos duas listas com cinco itens em cada lista.

3. Usando a sintaxe Point.ByCoordinates(x_vals<2>,y_vals<1>);, obtemos cinco listas com dois itens em cada lista.

Com essa notação, também podemos especificar qual lista será dominante: 2 listas de 5 itens ou 5 listas de 2 itens. No exemplo, alterar a ordem dos guias de replicação resulta em uma lista de linhas de pontos ou em uma lista de colunas de pontos em um eixo.

Nó para código

Embora os métodos de bloco de código acima possam ter algumas informações úteis, há um recurso no Dynamo chamado “Nó para código” que tornará o processo mais fácil. Para usar esse recurso, selecione uma matriz de nós no gráfico do Dynamo, clique com o botão direito do mouse na tela e selecione “Nó para código”. O Dynamo condensa esses nós em um bloco de código, com todas as entradas e saídas. Não só essa é uma ótima ferramenta para a aprendizagem do bloco de código, como também permite que você trabalhe com um gráfico do Dynamo mais eficiente e paramétrico. Concluiremos o exercício abaixo usando “Nó para código”, por isso, continue acompanhando.

Exercício: Atração de superfície

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.

Para mostrar as capacidades do bloco de código, vamos converter uma definição de campo atrativo existente em formato de bloco de código. O trabalho com uma definição existente demonstra como o bloco de código se relaciona com os scripts visuais e é útil para aprender a sintaxe do DesignScript.

Comece recriando a definição na imagem acima (ou abrindo o arquivo de amostra).

1. Observe que a amarra em Point.ByCoordinates foi definida como Produto transversal.

2. Cada ponto em um eixo é movido para cima na direção Z com base em sua distância até o ponto de referência.

3. Uma superfície é recriada e espessada, criando uma convexidade na geometria relacionada à distância até o ponto de referência.

1. Começando do início, vamos definir primeiro o ponto de referência: Point.ByCoordinates(x,y,0); Usamos a mesma sintaxe Point.ByCoordinates como especificado na parte superior do nó do ponto de referência.

2. As variáveis x e y são inseridas no Bloco de código de forma que possamos atualizá-las dinamicamente com controles deslizantes.

3. Adicione alguns controles deslizantes às entradas de Bloco de código que variam de -50 a 50. Dessa forma, podemos expandir através do eixo padrão do Dynamo.

1. Na segunda linha do Bloco de código, definimos uma abreviação para substituir o nó de sequência numérica: coordsXY = (-50..50..#11);Discutiremos mais sobre isso na próxima seção. Por enquanto, observe que essa abreviação é equivalente ao nó Sequência numérica no script visual.

1. Agora, queremos criar um eixo de pontos com base na sequência coordsXY. Para fazer isso, queremos usar a sintaxe Point.ByCoordinates, mas também precisamos iniciar um Produto transversal da lista da mesma maneira que fizemos no script visual. Para fazer isso, digitamos a linha: gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0); Os colchetes angulares indicam a referência do produto transversal.

2. Observe no nó Watch3D que temos um eixo de pontos no eixo do Dynamo.

1. Agora, a parte difícil: queremos mover o eixo de pontos para cima com base na distância deles até o ponto de referência. Primeiro, vamos chamar esse novo conjunto de pontos transPts. E, como uma conversão é uma ação em um elemento existente, em vez de usar Geometry.Translate..., vamos usar gridPts.Translate

2. Lendo o nó real na tela, vemos que há três entradas. A geometria para converter já está declarada porque estamos executando a ação naquele elemento (com gridPts.Translate). As duas entradas restantes serão inseridas entre os parênteses da função: direção e distância.

3. A direção é muito simples, usamos um Vector.ZAxis() para mover verticalmente.

4. A distância entre o ponto de referência e cada ponto do eixo ainda precisa ser calculada; portanto, fazemos isso como uma ação para o ponto de referência da mesma maneira: refPt.DistanceTo(gridPts)

5. A linha final do código fornece os pontos convertidos: transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));

1. Agora, temos um eixo de pontos com a estrutura de dados apropriada para criar uma superfície Nurbs. Construímos a superfície usando srf = NurbsSurface.ByControlPoints(transPts);

1. E, finalmente, para adicionar alguma profundidade à superfície, construímos um sólido usando solid = srf.Thicken(5); Neste caso, aumentamos a espessura da superfície 5 unidades no código, mas sempre podemos declará-la como uma variável (chamando-a de espessura, por exemplo) e, em seguida, controlamos esse valor com um controle deslizante.

Simplificar o gráfico com “Nó para código”

O recurso “Nó para código” automatiza todo o exercício que acabamos de concluir com o clique de um botão. Isso não só é eficaz para criar definições personalizadas e blocos de código reutilizáveis, também é uma ferramenta realmente útil para saber como criar um script no Dynamo:

1. Inicie com o script visual existente na etapa 1 do exercício. Selecione todos os nós, clique com o botão direito do mouse na tela e selecione “Nó para código”. É tão simples quanto isso.

O Dynamo automatizou uma versão com base em texto do gráfico visual, incluindo a amarra e outros itens. Teste isso em seus scripts visuais e aproveite ao máximo o recurso de bloco de código.

Determinados objetos de geometria podem ser criados explicitamente especificando as coordenadas x, y e z no espaço tridimensional. Mais frequentemente, no entanto, a geometria é movida para sua posição final usando transformações geométricas no próprio objeto ou em seu CoordinateSystem subjacente.

Conversão

A transformação geométrica mais simples é uma conversão, que move um objeto um número especificado de unidades nas direções x, y e z.

Rotação

Embora todos os objetos no Dynamo possam ser convertidos anexando o método .Translate ao final do nome do objeto, as transformações mais complexas exigem a transformação do objeto de um CoordinateSystem subjacente em um novo CoordinateSystem. Por exemplo, para rotacionar um objeto 45° em torno do eixo x, vamos transformar o objeto de seu CoordinateSystem existente sem rotação em um CoordinateSystem que foi rotacionado 45° em torno do eixo x com o método .Transform:

Dimensionar

Além de serem convertidos e rotacionados, também é possível criar os CoordinateSystems com escala ou cisalhamento. Um CoordinateSystem pode ser dimensionado com o método .Scale:

Os CoordinateSystems de cisalhamento são criados inserindo vetores não ortogonais no construtor CoordinateSystem.

A escala e o cisalhamento são, comparativamente, transformações geométricas mais complexas do que a rotação e a conversão, de modo que nem todos os objetos do Dynamo podem sofrer essas transformações. A tabela a seguir descreve quais objetos do Dynamo podem ter CoordinateSystems com escala não uniforme e CoordinateSystems com cisalhamento.

Muitos dos exemplos até agora têm se concentrado na construção de geometria dimensional maior com base em objetos dimensionais menores. Os métodos de interseção permitem que essa geometria dimensional maior gere objetos dimensionais menores, enquanto os comandos Trim e Select Trim permitem que o script modifique fortemente as formas geométricas após a criação.

O método Intersect é definido em todas as partes da geometria no Dynamo, o que significa que, em teoria, qualquer parte da geometria pode fazer interseção com qualquer outra parte da geometria. Naturalmente, algumas interseções são sem sentido, como interseções envolvendo pontos, já que o objeto resultante será sempre o próprio ponto de entrada. As outras combinações possíveis de interseções entre objetos são descritas no gráfico a seguir. A tabela a seguir descreve o resultado de diversas operações de interseção:

Intersecionar

O exemplo a seguir demonstra a interseção de um plano com uma NurbsSurface. A intersecção gera uma matriz NurbsCurve, que pode ser usada como qualquer outra NurbsCurve.

O método Trim é muito similar ao método Intersect, pois é definido para quase todas as partes da geometria. No entanto, há muito mais limitações em Trim do que em Intersect.

Trim

Algo a ser observado sobre os métodos Trim é o requisito de um ponto de “seleção”, um ponto que determina qual geometria será descartada e quais elementos devem ser mantidos. O Dynamo localiza e descarta a geometria recortada mais próxima do ponto selecionado.

Há duas maneiras fundamentais para criar curvas de forma livre no Dynamo: especificar uma coleção de pontos e fazer com que o Dynamo interpole uma curva suave entre eles ou um método de menor nível ao especificar os pontos de controle subjacentes de uma curva de determinado grau. As curvas interpoladas serão úteis quando um designer sabe exatamente a forma que uma linha deve ter ou se o projeto tiver restrições específicas por onde a curva pode e não pode passar. As curvas especificadas por meio de pontos de controle são, em essência, uma série de segmentos de linha reta que um algoritmo suaviza em uma forma de curva final. A especificação de uma curva por meio de pontos de controle pode ser útil para navegações de formas de curva com graus variados de suavização ou quando uma continuidade suave entre segmentos de curva é necessária.

Curva interpolada

Para criar uma curva interpolada, basta passar um conjunto de pontos para o método NurbsCurve.ByPoints.

A curva gerada faz interseção com cada um dos pontos de entrada, começando e terminando no primeiro e último ponto da coleção, respectivamente. É possível usar um parâmetro periódico opcional para criar uma curva periódica que está fechada. O Dynamo automaticamente preencherá o segmento ausente, portanto, um ponto final duplicado (idêntico ao ponto inicial) não é necessário.

Curva de pontos de controle

As NurbsCurves são geradas da mesma forma, com os pontos de entrada que representam os pontos finais de um segmento de linha reta e um segundo parâmetro que especifica a quantidade e o tipo de suavização que a curva sofre, denominado grau.* Uma curva com grau 1 não tem suavização; é uma polilinha.

Uma curva com grau 2 é suavizada de forma que a curva faça interseção e seja tangente ao ponto central dos segmentos de polilinha:

O Dynamo suporta curvas NURBS (B-spline racional não uniforme) até o grau 20, e o seguinte script ilustra o efeito que o aumento dos níveis de suavização tem na forma de uma curva:

Observe que você deve ter pelo menos mais um ponto de controle que o grau da curva.

Outro benefício de construir curvas por vértices de controle é a capacidade de manter a tangência entre segmentos de curva individuais. Isso é feito extraindo a direção entre os últimos dois pontos de controle e continuando esta direção com os dois primeiros pontos de controle da curva a seguir. O exemplo a seguir cria duas curvas NURBS separadas que, mesmo assim, são tão suaves como uma curva:

Os objetos em projetos de cálculo raramente são criados explicitamente em sua posição e forma finais e são, na maioria das vezes, convertidos, rotacionados e posicionados de outra forma, com base na geometria existente. A matemática de vetores serve como um tipo de andaime geométrico para dar direção e orientação à geometria, bem como para conceituar movimentos através do espaço 3D sem representação visual.

Em seu nível mais básico, um vetor representa uma posição no espaço 3D e, muitas vezes, é considerado como o ponto final de uma seta da posição (0, 0, 0) para essa posição. É possível criar vetores com o construtor ByCoordinates, usando as posições x, y e z do objeto Vector recém-criado. Observe que os objetos Vector não são objetos geométricos e não aparecem na janela do Dynamo. No entanto, as informações sobre um vetor recém-criado ou modificado podem ser impressas na janela do console:

Um conjunto de operações matemáticas é definido em objetos Vector, permitindo adicionar, subtrair, multiplicar e mover objetos no espaço 3D, como você moveria os números reais no espaço 1D em uma linha de números.

Adição de vetor

A adição de vetores é definida como a soma dos componentes de dois vetores e poderá ser considerada como o vetor resultante se as duas setas de vetor dos componentes forem inseridas “ponta a ponta”. A adição de vetores é realizada com o método Add e é representada pelo diagrama à esquerda.

Subtração de vetores

De forma similar, dois objetos Vector podem ser subtraídos um do outro com o método Subtract. A subtração de vetores pode ser considerada como a direção do primeiro vetor para o segundo vetor.

Multiplicação de vetores

A multiplicação de vetores pode ser considerada como o ato de mover a extremidade de um vetor em sua própria direção com base em um determinado fator de escala.

Normalizar comprimento do vetor

Muitas vezes, ao dimensionar um vetor, é desejável que o comprimento resultante seja exatamente igual à quantidade dimensionada. Isso é facilmente conseguido pela normalização de um vetor, ou seja, definindo o comprimento do vetor como exatamente igual a um.

c ainda aponta na mesma direção que a (1, 2, 3), embora agora apresente comprimento exatamente igual a 5.

Produto transversal

Existem dois métodos adicionais na matemática de vetores que não têm paralelos claros com a matemática 1D, o produto vetorial e o produto escalar. O produto vetorial é um meio de gerar um vetor ortogonal (a 90 graus) a dois vetores existentes. Por exemplo, o produto vetorial dos eixos x e y é o eixo z, embora os dois vetores de entrada não precisem ser ortogonais entre si. Um vetor de produto vetorial é calculado com o método Cross.

Produto escalar

Uma função adicional, embora um pouco mais avançada da matemática vetorial, é o produto escalar. O produto escalar entre dois vetores é um número real (não um objeto Vector) que se relaciona, mas não é exatamente, o ângulo entre dois vetores. Uma propriedade útil do produto escalar é que o produto escalar entre dois vetores será 0 somente se eles forem perpendiculares. O produto escalar é calculado com o método Dot.

Ponto

O objeto geométrico mais simples da biblioteca de geometria padrão do Dynamo é um ponto. Toda a geometria é criada usando funções especiais chamadas construtores, cada uma delas retorna uma nova instância desse tipo de geometria específico. No Dynamo, os construtores começam com o nome do tipo do objeto, neste caso, Ponto, seguido pelo método de construção. Para criar um ponto tridimensional especificado pelas coordenadas cartesianas x, y e z, use o construtor ByCoordinates:

Os construtores no Dynamo normalmente são designados com o prefixo “By” e a chamada dessas funções retorna um objeto recém-criado desse tipo. Esse objeto recém-criado é armazenado na variável nomeada no lado esquerdo do sinal de igual.

A maioria dos objetos tem muitos construtores diferentes, e podemos usar o construtor BySphericalCoordinates para criar um ponto sobre uma esfera, especificado pelo raio da esfera, um primeiro ângulo de rotação e um segundo ângulo de rotação (especificado em graus):

De ponto para linha

É possível usar os pontos para construir uma geometria dimensional maior, como linhas. Podemos usar o construtor ByStartPointEndPoint para criar um objeto de linha entre dois pontos:

De linha para superfície

De forma semelhante, é possível usar as linhas para criar uma geometria de superfície dimensional maior; por exemplo, usando o construtor Loft, que assume uma série de linhas ou curvas e interpola uma superfície entre elas.

De superfície para sólido

Também é possível usar as superfícies para criar uma geometria sólida dimensional maior, por exemplo, espessando a superfície por uma distância especificada. Muitos objetos possuem funções associadas a eles, chamados métodos, permitindo que o programador execute comandos nesse objeto em particular. Os métodos comuns a todas as porções de geometria incluem Translate e Rotate, que, respectivamente, convertem (movem) e rotacionam a geometria por um valor especificado. As superfícies apresentam um método Thicken, que recebe uma única entrada, um número que especifica a nova espessura da superfície.

Intersecionar

Os comandos Intersection podem extrair geometria dimensional menor de objetos dimensionais maiores. Essa geometria dimensional menor extraída pode formar a base para uma geometria dimensional maior, em um processo cíclico de criação, extração e recriação geométrica. Neste exemplo, usamos o sólido gerado para criar uma superfície e usamos a superfície para criar uma curva.

Nesta seção, você encontrará uma série de aulas sobre a criação de geometria com o DesignScript. Acompanhe copiando o DesignScript de exemplo para os blocos de código do Dynamo.

// copy this code into a Code Block
// to start writing DesignScript

x = "Let's create some geometry!";

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.

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 Programação visual 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:

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

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

A biblioteca Autodesk.DesignScript.Geometry permite usar a notação de pontos similar aos blocos de código. Para obter mais informações sobre a sintaxe do Dynamo, consulte https://github.com/DynamoDS/DynamoPrimerNew/blob/master-ptb/coding-in-dynamo/7_code-blocks-and-design-script/7-2_design-script-syntax.md, bem como o Guia do DesignScript (Para fazer o download desse documento PDF, clique com o botão direito do mouse no link e escolha “Salvar link como...”). Digitar um tipo de geometria como “Point.” exibirá uma lista de métodos para criar e consultar pontos.

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.

# 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

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.

# 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

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.

# 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

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.

Os seguintes scripts Python geram matrizes de pontos para diversos exemplos. Elas devem ser coladas em um nó de script do Python da seguinte forma:

python_points_1

out_points = []

for i in range(11):
	sub_points = []
	for j in range(11):
		z = 0
		if (i == 5 and j == 5):
			z = 1
		elif (i == 8 and j == 2):
			z = 1
		sub_points.append(Point.ByCoordinates(i, j, z))
	out_points.append(sub_points)

OUT = out_points

python_points_2

out_points = []

for i in range(11):
	z = 0
	if (i == 2):
		z = 1
	out_points.append(Point.ByCoordinates(i, 0, z))

OUT = out_points