Dynamo
Primer for v2.0
Português (Brasil)
Português (Brasil)
  • Sobre
  • Introdução
    • O que é o Dynamo e como ele funciona?
    • Guia do Usuário do Primer, Comunidade e plataforma do Dynamo
  • Configuração do Dynamo
  • Interface do usuário
    • Área de trabalho
    • Biblioteca
  • Nós e fios
  • Nós e conceitos essenciais
    • Índice de nós
    • Geometria do projeto computacional
      • Visão geral da geometria
      • Vetor, plano e sistema de coordenadas
      • Pontos
      • Curvas
      • Superfícies
      • Sólidos
      • Malhas
    • Os blocos de construção de programas
      • Dados
      • Matemática
      • Lógica
      • Sequências de caracteres
      • Cor
    • Projetar com listas
      • O que é uma lista?
      • Trabalhar com listas
      • Listas de listas
      • Listas n-dimensionais
    • Dicionários no Dynamo
      • O que é um dicionário
      • Nós de dicionário
      • Dicionários em blocos de código
      • Casos de uso do Revit
  • Nós e pacotes personalizados
    • Nós personalizados
      • Introdução ao nó personalizado
      • Criar um nó personalizado
      • Publicar na biblioteca
    • Pacotes
      • Introdução aos pacotes
      • Estudo de caso do pacote – Kit de ferramentas de malha
      • Desenvolver um pacote
      • Publicar um pacote
      • Importação sem toque
  • Dynamo para Revit
    • A conexão do Revit
    • Selecionar
    • Editar
    • Criar
    • Personalizar
    • Documentação
  • Dynamo for Civil 3D
    • Conexão do Civil 3D
    • Guia de Introdução
    • Biblioteca de nós
    • Exemplos de fluxos de trabalho
      • Estradas
        • Posicionamento de postes de luz
      • Terra
        • Posicionamento de serviço
      • Utilitários
        • Renomear estruturas
      • Ferrovia
        • Estrutura da altura livre
      • Levantamento topográfico
        • Gerenciamento de grupo de pontos
    • Tópicos avançados
      • Vinculação de objetos
      • Python e Civil 3D
    • Dynamo Player
    • Pacotes úteis
    • Recursos
  • Dynamo no Forma Beta
    • Configurar o Dynamo Player no Forma
    • Adicionar e compartilhar gráficos no Dynamo Player
    • Executar gráficos no Dynamo Player
    • O Dynamo calcula diferenças de serviço com o Dynamo Desktop
  • Codificação no Dynamo
    • Blocos de código e DesignScript
      • O que é um bloco de código
      • Sintaxe do DesignScript
      • Abreviação
      • Funções
    • Geometria com o DesignScript
      • Conceitos básicos da geometria DesignScript
      • Primitivas geométricas
      • Matemática de vetores
      • Curvas: interpoladas e pontos de controle
      • Transformações de conversão, de rotação e outras
      • Superfícies: interpoladas, pontos de controle, elevação, revolução
      • Parametrização geométrica
      • Interseção e aparar
      • Booleanos geométricos
      • Geradores de pontos do Python
    • Python
      • Nós do Python
      • Python e Revit
      • Configurar seu próprio modelo Python
    • Alterações de linguagem
  • Práticas recomendadas
    • Estratégias de gráfico
    • Estratégias de script
    • Referência dos scripts
    • Gerenciar o programa
    • Trabalhar de forma eficiente com grandes conjuntos de dados no Dynamo
  • Exemplos de fluxos de trabalho
    • Fluxos de trabalho de introdução
      • Vaso paramétrico
      • Pontos de atração
    • Índice conceitual
  • Manual do Desenvolvedor
    • Compilar o Dynamo da origem
      • Compilar o DynamoRevit da origem
      • Gerenciar e atualizar dependências no Dynamo
    • Desenvolvimento do Dynamo
      • Guia de Introdução
      • Estudo de caso sem toque – Nó de grade
      • Executar scripts Python em nós Sem toque (C#)
      • Aprofundar o conhecimento sobre o nó Sem toque
      • Personalização avançada de nós do Dynamo
      • Usar tipos COM (interoperabilidade) em pacotes do Dynamo
      • Estudo de caso do NodeModel – Interface do usuário personalizada
      • Atualizar os pacotes e as bibliotecas do Dynamo para Dynamo 2.x
      • Atualizar os pacotes e as bibliotecas do Dynamo para Dynamo 3.x
      • Extensões
      • Definir a organização de pacotes personalizados no Dynamo 2.0 e superior
      • Interface de linha de comando do Dynamo
      • Integração do Dynamo
      • Desenvolvimento do Dynamo para Revit
      • Publicar um pacote
      • Compilar um pacote do Visual Studio
      • Extensões como pacotes
    • Solicitações de extração
    • Expectativas de testes
    • Exemplos
  • Apêndice
    • Perguntas frequentes
    • Programação visual e Dynamo
    • Recursos
    • Notas de versão
    • Pacotes úteis
    • Arquivos de exemplo
    • Mapa de integração do hospedeiro
    • Fazer o download do PDF
    • Atalhos de teclado do Dynamo
Powered by GitBook
On this page
  • Notação de ponto no bloco de código
  • Nós de chamada – Criar, Ações, Consulta
  • E a amarra?
  • Nó para código
  • Exercício: Atração de superfície
Edit on GitHub
Export as PDF
  1. Codificação no Dynamo
  2. Blocos de código e DesignScript

Sintaxe do DesignScript

PreviousO que é um bloco de códigoNextAbreviação

Last updated 1 month ago

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):

Legível por humanos
Notação de ponto
Saída

Qual é a cor da maçã?

Apple.color

vermelho

A maçã está madura?

Apple.isRipe

true

Quanto a maçã pesa?

Apple.weight

170 g

De onde veio a maçã?

Apple.parent

árvore

O que a maçã cria?

Apple.children

sementes

Esta maçã foi cultivada localmente?

Apple.distanceFromOrchard

96 km

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.

14KB
Dynamo-Syntax_Attractor-Surface.dyn
NodeNames