Apostila BIM & Projeto Computacional No Dynamo

Soluções em TI para Engenharia
& Arquitetura
Implantação da Metodologia BIM
www.dharmasistemas.wix.com/home
Capacitação Profissional
BIM & Projeto Computacional no Dynamo
Autodesk Revit® & Dynamo & Microsoft Excel®
Última revisão: 08/04/2019

Sobre o autor
Ari Monteiro é proprietário da Dharma Sistemas, Cientista da Computação e Mestre
em Engenharia Civil e Urbana pela Escola Politécnica da USP. Profissional com
grande experiência na implantação e customização de ferramentas CAD/BIM. É
pesquisador e consultor BIM desde 2008. Membro da comissão de estudo
ABNT/CEE-134 para elaboração da norma BIM nacional desde 2015. Docente
convidado em programas de pós-graduação relacionados ao tema BIM desde 2014.
Atualmente, presta serviços de consultoria em BIM e em outras tecnologias
relacionadas para várias empresas de Engenharia, Arquitetura e Construção.
Copyright © 2019 de Ari Monteiro

Todos os direitos reservados. Este material ou qualquer parte dele não pode ser reproduzido ou usado de
forma alguma sem autorização expressa, por escrito, do autor ou editor, exceto pelo uso de citações
breves em uma resenha deste material.
1º ed., 2019
Contatos: www.dharmasistemas.wix.com/home
Copyright © 2019 Prof. Ari Monteiro 2/56

SUMÁRIO
AULA 1 .............................................................................................................................. 5
Introdução às Ferramentas VPL ................................................................................... 5
A ferramenta Dynamo ................................................................................................. 8
Interface com o usuário........................................................................................................................ 8

A anatomia de um grafo ..................................................................................................................... 10
Organização e gerenciamento de dados em um programa ............................................................... 13
AULA 02 .......................................................................................................................... 15
Elementos Básicos da Programação Visual ............................................................... 15
Tipos de dados .................................................................................................................................... 15

Dados nulos ........................................................................................................................................ 16
Listas ................................................................................................................................................... 17
Funções matemáticas ................................................................................................ 17
Funções lógicas .......................................................................................................... 19
Funções para manipulação de strings ....................................................................... 20
AULA 03 .......................................................................................................................... 22
Manipulação de Listas ............................................................................................... 22
Criando listas ...................................................................................................................................... 22

Acessando elementos de uma lista .................................................................................................... 25
Contando os elementos da lista ......................................................................................................... 26
Alterando a estrutura de níveis de uma lista aninhada...................................................................... 27
Mapeando funções em listas .............................................................................................................. 28
Combinando dados em listas ............................................................................................................. 29
Adicionando e removendo dados numa lista ..................................................................................... 32
Substituindo elementos numa lista .................................................................................................... 34
Ordenando dados numa lista ............................................................................................................. 34
AULA 04 .......................................................................................................................... 37
Modelagem Geométrica ............................................................................................ 37
Estrutura hierárquica dos tipos de dados na geometria ........................................... 37
Funções para manipulação de pontos ....................................................................... 39
Funções para manipulação de curvas........................................................................ 40
Funções para manipulação de sólidos ....................................................................... 40

AULA 05 .......................................................................................................................... 41
Modelagem BIM com o Dynamo ............................................................................... 41
Selecionando elementos do modelo BIM .......................................................................................... 41

Lendo valores de parâmetros nos elementos do modelo BIM .......................................................... 43
Editando valores de parâmetros nos elementos do modelo BIM ...................................................... 44
Inserindo elementos no modelo BIM ................................................................................................. 44
AULA 06 .......................................................................................................................... 46
Interoperabilidade ..................................................................................................... 46
Importação de dados do Excel para o Revit ....................................................................................... 46

Exportação de dados do Revit para o Excel ........................................................................................ 47
AULA 07 .......................................................................................................................... 48
Programação Textual vs Programação Visual............................................................ 48
Quando usar programação textual..................................................................................................... 48

Introdução a linguagem DesignScript ................................................................................................. 48
Definição de uma função em DesignScript ......................................................................................... 48
Introdução a linguagem Python ......................................................................................................... 48
Exemplo de código Python no Dynamo.............................................................................................. 49
AULA 08 .......................................................................................................................... 51
Customização de nós ................................................................................................. 51
Criação de um nó personalizando ...................................................................................................... 51

Utilização de um nó personalizado .................................................................................................... 53
Considerações finais .................................................................................................. 55
Referências ..................................................................................................................... 56

AULA 1
Introdução às Ferramentas VPL
As VPLs (Visual Programming Languages) ou Linguagens de Programação Visual foram desenvolvidas nos
anos 70 e surgiram da união de trabalhos nos campos da computação gráfica, das linguagens de
programação e da interação humano-computador (BOSHERNITSAN; DOWNES, 2004).
A ideia principal por trás desse tipo de linguagem é facilitar a sua utilização e aprendizado, por meio do
uso de artefatos gráficos em oposição, ao uso de uma linguagem de programação textual (CRAFAI, 2015).
Em linguagens de programação textuais os usuários precisam aprender a sintaxe das estruturas da
linguagem para que possam codificar programas.
Nas ferramentas baseadas em VPL, a lógica dos programas é construída usando diagramas chamados
grafos que são compostos de elementos chamados nós.
Figura 1 – Cálculo da média de dois números usando uma VPL (Dynamo).
Figura 2 – Cálculo da média de fois números usando uma linguagem de programação textual (C++).
Os nós contêm encapsuladas as estruturas utilizadas pela linguagem de programação visual. Na medida
em que o usuário cria o grafo de um programa, indiretamente, está produzindo códigos de programação
que ficam ocultos dentro dos nós do grafo.
Quando esse grafo é executado a lógica de programação incorporada nos nós é processada gerando
geometrias novas ou manipulando geometrias existentes (Figura 3, p.6).

Figura 3 – O Dynamo criando geometrias a partir da lógica incorporada em um grafo.
As ferramentas VPL têm sido utilizadas no contexto do BIM há alguns anos, em particular em estudos de
formas arquitetônicas complexas (STAVRIC; MARINA, 2011) e no suporte a fabricação digital (LACHAUER
et al., 2010).
Exemplos de ferramentas VPL integradas com suas respectivas ferramentas BIM são:
• Grasshopper (Graphisoft ArchiCAD);
• Dynamo (Autodesk Revit);
• Generative Components (Bentley AECOsim);
• Marionette (Nemetscheck Vectorworks).
Figura 4 – Aplicação do Dynamo para análise de rota de fuga em um projeto de segurança predial.
Figura 5 – Aplicação do Dynamo em análise de insolação.

As ferramentas VPL permitem não apenas a modelagem geométrica, mas também, a modelagem BIM.
Enquanto a modelagem geométrica foca na forma dos objetos, a modelagem BIM foca na funcionalidade
desses objetos dentro de um contexto projetual.
Por exemplo, na modelagem geométrica uma parede tem sua descrição restrita apenas a sua geometria.
Uma parede é apenas um prisma retangular com suas dimensões de espessura, comprimento e altura, os
quais podem ainda, serem estáticas ou dinâmicas (modelagem paramétrica).
Na modelagem BIM a mesma parede ganha mais características relacionadas ao seu contexto projetual,
isto é, não é apenas um prisma retangular com dimensões variáveis.
Agora esse objeto pode representar virtualmente uma parede e, por consequência, deve apresentar
comportamentos de uma parede real.
Uma parede, num modelo BIM, deve saber interagir com outros objetos (paredes, portas, janelas, etc.).
Além disso, deve conter diversos tipos de dados técnicos (propriedades), tais como: materiais que a
compõe, pavimentos os quais ela está relacionada, área de sua superfície, sua identificação, sua
localização, etc.
O uso combinado de ferramentas VPL e de autoria de modelos BIM é uma técnica interessante a ser
explorada.
O uso de ferramentas VPL para explorar novas formas geométricas é interessante, mas o uso dessas
ferramentas na elaboração e manipulação de modelos BIM é onde o poder delas se mostra muito maior.
Um exemplo claro disso se vê na elaboração de modelos BIM com LoD 400 (BIMFORUM, 2016) e na
execução de tarefas repetitivas durante este processo (Figura 6).
Figura 6 – Exemplos de projetos onde modelos BIM LoD 400 podem ser usados.
A modelagem BIM com o suporte de ferramentas VPL para a automação de modelagem é crucial para
obter produtividade.
Os modelos BIM de projetos para produção são exemplos de onde as ferramentas VPL podem ajudar na
automação da modelagem:
• Formas e escoramentos;
• Drywall;
• Madeiramento de telhado;
• Detalhamento de armações;
• Detalhamento de estruturas metálicas.

A ferramenta Dynamo
O Dynamo é uma ferramenta VPL que trabalha de forma integrada com o Autodesk Revit;
Com ela é possível automatizar diversos tipos de tarefas, tais como:
• Preenchimento de carimbos nas pranchas do projeto;
• Inserção automática de famílias seguindo uma regra específica para sua distribuição;
• Gerar pranchas com determinadas vistas já inseridas;
• Importação/exportação de modelos 3D, etc.
Figura 7 – Exemplo de grafo no Dynamo para preencher carimbos nas prachas de um projeto.
Ao instalar o Autodesk Revit o Dynamo também é instalado de duas formas:

• Dynamo Revit Add-in: o Dynamo é instalado como um suplemento (add-in) do Autodesk Revit.
Deste modo, o Dynamo pode ser usado integrado ao Revit. Ele pode ser ativado a partir da aba
“Gerenciar”, aba “Programação visual”, botão “Dynamo” (Figura 8). O botão “Reprodutor do
Dynamo” ou “Dynamo Browser” é uma janela que permite a execução de programas
desenvolvidos com o Dynamo sem a necessidade de abrir a janela do aplicativo.
Figura 8 – Acesso ao Dynamo a partir da faixa de opções do Revit.
• Dynamo Sandbox: é a versão standalone do Dynamo, isto é, um aplicativo independente que

pode ser usado fora do Autodesk Revit. Neste aplicativo é possível usar o Dynamo apenas para
modelagem geométrica.
Interface com o usuário

A janela do Dynamo é a mesma abrindo o aplicativo a partir do Revit ou a partir do Sandbox, com exceção
que este último não tem recursos para interagir com o modelo BIM. Os elementos da interface com o
usuário no Dynamo são descritos abaixo e apresentados na Figura 9 (p. 9).
• Menu suspenso: menu que organiza os comandos em categorias;
• Barra de ferramenta: barra com atalhos para os principais comandos de gerenciamento de
arquivos (Novo, Abrir, Salvar, Desfazer e Refazer);

• Espaço de trabalho: área da tela onde é possível interagir com o grafo e pré-visualizar os
resultados da sua execução;
Figura 9 – Elementos da interface com o usuário no Dynamo.
• Botão para exportar o grafo para um arquivo de imagem: use esse botão para exportar o
conteúdo do “espaço de trabalho” para um arquivo de imagem no formato PNG;
Nota: antes de exportar o grafo muito grande, deixe-o pré-selecionado para garantir uma boa resolução
da imagem.
• Biblioteca: painel que organiza as funções de programação visual em categorias.

• Botão para adicionar ou pesquisar pacotes: use esse botão para incrementar a biblioteca de
funções do Dynamo utilizando novos pacotes. Os pacotes são bibliotecas de funções
personalizadas que podem ser criadas por você ou por outros desenvolvedores;
• Barra de execução: use esse botão para controlar a execução do grafo. Pode ser ajustado para
execução manual ou automática;
Nota: quando o grafo envolve o processamento de muitas geometrias ou operações no modelo BIM é
recomendado deixar sempre no modo de execução “manual” para não degradar muito o desempenho do
Dynamo e causar travamentos.
• Ativa a navegação na visualização 3D: use esse botão para alternar para a visualização 3D e
ajustar a câmera da pré-visualização de resultados. Quando esse botão é acionado o grafo fica
em segundo plano;
• Ativa a navegação na vista gráfica: use esse botão para alternar para modo de visualização do
grafo. Quando esse botão é acionado a visualização 3D fica em segundo plano;
• Botões de Zoom, Pan e Órbita: use esses botões para ajustar o ponto de vista na visualização 3D
ou no modo de visualização do grafo.
Nota: A função “Orbit” são está disponível quando o modo de visualização 3D está ativo (Figura 10, p.10).

Figura 10 – Função “Órbita” na barra de navegação.
A anatomia de um grafo
Um grafo (graph) é um diagrama composto de nós (nodes) e fios (wires) utilizado para representar a lógica
de um programa.
Os nós (nodes) são os elementos que contém os dados manipulados por um programa e são compostos
das seguintes partes (Figura 11):
Figura 11 – Anatomia de um nó.
• Nome: nome do nó seguindo a convenção de nomeação “Categoria.Nome”;

• Principal: corpo principal do nó. Ao clicar com o botão direito um menu contexto será exibido
com opções relacionadas ao uso do nó (Figura 12);
Figura 12 – Menu contexto ativado ao clicar botão direito sobre o corpo de um nó.
• Portas (Entrada/Saída): pontos para ligação dos fios (wires) que suprem ou transportam os
dados entre os nós;
• Pré-visualização de dados: passe o cursor ou clique para uma pré-visualização do processamento
de dados do nó;

• Ícone de amarra: indica a opção de amarra (lacing) utilizada para combinar listas de dados
fornecidas ao nó.
Nota: no menu contexto utilize a opção “Ajuda...” para consultar uma breve descrição do nó selecionado
na documentação do Dynamo (Figura 13). Utilizar a documentação do Dynamo é uma excelente forma de
aprender mais a fundo cada nó da biblioteca padrão.
Figura 13 – Exemplo de documentação de um nó exibida quando a opção “Ajuda...” é acionada.
Os nós podem apresentar diferentes estados durante o desenvolvimento de um programa (Figura 14):
• Inativo: um nó cinza escuro indica que ele está inativo e que precisa ser ligado com um fio ao
fluxo de programação;
• Ativo: um nó cinza claro indica que ele está perfeitamente ligado ao fluxo de programação;
• Selecionado: um nó com a borda azul indica que ele está selecionado;
• Alertando: um nó amarelo indica que algum erro ocorreu no processamento do nó. Deve-se
checar as portas de entrada de dados do nó.
Figura 14 – Aparências de um nó durante o desenvolvimento de um programa.

Os fios (wires) são os elementos que ligam os nós e definem o fluxo da programação. Eles são os
responsáveis por transportar os dados entre os nós. O fluxo de dados padrão de um grafo é da esquerda
para a direita (Figura 15). Para ligar dois nós com um fio o procedimento é:
1. Clique numa porta à direita do nó (saída);
2. Desloque o cursor para direita e pare sobre a porta à esquerda do outro nó (entrada);
3. Clique na porta deste nó para ligar o fio.
Figura 15 – Ligação de dois nós com um fio.
A biblioteca (library) armazena os nós utilizados para criar os grafos. Esses nós são organizados na
biblioteca em categorias (Figura 16).
Figura 16 – Categorias de nós na biblioteca.
Os nós com o ícone “+” antes do nome do nó representam operações de criação (create) de objetos ou
geometrias.
Os nós com o ícone “raio” antes do nome do nó representação operações de modificação (action) de
objetos ou geometrias existentes.
Os nós com o ícone “?” antes do nome do nó representam operações de consulta (query) de dados em
objetos ou geometrias existentes.

Organização e gerenciamento de dados em um programa

A organização de programas pode ser feita usando os recursos:
• Alinhar seleção: permite alinhar os nós do grafo em uma determinada orientação (Figura 17);
Figura 17 – Alinhamento de nós com o comando “Alinhar seleção”.
• Criar nota: permite adicionar notas explicativas no grafo (Figura 18);
Figura 18 – Adição de uma nota no grafo com o comando “Criar nota”.
• Criar grupo: permite agrupar nós em caixas coloridas contendo descrições breves sobre o grupo
(Figura 19).
Figura 19 – Agrupamento de elementos com o comando “Criar grupo”.

Nota: a Figura 20 apresenta uma sugestão de cores para os grupos de acordo com a atividade
desempenhada pelos nós que compõem um grupo. O uso de um padrão de cores nos agrupamentos de
um grafo é uma boa prática para deixar o seu programa mais legível!
Figura 20 – Sugestão para a padronização de cores de grupos nos em grafos.
Abaixo uma breve descrição sobre cada padrão de cor sugerido:

• Azul: seleções do usuário, entradas de dados e créditos;
• Verde: descoberta ou recuperação de informações numa geometria ou modelo BIM;
• Cinza: processamento dados coletados pelos nós agrupados com a cor verde;
• Rosa: criação de elementos no Dynamo (ex.: geometrias como pontos, superfícies, sólidos ou
malhas);
• Púrpura: criação de elemento no Revit (ex.: inserção de famílias no projeto);
• Laranja: exportação de dados do Dynamo para o MS Excel, arquivos de texto, arquivos SAT ou
gravação de uma geometria gerada no Dynamo com uma família local no Revit.

AULA 02
Elementos Básicos da Programação Visual
Para desenvolver programas é necessário conhecer os elementos essenciais de uma linguagem
computacional.
Esses elementos são os blocos fundamentais para construir a lógica de um programa, tais como: tipos de
dados, variáveis, estruturas de fluxo, estruturas de repetição, etc.
Nessa aula serão abordados quais são os elementos básicos da programação visual no Dynamo.
Tipos de dados
No Dynamo os dados são qualquer coisa que os nós de um grafo recebem ou retornam. Os tipos de dados
básicos são:
• Número (number): usado para representar números reais (números com parte decimal) ou
inteiros;
• Cadeia de caracteres (string): usado para representar texto;
• Objeto (object): usado para representar uma geometria (ponto, face, etc.);
• Função (function): usado para representar um nó que executa uma ação. Por exemplo: um nó
que cria um ponto (Point.ByCoordinates) se não recebe dados de entrada, o dado retornado é
do tipo Function.
Figura 21 – Exemplos de alguns dos tipos de dados existentes no Dynamo.

Na biblioteca de nós a categoria “Core/Input” (Figura 22) contém todos os tipos de entrada de dados que
podem ser usados em um programa:
Figura 22 – Categoria “Core/Input” na biblioteca de nós.
• Booleano (boolean): booleano (verdadeiro ou falso);

• Bloco de código (code block): bloco de código DesignScript;
• Data e hora (date time): data e/ou horário;
• Caminho de pasta (directory path): caminho de uma pasta;
• Caminho de arquivo (file path): caminho de um arquivo;
• Seletor de inteiros (integer slider): seletor de números inteiros;
• Seletor de números reais (number slider): seletor de números reais;
• Número real (number): número real;
• Cadeia de caracteres (string): dado texto.
Dados nulos
Os dados nulos ou dados inválidos são outra possibilidade de tipo de dado que pode existir em um
programa e é necessário tomar cuidado com esse tipo de dado.
Quando um nó recebe dados inválidos ele retorna um tipo chamado Null, que é usado para representar
a ausência de um dado válido;
Existe um nó específico na biblioteca para testar se um dado é nulo (Figura 23, p. 17). O nó isNull,
disponível na categoria “Core/Object”, retorna um dado do tipo booleano que é ideal para uso em
controle de fluxo juntamente com o nó If localizado na categoria “Core/Logic”.

Figura 23 - Exemplo de utilização do nó “Object.isNull” para checar se o valor de uma entrada é nulo.
Nota: o tratamento de dados nulos é essencial para criar programas robustos.
Listas
Nas linguagens de programação os dados podem ser organizados em conjuntos que são chamados de
estruturas de dados.
A estrutura de dados essencial do Dynamo é a lista. Existem diversos nós dentro da biblioteca padrão para
manipular listas.
As listas podem conter dados do mesmo tipo (listas homogêneas) ou de tipos diferentes (listas
heterogêneas). Além disso, as listas podem conter outras listas (listas aninhadas).
Exemplo de listas são: pontos, faces, instâncias de uma família, pranchas, vistas, etc.
As listas podem ser criadas a partir de sequências de dados pelos nós “Number Sequence”, “List Create”
ou “Code Block” (Figura 24).
Figura 24 – Formas de criação de listas.
Funções matemáticas
No Dynamo é possível trabalhar com simples operações aritméticas ou complexas fórmulas matemáticas.
Na categoria “Operators” da biblioteca estão os nós relacionados aos operadores aritméticos e lógicos e
na categoria “Core/Math” estão os nós relacionados a funções matemáticas avançadas.

Na categoria “Core/Formula” da biblioteca está o nó “Evaluate” e na categoria “Core/Scripting” está o nó

“Formula”, ambos podem ser usados para a avaliação de fórmulas matemáticas complexas (Figura 25).
Figura 25 – Categorias da biblioteca relacionadas com operações matemáticas.
Dos nós utilizados para representar fórmulas matemáticas, o nó “Formula” localizado na categoria
“Core/Scripting” oferece uma forma mais compacta de trabalhar (Figura 26) que o nó “Evaluate”, pois é
necessário informar apenas os valores para os argumentos da fórmula.
Figura 26 – Exemplos de utilização dos nós “Evaluate” e “Formula”.

Funções lógicas
A lógica condicional se refere ao controle de fluxo de programação utilizando testes lógicos que retornam
dados booleanos (true ou false).
No Dynamo essa lógica pode ser realizada usando a função “If” em conjunto com operadores lógicos e
operadores de comparação.
Os operadores lógicos e de comparação são encontrados na categoria “Operators” da biblioteca.
A função “If” é encontrada na categoria “Core/Logic” e os nós “Core/Formula” e “Core/Input/Code Block”
também podem ser usados para avaliar a função “If” (Figura 27).
Figura 27 – Exemplos de utilização da estrutura “If”.
O operador “==” pode ser utilizado como entrada do nó “If” pois ele retorna um dado do tipo booleano
(true ou false). A Figura 28 mostra um exemplo de aplicação desse operador para verificar se o resto da
divisão de um número por 2 é igual a zero.
Figura 28 – Exemplo de uso conjunto do operador “==” com o nó “If”.

No lugar do nó “If” é possível usar o nó “FilterByBoolMask” localizado na categoria “Core/List” da

biblioteca.
Esse nó recebe duas listas como entrada onde a primeira lista corresponde aos elementos que serão
mapeados com os elementos da segunda lista. Já a segunda lista corresponde ao resultado da aplicação
de uma expressão lógica nos elementos da primeira lista.
A estrutura de fluxo “If” já está incorporada em “FilterByBoolMask” e ele retorna duas listas com os
resultados que correspondem aos elementos para os quais esse “If” retornou “true” e “false” (Figura 29).
Figura 29 – Exemplo de uso do nó “FilterByBoolMask” no lugar do nó “If”.
Funções para manipulação de strings

Na biblioteca padrão do Dynamo existem diversos nó para trabalhar com dados texto ou strings. Abaixo
uma lista dos principais nós da categoria “Core/String”:
• Core/String/Concat: concatena, isto é, une um conjunto de strings para formar uma única string
(Figura 30).
Figura 30 – Exemplo de utilização do nó “Core/String/Concat”.
• Core/String/Contains: verifica se uma string está contida em outra string e retornar um valor
booleano (true ou false). O nó retorna true se a string procurada existir e, caso o contrário,
retorna false. Para ignorar caracteres maiúsculos ou minúsculos na busca, informe true para a
entrada “ignoreCase” (Figura 31).
Figura 31 – Exemplo de utilização do nó “Core/String/Contains”.

• Core/String/Split: fatia uma string utilizando um delimitador de campo (ex.: hífen, espaço, ponto
e vírgula, etc.). O retorno desse nó é uma lista contendo as partes da string fatiada (Figura 32).
Figura 32 – Exemplo de utilização do nó “Core/String/Split”.
• Core/String/Substring: retorna uma parte da string informando a posição inicial indexada a

partir de 0 e a quantidade de caracteres (Figura 33).
Figura 33 – Exemplo de utilização do nó “Core/String/Substring”.

AULA 03
Manipulação de Listas
As listas são o meio utilizado pelo Dynamo para organizar os dados e representam uma coleção de itens
de um determinado tipo (lista homogênea) ou de tipos diferentes (lista heterogênea), mas que possuem
ligação com um determinado contexto.
Uma lista contendo os tipos de todas as famílias de porta carregadas no projeto é um exemplo de lista
homogênea.
Uma lista contendo os dados código (number), descrição do item (string) e quantidade (integer), referente
a uma lista de materiais é um exemplo de lista heterogênea.
Existem diversos nós na categoria “Core/List” para manipular listas e nessa sessão são apresentadas as
principais operações que envolvem a manipulação dessas estruturas (Figura 34).
Figura 34 – Alguns dos nós da biblioteca utilizados para a manipulação de listas.
Criando listas
Para criar uma lista de números utilize o nó “Core/List/Create” ou o nó “Code Block” usando a sintaxe
“i..#e..p” onde “i” representa o número inicial da sequência, “#e” é número de elementos da sequência e
“p” é o passo (incremento ou decremento) nos números da sequência (Figura 35, p.23).

Figura 35 – Exemplo de aplicação da técnica de sequências para criar listas de números.
As sequências também permitem criar listas contendo valores texto. A Figura 36 mostra como criar uma
lista contínua de letras de “a” até “m” e a mesma lista pulando uma letra usando o parâmetro passo “#2”.
Figura 36 - Exemplo de aplicação da técnica de sequências para criar listas de letras.
Listas de pontos podem ser criadas usando a combinação de listas de números com o nó
“Geometry/Point/ByCoordinates” (Figura 37, p.24).

Figura 37 - Exemplo de aplicação da técnica de sequências para criar listas de pontos.
Nota: a forma mais rápida de criar lista de números no Dynamo é usando a sintaxe de sequência “i..#e..p”
apresentada anteriormente.
Quando é necessário armazenar dois ou mais conjuntos de dados numa única lista, teremos uma situação
de lista aninhada.
A Figura 38 mostra um exemplo de criação de lista aninhada usado o nó “Core/List/Create” e a técnica de
sequência. Nos dois casos o resultado é exatamente o mesmo.
Figura 38 – Exemplos de criação de listas aninhadas usando o nó “Core/List/Create” e sequências.

Acessando elementos de uma lista

Cada elemento de uma lista recebe um código que é usado para acessá-lo e obter o dado que ele
armazena. Esse código é um número inteiro sequencial iniciando por zero e ele se chama índice. Para
acessar o primeiro elemento o índice é “0” e para acessar o terceiro elemento o índice é “2” (Figura 39).
Figura 39 – Indexação de itens dentro de uma lista.
Para acessar um elemento da lista utilize o nó “Core/List/GetItemAtIndex” ou pelo nó “Code Block”

usando a sintaxe NomeLista[n], onde “NomeLista” é um nome a sua escolha para a lista e “n” é o índice
do elemento que se deseja acessar na lista (Figura 40).
Figura 40 – Utilização de índices para acessar elementos numa lista.
Em listas aninhadas o acesso a itens dentro dos níveis da lista pode ser feito com o auxílio do recurso
“list@level” (list at level).
A Figura 41 mostra a diferença na utilização do nó “Core/List/GetItemAtIndex” para acessar o elemento
de índice = 1 de uma lista aninhada.
Figura 41 – Exemplo de utilização do recurso “list@level” para acessar o nível 2 de uma lista aninhada.

No primeiro caso, o nó “Core/List/GetItemAtIndex” não está usando o recurso “list@level”, o que resulta
no retorno da segunda sublista da lista aninhada.
No segundo caso, o nó “Core/List/GetItemAtIndex” está usando o recurso “list@level” apenas na entrada
“list” o que resulta no acesso aos elementos de índice = 1 das sublistas localizadas no nível 2 da lista
aninhada.
Por fim, no terceiro caso, o recurso “list@level” é utilizado nas entradas “list” e “index” do nó
“Core/List/GetItemAtIndex” o que resulta apenas no elemento de índice = 1 da primeira sublista.
Mas, se fosse necessário acessar o elemento de índice = 1 da segunda sublista? Neste caso, informar os
índices que deseja acessar entre colchetes em um “Code Block” é mais simples e direto como mostra na
Figura 42.
Figura 42 – Acesso aos elementos de uma lista aninhada usando o nó “Code Block”.
Nota: o recurso “list@level” pode ser usado diversos tipos de nós de manipulação de listas. Use-o quando
precisar aplicar uma função em elementos de uma lista aninhada.
Contando os elementos da lista

O nó “Core/List/Count” permite contar quantos elementos existem numa lista. A Figura 43 mostra como
esse nó pode ser usado.
Figura 43 – Exemplo de utilização do nó “Core/List/Count”.

Alterando a estrutura de níveis de uma lista aninhada

O nó “Flatten” permite eliminar níveis dentro listas aninhadas e ele possui duas variantes na biblioteca. A
primeira variante está localizada em “BuiltIn/Flatten” e elimina qualquer quantidade de níveis numa lista
aninhada. A segunda variante está localizada em “Core/List/Flatten” permite definir qual nível da lista
aninhada será eliminado (Figura 44).
Figura 44 – Exemplo de utilização das variantes do nó “Flatten”.
Nota: observe que no nó “Core/List/Flatten” é possível indicar a quantidade de níveis que se deseja
eliminar na lista aninhada.
Na sessão anterior vimos como eliminar níveis numa lista aninhada, mas pode ser necessário fazer o
contrário que é agrupar os elementos de uma lista em sublistas. O nó “Core/List/Chop” permite fazer esse
agrupamento.
Esse nó tem duas entradas sendo a primeira a lista a ser processada e a segunda a quantidade de
elementos desejados para cada sublista (Figura 45).
Figura 45 – Exemplo de utilização do nó “Core/List/Chop”.

Nota: se a quantidade no segundo parâmetro não for módulo da quantidade total de elementos da lista
original, a última sublista poderá conter menos elementos.
Mapeando funções em listas

Quando é necessário aplicar uma função em todos os elementos de uma lista o nó “Core/List/Map” pode
ser usado. A Figura 46 mostra o efeito da função “Core/List/Count” aplicada numa lista de 3 níveis com e
sem o uso do nó “Core/List/Map”.
Figura 46 – Exemplo de utilização do nó “Core/List/Map”.
O nó “Core/List/Map” permite acessar somente um nível abaixo do maior nível (ex.: o nível 2 de uma lista
de 3 níveis). O recurso “list@level” pode ser usado para acessar qualquer nível de uma lista aninhada. A
Figura 47 mostra como ativar o recurso “list@level” dentro do nó “Core/List/Count”.
Figura 47 – Utilização do recurso “list@level” ao invés do nó “Core/List/Map”.
Também é possível aplicar uma combinação de funções nos elementos de uma lista usando o nó
“Core/Evaluate/Function Compose”. Esse nó permite receber diversas funções que serão processadas na
ordem que forem informadas. O resultado de uma função alimenta a próxima função.

No exemplo da Figura 48 o nó “Core/Math/Average” calcula a média dos valores contidos em cada sublista
e passa os resultados para o nó “Core/Math/Sqrt” que calcula a raiz quadrada de cada valor retornado
pelo nó “Core/Math/Average”. Por fim, o nó “Core/List/Map” se encarrega de aplicar essas duas funções
na lista original definida no nó “Code Block”.
Figura 48 – Exemplo de utilização do nó “Core/Evaluate/Function Compose”.
Combinando dados em listas

Na sessão anterior vimos que é possível aplicar diversas funções nos elementos de uma lista, mas as
funções que utilizamos (“Core/Math/Average” e “Core/Math/Sqrt”) possuíam apenas uma entrada.
Há casos em que será necessário aplicar funções que tenham mais de uma entrada aos dados de uma
lista, e para essas situações o nó mais adequado é “Core/List/Combine”. A Figura 49 mostra um exemplo
de utilização desse nó para aplicar a função “Operator/+” que têm duas entradas, aos dados de cada lista
informada.
Figura 49 – Exemplo de utilização do nó “Core/List/Combine”.

Nota: observe que a ideia o nó “Core/List/Combine” é uma extensão do nó “Core/List/Combine”, pois o

primeiro só aceita aplicar um conjunto de funções em uma única lista. Já o nó “Core/List/Combine”
permite aplicar um conjunto de funções combinando dados contidos em mais de uma lista.
Além do nó “Core/List/Combine” existe um recurso de combinação incorporado na maioria dos nós
chamado lacing (amarra). Esse recurso possui três opções para combinar dados entre duas listas, são eles:
• Shortest (mais curto): combina os elementos das listas envolvidas 1 a 1 (Figura 50). Quando o
número de elementos entre as listas é diferente os elementos finais da lista maior não participam
da combinação.
Figura 50 – Opção de amarra “lista mais curta”.
• Longtest (mais longo): combina os elementos das listas envolvidas 1 a 1 (Figura 51). Quando o
número de elementos entre as listas é diferente os elementos finais da lista maior são
combinados com o último elemento da lista menor.
Figura 51 - Opção de amarra “lista mais longa”.
• Cross Product (produto transversal): combina os elementos das listas envolvidas todos com
todos, isto é, todas as conexões possíveis são realizadas (Figura 52, p. 31).

Figura 52 - Opção de amarra “produto transversal”.
A opções do recurso “amarra” podem ser utilizadas para gerar conjuntos de pontos nos espaços 2D e 3D.
A opção “mais curto” quando recebe listas de mesmo comprimento (mesma quantidade de elementos)
combina esses elementos 1 a 1 gerando uma sequência de pontos posicionados numa determinada
direção (Figura 53).
Figura 53 – Exemplo de utilização do recurso “amarra” com a opção “mais curto”.
Na opção “produto transversal”, se as listas tem o mesmo comprimento, o recurso “amarra” permite
gerar uma grade de pontos no plano XY (Figura 54).
Figura 54 - Exemplo de utilização do recurso “amarra” com a opção “produto transversal” 2D.

A opção “produto transversal” quando recebe 3 listas de mesmo comprimento, gera uma nuvem de
pontos no espaço 3D (Figura 55).
Figura 55 - Exemplo de utilização do recurso “amarra” com a opção “produto transversal” 3D.
A opção “mais longo” faz mais sentido utilizar quando as listas que serão combinadas têm comprimentos
diferentes. O Figura 56 mostra um exemplo de utilização do desta opção para aplicar a função
“Core/String/Concat” para criar strings que com números sequenciais.
Figura 56 – Exemplo de utilização da opção “mais longo” do recurso “amarra”.
Adicionando e removendo dados numa lista

Para adicionar dados numa lista o Dynamo possui as seguintes funções na biblioteca (Figura 57):
• Core/List/AddItemToFront: acrescenta um item no início na lista.
• Core/List/AddItemToEnd: acrescenta um no final da lista.
Figura 57 – Exemplo de utilização dos nós “Core/List/AddItemToFront” e “Core/List/AddItemToEnd”.

Para remover dados numa lista o Dynamo possui as seguintes funções na categoria “Core/List” da
biblioteca:
• Core/List/RestOfItems: remove o primeiro item da lista;
• Core/List/RemoveItemAtIndex: remove itens da lista informando os seus índices a partir do
início da lista;
Figura 58 – Exemplo da utilização dos nós “Core/List/RestOfItems” e “Core/List/RemoveItemAtIndex”.
• Core/List/DropItems: remove itens da lista até um determinado índice e a partir do início da

lista. Se for informado um índice negativo, o nó removerá itens a partir do fim da lista;
• Core/List/DropEveryNthItems: remove itens da lista com índices múltiplos do índice informado.
Opcionalmente, é possível informar um passo (offset) para que o nó ignore determinados itens.
Figura 59 - Exemplo da utilização dos nós “Core/List/DropItems” e “Core/List/DropEveryNthItem”.
Também é possível remover itens duplicados de uma lista usando o nó “Core/List/UniqueItems” (Figura
60).

Figura 60 – Exemplo de utilização do nó “Core/List/UniqueItems”.
Substituindo elementos numa lista

Para remover dados numa lista o Dynamo possui as seguintes funções na categoria “Core/List” da
biblioteca:
• Core/List/ReplaceAtIndex: substitui um item da lista informando o seu índice a partir do início
da lista. Informando um índice negativo é possível substituir um item lendo a lista a partir do
final.
• Core/List/ReplaceByCondition: substitui itens na lista que atendem uma determinada condição,
isto é, quando a condição retornar “verdadeiro” o item é substituído.
Figura 61 – Exemplo de utilização de “Core/List/ReplaceAtIndex” e “Core/List/ReplaceByCondition”.
Nota: quando expressões lógicas são utilizadas como entrada no nó “Core/List/ReplaceByCondition”, use
o nó “Core/Scripting/Formula” ao invés de um nó “Code Block” para entrar com a expressão lógica. Se o
“Core/Scripting/Formula” não atualizar a saída do nó “Core/List/ReplaceByCondition”, desligue e ligue o
nó “Core/Scripting/Formula” da entrada “condition”. Esse é um pequeno “bug” no Dynamo! ☹
Ordenando dados numa lista

Para ordenar dados de uma lista a biblioteca padrão do Dynamo oferece os seguintes nós na categoria
“Core/List”:
• Core/List/Sort: classifica os itens da lista em ordem crescente. Essa classificação é aplicável para
dados numéricos e texto (string). Se precisar inverter a ordem da classificação use o nó
“Core/List/Reverse” (Figura 62).

• Core/List/SortByKey: classifica os itens de uma lista (lista original) com base numa outra lista
(lista de chaves). O nó primeiro classifica em ordem crescente a lista de chaves e depois utiliza
os índices desses elementos para ordenar os dados da lista original. Use esse nó quando a
ordenação natural retornada por “Core/List/Sort” não for possível. A Figura 63 (p. 35) ilustra um
exemplo de utilização do nó “List/Core/SortByKey” para ordenar os rótulos de paredes (ex.: PA-
1, PA-12, etc.) usando o os sufixos de cada rótulo (o número depois do hífen) para a ordenação.
Figura 62 – Exemplo de utilização de “Core/List/Sort” e “Core/List/Reverse” na classificação de itens.
Figura 63 – Exemplo de utilização do nó “Core/List/SortByIndex”.
Nota: também existe um outro nó “BuiltIn/SortByFunction” que permite ordenar dados em listas
aplicando uma função em seus dados. Similar aos nós que vimos nas sessões “Mapeando funções em
listas” (p. 28) e “Combinando dados em listas” (p. 29). A Figura 64 mostra um exemplo de utilização do nó
“BuiltIn/SortByFunction” para ordenar pontos nos eixos X e Y.
Figura 64 – Exemplo de ordenação de pontos usando o nó “BuilIn/SortByFunction”.

Por fim, existem duas variações do nó “BultIn/SortIndexByValue” que retornam como resultado não os
dados da lista ordenados, mas os seus índices (Figura 65).
Figura 65 – Exemplo de utilização do nó “BuilIn/SortIndexByValue”.
A primeira opção deste nó retorna os elementos em ordem crescente, já a segunda opção tem uma
entrada onde é possível controlar a ordem da classificação sem a necessidade de usar o nó
“Core/List/Reverse” depois.
Essa funcionalidade é interessante, pois permitirá selecionar um determinado elemento de uma lista
ordenada usando o nó “Core/List/GetItemAtIndex”.
Nota: o nó “BuiltIn/SortIndexByValue” só é aplicável em listas com dados numéricos. Para listas com
dados texto ou alfanuméricos, utilize os nós “Core/List/Sort” ou “Core/List/SortByKey”.

AULA 04
Modelagem Geométrica
Nessa aula veremos os nós da biblioteca padrão do Dynamo para trabalhar geometrias. Serão vistas as
funções usadas para modelagem geométrica e para acessar a geometria de elementos existentes no
modelo BIM.
Estrutura hierárquica dos tipos de dados na geometria

As geometrias no Dynamo são descritas de duas formas: tipos abstratos e tipos geométricos (Figura 66 –
Hierarquia dos tipos de dados geométricos no Dynamo.).
Os tipos abstratos como vetores e planos são utilizados para definir a localização, a orientação ou as
relações entre os objetos.
Já os tipos geométricos são utilizados para representar os objetos modelados.
Figura 66 – Hierarquia dos tipos de dados geométricos no Dynamo.
A categoria “Geometry” da biblioteca reúne todos os nós utilizados para modelagem geométrica do
Dynamo (Figura 67).
Figura 67 – Algumas das subcategorias de nós abaixo da categoria “Geometry”.
É possível criar uma geometria 2D usando um nó como “Geometry Circle/ByCenterPointRadius”, ou uma

geometria 3D com um nó como “Geometry/Cylinder/ByPointsRadius”.

Também é possível importar ou exportar um modelo 3D no formato de arquivo SAT utilizando nós como
“Geometry/Geometry/ImportFromSAT” e “Geometry/Geometry/ExportToSAT”.
Os pontos podem ser descritos no Dynamo usando um dos seguintes tipos de sistemas de coordenadas
de acordo com o tipo de objeto (Figura 68).
Figura 68 – Sistemas de coordenadas euclidianas e paramétricas.
Os pontos são os elementos essenciais de qualquer geometria criada no Dynamo.

Usando os nós “Core/Scripting/Formula” e “Geometry/Point/ByCoordinates” é possível criar pontos
usando fórmulas matemáticas (Figura 69).
Figura 69 – Uso de fórmulas matemáticas para a definição de pontos.
As curvas na hierarquia da geometria são os próximos objetos. No Dynamo todas as geometrias 2D são
curvas. Elas possuem um sistema de coordenadas paramétrico, onde o parâmetro “t” têm seus valores
variando de 0 até 1 (Figura 70, p.39).

Figura 70 – Coordenadas paramétricas nos tipos de curva.
As superfícies são geometrias compostas de curvas em duas direções (u e v). Possuem um sistema de
coordenadas similar ao das curvas, mas com dois parâmetros “u” e “v” (Figura 71).
Figura 71 – Coordenadas paramétricas sobre uma superfície.
Funções para manipulação de pontos

As funções no Dynamo para manipular pontos estão na categoria “Core/Geometry/Point”. A seguir uma
breve descrição de algumas funções:
• Core/Geometry/Point/ByCoordinates: permite a definição de pontos usando o sistema de
coordenadas euclidiana informando as componentes X, Y e Z da coordenada.
• Core/Geometry/Point/ByCylindricalCoordinates: permite a definição de pontos usando um
sistema de coordenada cilíndrico informando um sistema de coordenada de referência, um
ângulo de rotação do eixo Z, uma elevação em relação ao plano XY e um raio.
• Core/Geometry/Point/BySphericalCoordinates: permite a definição de pontos usando um
sistema de coordenada esférico informando um sistema de coordenada de referência, um ângulo
de rotação do eixo Z, um ângulo a partir do eixo X e um raio.

Funções para manipulação de curvas

As funções no Dynamo para manipular curvas estão na categoria “Core/Geometry”. A seguir uma breve
descrição de algumas funções:
• Core/Geometry/Arc/ByCenterPointRadiusAngle: permite traçar um arco pelo seu centro, raio e
ângulo de varredura.
• Core/Geometry/Circle/ByCenterPointRadius: permite traçar um círculo pelo seu centro e raio.
• Core/Geometry/Line/ByStartPointEndPoint: permite traçar uma linha informando as
coordenadas nos pontos inicial e final.
• Core/Geometry/Rectangle/ByWidthLength: permite traçar um retângulo centralizado no em
um determinado plano e informando seu comprimento e largura.
• Core/Geometry/Polycurve/ByPoints: permite traçar uma poligonal aberta ou fechada
informando as coordenadas de seus vértices.
• Core/Geometry/Nurbscurve/ByPoints: permite traçar uma curva polinomial (NURBS)
informando os pontos de controle e o grau do polinômio de interpolação da curva.
Funções para manipulação de sólidos

Para obter as faces de um elemento seja ele uma geometria produzida dentro do Dynamo ou um elmento
do modelo BIM, utilize o nó “Core/Geometry/Topology/Faces” (Figura 72).
Figura 72 – Exemplo de utilização do nó “Core/Geometry/Topology/Faces”.

AULA 05
Modelagem BIM com o Dynamo
Nessa aula veremos os nós da biblioteca padrão do Dynamo para trabalhar com modelos BIM no Revit.
Serão vistas as funções usadas para a inserção de famílias e para acessar os dados de elementos existentes
no modelo BIM.
A partir do Revit 2017 o Dynamo está incorporado ao núcleo do Revit, tornando-se um recurso nativo e
deixando seu processamento mais eficiente.
Para acessar o Dynamo a partir do Revit, acesse a aba “Gerenciar”, painel “Programação Visual” e clique
no botão Dynamo (Figura 73).
Figura 73 - Acesso ao Dynamo a partir do Revit.
O Dynamo quando executado a partir do Revit apresenta na biblioteca de nós uma categoria chamada
Revit. Nessa categoria são encontrados todos os nós para manipulação de modelos BIM pelo Dynamo
(Figura 74).
Figura 74 – Categoria “Revit” na biblioteca padrão do Dynamo.
Selecionando elementos do modelo BIM

É possível selecionar objetos ou partes desses objetos (pontos, faces ou arestas) de duas formas: seleção
explícita e seleção por filtro.
Os nós para seleção de objetos estão concentrados na categoria “Revit/Selection”. A figura apresenta os
principais nós da biblioteca padrão para a seleção de objetos.

Figura 75 – Principais nós para seleção de objetos na categoria “Revit/Selection”.
Use os nós “Selection Model Element” ou “Selecion Model Elements”, para selecionar elementos no
modelo BIM.
Use os nós “Select Face” ou “Select Faces”, para selecionar faces de um ou mais elemento no modelo
BIM.
Figura 76 - Nós utilizados para a seleção explícita de elementos e faces.
Esses são os nós básicos para seleção explícita no Dynamo, mas existem nós para elementos mais
específicos.
Nota: quando os elementos selecionados com esses nós forem excluídos do modelo BIM, a lógica criada
no Dynamo para manipular esses elementos deixará de funcionar.
Para a seleção de elementos no modelo BIM o Dynamo leva em consideração a hierarquia de elementos
no Revit como apresentada na Figura 77.
Figura 77 – Hierarquia de elementos no Revit.

Considerando a hierarquia de elementos no Revit, existem vários nós que permitem selecionar elementos
usando filtros. É possível filtrar elementos, por exemplo, por categoria, nível ou tipos de família.
Figura 78 – Nós para a seleção de elementos por categoria, tipo de família e nível.
Há também nós para selecionar tipos em famílias de sistema (ex.: paredes e pisos), ou elementos
específicos (ex.: níveis), ou ainda, uma determinada categoria de elemento (ex.: portas ou janelas).
Figura 79 – Nós para a seleção de tipos de família específicos.
Lendo valores de parâmetros nos elementos do modelo BIM

Outra operação importante no Dynamo é a capacidade de ler valores de parâmetros nos objetos no
modelo BIM.
Por exemplo, é possível ler parâmetros como comprimentos, áreas e volumes armazená-los numa lista e
depois usar essa lista para exportar os dados para o MS Excel.
Para ler valores de parâmetros de um ou mais elementos do modelo BIM utilize o nó
“Revit/Elements/Element/GetParameterValueByName”.
No exemplo da Figura 80, alguns parâmetros das paredes são lidos e armazenados numa lista com
sublistas usando o nó “Revit/Elements/Element/GetParameterValueByName”.
Figura 80 – Exemplo de utilização do nó “Revit/Elements/Element/GetParameterValueByName”.

Editando valores de parâmetros nos elementos do modelo BIM

Outra operação importante no Dynamo é a capacidade de editar valores em parâmetros nos elementos
do modelo BIM.
Por exemplo, é possível alterar parâmetros referentes a campos do carimbo em diversas pranchas de um
projeto.
Ou preencher parâmetros usando uma lógica como, por exemplo, preencher um parâmetro texto a partir
a da leitura de outros parâmetros. Ou ainda checar se determinados parâmetros do modelo estão
preenchidos corretamente.
Para editar os valores de parâmetros de um ou mais elementos de um modelo BIM utilize o nó
“Revit/Elements/Element/SetParameterByName”. No exemplo da Figura, dois parâmetros nas famílias de
janela são alterados usando o nó “Revit/Elements/Element/SetParameterByName”.
Figura 81 – Exemplo de utilização do nó “Revit/Elements/Element/SetParameterByName”.
Inserindo elementos no modelo BIM

Outra operação importante no Dynamo é a capacidade criar elementos no modelo BIM.
Por exemplo, é possível inserir luminárias em forros ou portas e janelas em paredes.
Os nós para inserção de elementos no modelo BIM são encontrados na categoria
“Revit/Elements/FamilyInstance” (Figura 82).
Figura 82 – Acesso a categoria “Revit/Elements/FamilyInstance”.

Os nós dessa categoria são usados para inserir famílias carregáveis: ex.: portas, janelas, luminárias, pilares,
etc. Para a inserção de famílias de sistema e outras famílias carregáveis (ex.: vigas), existem outras
categorias na biblioteca:
• Revit/Elements/Adaptive Components: componentes adaptativos;
• Revit/Elements/Curtain Panel: painéis cortina;
• Revit/Elements/Curtain System: sistema de painéis;
• Revit/Elements/Floor = pisos;
• Revit/Elements/Roof = telhado;
• Revit/Elements/StructuralFraming = vigas;
• Revit/Elements/Wall = paredes.
A Figura 83 apresenta um exemplo de grafo para modelar 4 paredes. O nó “Wall/ByCurveAndLevels”
permite modelar uma parede usando curvas (linhas ou arcos) e os níveis associados a nova parede.
Figura 83 – Exemplo de modelagem de paredes com o nó “Revit/Elements/Wall/ByCurveAndLevels”.

AULA 06
Interoperabilidade
A biblioteca padrão do Dynamo contém alguns nós para integração com o Microsoft Excel na sessão
“Office”.
O nó “Office/ReadFromFile” permite ler em um arquivo Excel. Já o nó “Office/WriteToFile” permite
escrever em um arquivo Excel.
Use esses nós para exportar ou importar dados entre o Revit e Excel.
Figura 84 – Acesso aos nós para acessar arquivos do MS Excel.
Importação de dados do Excel para o Revit

A Figura 85 apresenta um exemplo de aplicação do nó “Office/ReadFromFile” para leitura de dados numa
planilha e preenchimento de parâmetros nas paredes em função de suas características (externa ou
interna).
Figura 85 – Exemplo de preenchimento de parâmetros usados dados de um arquivo Excel.

Exportação de dados do Revit para o Excel

A Figura 86 apresenta um exemplo de aplicação do nó “Office/WriteFile” para exportação de algumas os
dados alguns parâmetros de paredes para uma planilha Excel.
Figura 86 - Exemplo de exportação de dados de parâmetros para um arquivo Excel.

AULA 07
Programação Textual vs Programação Visual
Nessa aula veremos uma introdução as duas principais linguagens de programação textual presentes no
Dynamo: Design Script e Python.
Quando usar programação textual
A programação visual apresenta uma forma mais simples de aprender de criar programas, pois utiliza
apenas artefatos gráficos (grafos) para representar uma lógica sem a necessidade de escrever longos
códigos de programação.
Mas, quando a lógica nos grafos se torna complexa demais os mesmos tendem a ficar muito poluídos.
Nesse momento, começa a ser recomendado o uso de programação textual para deixar os grafos mais
legíveis.
No Dynamo é possível utilizar linguagens textuais, tais como: DesignScript e Python, usando os nós “Code
Block” e “Python Script”.
Introdução a linguagem DesignScript

Essa a linguagem que o Dynamo utiliza por trás da sua biblioteca padrão de nós. Para usar DesignScript
utilize o nó “Code Block” como editor de códigos.
Definição de uma função em DesignScript

A Figura 87 apresenta um exemplo de utilização da linguagem DesignScript para a modelagem
geométrica, mas essa linguagem permite utilizar todas as funções da biblioteca padrão do Dynamo além
de estruturas de decisão (estrutura If) e estruturas de repetição (estruturas while e for).
Figura 87 – Exemplo de aplicação da linguagem Design Script.
No código Design Script apresentado na Figura 87, a declaração “def” permite definir uma nova função
no grafo que poder ser chamada dentro um nó “Code Block”.
Introdução a linguagem Python

A linguagem Python é uma opção mais avançada de linguagem textual no Dynamo.
Permite acesso à bibliotecas variadas de programação (aquelas disponíveis no IronPython® -
implementação da Microsoft para o Python desenvolvida em .NET) e à API (Application Programming
Interfce) do Revit®.

Para usar o Python no Dynamo utilize os nós “Core/Scripting/Python Script” ou “Core/Scripting/Python

Script From String” (Figura 88).
Figura 88 – Acesso aos nós para trabalhar com a linguagem Pytnon no Dynamo.
Exemplo de código Python no Dynamo

Não existe um nó na biblioteca padrão do Dynamo para inserir famílias baseadas em um host (hospedeiro)
como portas e janelas.
Para isso é necessário usar um nó Python. Abaixo um exemplo de grafo usando um nó Python para inserir
janelas em paredes (Figura).
Figura 89 – Exemplo de grafo que usa um nó “Core/Scripting/Python Script”.
A figura apresenta o código contido no nó “Core/S”. Ao clicar duas vezes sobre o nó um editor de código
será exibido e nele você poderá codificar um script usando a linguagem Python.

Figura 90 – Exemplo de código Python – Trecho 1.
Figura 91 – Exemplo de código Python – Trecho 1.

AULA 08
Customização de nós
A criação de nós customizados é uma técnica interessante para reaproveitar uma determinada lógica em
outros projetos.
Nós customizados podem ser armazenados na biblioteca do Dynamo dentro de uma categoria existente.
Para deixar os nós customizados mais organizados é recomendável armazená-los em uma categoria que
tenha relação com a ação que novo nó vai executar.
Por exemplo, use a categoria “Core/Geometry” para nós customizados que tenham relação com a
manipulação de geometrias.
A definição de um nó customizado é armazenado em arquivos de extensão “dfy” ao invés de arquivos
com a extensão “dyn”.
Criação de um nó personalizando
Nesse exemplo, utilizaremos o grafo “Ordenação de Pontos - Algoritmo Léxico.dyn” contido na pasta
“Dataset” do treinamento para criar um nó personalizado.
Abra o grafo e aplique um zoom na região identificada em laranja (Figura 92), essa é a parte do grafo que
será usada para criar o nó personalizado.
Figura 92 – Trecho do grafo “Ordenação de Pontos - Algoritmo Léxico”.
Selecione os nós contidos na região laranja com exceção o último nó “Watch”, clique botão direito e sobre
uma área livre da área de trabalho e selecione a opção “Criar nó personalizado” no menu contexto (Figura
93).
Figura 93 – Acesso ao comando “Criar nó personalizado”.

Na janela “Propriedades do nó personalizado”, preencha os campos como indicado na Figura e clique OK

para continuar.
Figura 94 – Preenchimento das propriedades do nó personalizado.
A Figura 95 apresenta o resultado final da criação do nó personalizado. Note que o novo nó já

automaticamente aplicado ao grafo e também adicionado embaixo da categoria correta na biblioteca
padrão.
Figura 95 – Aparência do nó personalizado no grafo e na biblioteca.
Observe que no topo da área de trabalho aparece uma nova aba chamada “Ordenar Pontos Léxico”,
habilitando esta aba você consegue visualizar a definição do nó personalizado (Figura 96).
Figura 96 – Definição do nó personalizado.
Nota: repare que a cor de fundo da área de trabalho é amarela para indicar que você está visualizando
uma definição de nó personalizado.

Tecle CTRL+S para salvar a definição do nó personalizado. Observe que a extensão do arquivo é “dfy” e
não “dyn” e que a pasta padrão usada para armazenar essa definição é (Figura):
C:\Users\dharm\AppData\Roaming\Dynamo\Dynamo Revit\1<versão corrente do Dynamo>\definitions
Figura 97 – Pasta padrão usada pelo Dynamo para armazenar arquivo “dyf”.
Após salvar a definição, feche a aba “Ordenar Pontos Léxico” e de volta a aba “Ordenação de Pontos -
Algoritmo Léxico”, feche-a para encerrar o processo.
Utilização de um nó personalizado
Para utilizar o nó personalizado em outro grafo, basta selecioná-lo na biblioteca como qualquer outro nó
para inserí-lo na área de trabalho.
Também é possível editar a propriedades do nó personalizado, clique clicando com o botão direito e
selecionando a opção “Editar as propriedades do nó personalizado...” (Figura 98). Faça as modificações
nas propriedades do nó personalizado e clique OK para finalizar o processo.
Figura 98 – Acesso ao comando “Editar as propriedades do nó personalizado...”.
Outra possibilidade é editar a definição de nó personalizado usando a opção “Editar o nó personalizado...”

do menu contexto. Com essa opção é possível abrir o arquivo “dyf” correspondente para editá-lo.

Por fim, é possível publicar esse nó personalizado na biblioteca de nós como um pacote. Essa opção
permitirá você adicionar esse novo nó em uma nova categoria na biblioteca. Preencha os campos da janela
“Publicar um pacote no Dynamo” como indicado na Figura 99 e clique no botão “Publicar localmente”.
Figura 99 - Preenchimento das propriedades do pacote.
Nota: a opção “Publicar on-line” lhe permite compartilhar o seu pacote no site do “Gerenciador de
pacotes”.

Considerações finais
Consulte mais detalhes sobre este e outros treinamentos da Dharma Sistemas na loja virtual:
www.dharmasistemas.wix.com/home/online-store
Muito obrigado e vejo você nos próximos treinamentos!
Prof. MsC. Ari Monteiro

Consultor e Pesquisador BIM
Dharma Sistemas
www.dharmasistemas.wix.com/home

Referências
AUTODESK. Autodesk Revit WikiHelp. Disponível em: http://help.autodesk.com/view/RVT/2019/ENU/.
Acesso em: 15 abr. 2019.
BIMFORUM. Level of Development Specification 2015. Disponível em: http://bimforum.org/lod/. Acesso

em: 15 abr. 2019.
BOSHERNITSAN, M.; DOWNES, M. Visual Programming Languages: A Survey. Report No. UCB/CSD-04-
1368. Computer Science Division (EECS). University of California. Berkeley, California, 2004. 28 p.
CRAFTAI. The maturity of visual programming. Disponível em: http://www.craft.ai/blog/the-maturity-of-

visual-programming/. Acesso em: 15 abr. 2019.
DYNAMO. Dynamo Primer. Disponível em: http://dynamobim.com/learn/#primer. Acesso em: 15 abr.

2019.
DYNAMO. Learn | Dynamo BIM. Disponível em: http://dynamobim.com/learn/#videoTut. Acesso em: 15

abr. 2019.
LACHAUER, L; RIPPMANN, M; BLOCK. P. Form Finding to Fabrication: A digital design process for masonry
vaults. In: International Association for Shell and Spatial Structures (IASS) Symposium – Spatial Structures
– Permanent and Temporary. Proceedings… Shangai: Tongji University, 2010. Disponível em:
http://www.block.arch.ethz.ch/brg/files/IASS2010_lachauer-rippmann-block.pdf. Acesso em: 15 abr.
2019.
MONTEIRO, A. UTILIZAÇÃO DE LINGUAGEM DE PROGRAMAÇÃO VISUAL PARA ELABORAÇÃO DE MODELOS

BIM LOD 400. In: 4th BIM INTERNATIONAL CONFERENCE, 2016, São Paulo e Lisboa. Proceedings... São
Paulo: BIMMI, 2016. Disponível em: http://migre.me/wbmsn
MONTEIRO, A.; SANTOS, E.T. Uso de modelagem generativa para representação de modulações de
alvenarias em ferramentas BIM. In: Congresso da Sociedade Iberoamericana de Gráfica Digital – SIGRADI,
13., 2009, São Paulo. Anais... São Paulo: Universidade Presbiteriana Mackenzie, 2009a, p. 119-121. (ISSN
2176-0519).
STAVRIC, M.; MARINA, O. Parametric Modeling for Advanced Architecture. In: INTERNATIONAL JOURNAL
OF APPLIED MATHEMATICS AND INFORMATICS. Issue 1, Volume 5, 2011. 8 p.

Apostila BIM & Projeto Computacional No Dynamo

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila BIM & Projeto Computacional No Dynamo

Enviado por

Direitos autorais:

Formatos disponíveis

Soluções em TI para Engenharia

Autodesk Revit® & Dynamo & Microsoft Excel®

Última revisão: 08/04/2019

Copyright © 2019 de Ari Monteiro

Copyright © 2019 Prof. Ari Monteiro 2/56

Introdução às Ferramentas VPL ................................................................................... 5

A ferramenta Dynamo ................................................................................................. 8

Interface com o usuário........................................................................................................................ 8

Elementos Básicos da Programação Visual ............................................................... 15

Tipos de dados .................................................................................................................................... 15

Funções matemáticas ................................................................................................ 17

Funções lógicas .......................................................................................................... 19

Funções para manipulação de strings ....................................................................... 20

Manipulação de Listas ............................................................................................... 22

Criando listas ...................................................................................................................................... 22

Modelagem Geométrica ............................................................................................ 37

Estrutura hierárquica dos tipos de dados na geometria ........................................... 37

Funções para manipulação de pontos ....................................................................... 39

Funções para manipulação de curvas........................................................................ 40

Funções para manipulação de sólidos ....................................................................... 40

Copyright © 2019 Prof. Ari Monteiro 3/56

Modelagem BIM com o Dynamo ............................................................................... 41

Selecionando elementos do modelo BIM .......................................................................................... 41

Importação de dados do Excel para o Revit ....................................................................................... 46

Programação Textual vs Programação Visual............................................................ 48

Quando usar programação textual..................................................................................................... 48

Customização de nós ................................................................................................. 51

Criação de um nó personalizando ...................................................................................................... 51

Considerações finais .................................................................................................. 55

Copyright © 2019 Prof. Ari Monteiro 4/56

Figura 1 – Cálculo da média de dois números usando uma VPL (Dynamo).

Copyright © 2019 Prof. Ari Monteiro 5/56

Figura 3 – O Dynamo criando geometrias a partir da lógica incorporada em um grafo.

Figura 5 – Aplicação do Dynamo em análise de insolação.

Copyright © 2019 Prof. Ari Monteiro 6/56

Copyright © 2019 Prof. Ari Monteiro 7/56

Ao instalar o Autodesk Revit o Dynamo também é instalado de duas formas:

Figura 8 – Acesso ao Dynamo a partir da faixa de opções do Revit.

• Dynamo Sandbox: é a versão standalone do Dynamo, isto é, um aplicativo independente que

Interface com o usuário

Copyright © 2019 Prof. Ari Monteiro 8/56

Figura 9 – Elementos da interface com o usuário no Dynamo.

• Biblioteca: painel que organiza as funções de programação visual em categorias.

Copyright © 2019 Prof. Ari Monteiro 9/56

Figura 10 – Função “Órbita” na barra de navegação.

Figura 11 – Anatomia de um nó.

• Nome: nome do nó seguindo a convenção de nomeação “Categoria.Nome”;

Copyright © 2019 Prof. Ari Monteiro 10/56

Figura 13 – Exemplo de documentação de um nó exibida quando a opção “Ajuda...” é acionada.

Figura 14 – Aparências de um nó durante o desenvolvimento de um programa.

Copyright © 2019 Prof. Ari Monteiro 11/56

Figura 15 – Ligação de dois nós com um fio.

Figura 16 – Categorias de nós na biblioteca.

Copyright © 2019 Prof. Ari Monteiro 12/56

Organização e gerenciamento de dados em um programa

Figura 17 – Alinhamento de nós com o comando “Alinhar seleção”.

• Criar nota: permite adicionar notas explicativas no grafo (Figura 18);

Figura 18 – Adição de uma nota no grafo com o comando “Criar nota”.

Figura 19 – Agrupamento de elementos com o comando “Criar grupo”.

Copyright © 2019 Prof. Ari Monteiro 13/56

Figura 20 – Sugestão para a padronização de cores de grupos nos em grafos.

Abaixo uma breve descrição sobre cada padrão de cor sugerido:

Copyright © 2019 Prof. Ari Monteiro 14/56