Nesta seção, apresentamos os nós essenciais disponíveis na biblioteca do Dynamo que ajudarão você a criar seu próprio programa visual como um profissional.

• Geometria do projeto computacional: Como posso trabalhar com elementos geométricos no Dynamo? Explore várias maneiras de criar geometrias simples ou complexas com base em primitivos.

• Blocos de construção de programas: O que são os “Dados” e quais são alguns tipos fundamentais que posso começar a usar em meus programas? Além disso, saiba mais sobre como incorporar operações de matemática e lógica no fluxo de trabalho do projeto.

• Projetar com listas: Como posso gerenciar e coordenar minhas estruturas de dados? Entenda mais sobre o conceito de lista e use-a para gerenciar os dados do projeto com eficiência.

• Dicionários no Dynamo: O que são dicionários? Descubra como usar dicionários para procurar dados e valores específicos nos resultados existentes.

Geometria no Dynamo Sandbox

Geometria é a linguagem da área de design. Quando uma linguagem de programação ou ambiente tem um kernel de geometria em seu núcleo, podemos explorar as possibilidades de projetar modelos precisos e robustos, automatizando rotinas de projeto e gerando iterações de projeto com algoritmos.

A compreensão dos tipos de geometria e como eles estão relacionados permitirá navegar no conjunto de Nós de geometria disponíveis na biblioteca. Os nós de geometria são organizados em ordem alfabética, ao contrário da hierarquia; aqui eles são exibidos de forma similar ao layout na interface do Dynamo.

Além disso, a criação de modelos no Dynamo e conexão da visualização de plano fundo ao fluxo de dados em nosso gráfico são processos que devem se tornar mais intuitivos com o passar do tempo.

1. Observe o sistema de coordenadas assumido renderizado pela grade e pelos eixos coloridos

2. Os nós selecionados irão renderizar a geometria correspondente (se o nó criar geometria) no plano de fundo, a cor de realce

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.

Conceito de geometria

A geometria, tradicionalmente definida, é o estudo de forma, tamanho, posição relativa das imagens e as propriedades de espaço. Este campo tem uma história rica que remonta a milhares de anos. Com o advento e a popularização do computador, ganhamos uma poderosa ferramenta na definição, na exploração e na geração de geometria. Agora é muito fácil calcular o resultado de interações geométricas complexas, o fato de que estamos fazendo isso é quase transparente.

Se você tem curiosidade em descobrir como a geometria pode ser diversa e complexa com o poder do computador, faça uma pesquisa rápida pelo Stanford Bunny, um modelo tradicional usado para testar algoritmos.

Compreender a geometria no contexto de algoritmos, computação e complexidade pode parecer desafiador. No entanto, há alguns princípios-chave e relativamente simples que podemos estabelecer como fundamentos para começar a construção em aplicativos mais avançados:

1. A geometria corresponde a dados: para o computador e o Dynamo, um modelo Bunny não é tão diferente de um número.

2. A geometria depende da abstração: fundamentalmente, os elementos geométricos são descritos por números, relações e fórmulas em um determinado sistema de coordenadas espaciais

3. A geometria possui uma hierarquia: os pontos são reunidos para criar linhas, as linhas se unem para criar superfícies, e assim por diante

4. A geometria descreve simultaneamente a parte e o todo: quando uma curva é exibida, ela tem a forma e todos os pontos possíveis ao longo dela

Na prática, esses princípios significam que precisamos estar cientes do material com o qual estamos trabalhando (com que tipo de geometria, como ela foi criada, etc.) para que possamos compor, decompor e recompor de forma fluida diferentes geometrias à medida que desenvolvemos modelos mais complexos.

Etapas a seguir na hierarquia

Vamos separar um momento para analisar a relação entre as descrições de geometria abstrata e hierárquica. Como esses dois conceitos estão relacionados, mas nem sempre são óbvios no início, podemos chegar rapidamente a um bloco de estradas conceitual quando começamos a desenvolver fluxos de trabalho ou modelos mais profundos. Para começar, vamos usar a cotagem como um descritor fácil do "material" que modelamos. O número de cotas necessárias para descrever uma forma nos dá uma ideia sobre como a geometria é organizada hierarquicamente.

1. Um Ponto (definido por coordenadas) não possui dimensões, apenas números que descrevem cada coordenada

2. Uma Linha (definida por dois pontos) agora tem uma cota: é possível “navegar” na linha para frente (direção positiva) ou para trás (direção negativa)

3. Um Plano (definido por duas linhas) tem duas dimensões: agora é possível andar mais para a esquerda ou mais para a direita

4. Uma Caixa (definida por dois planos) tem três dimensões: podemos definir uma posição com relação para cima ou para baixo

A cotagem é uma forma conveniente de começar a classificar a geometria, mas não é necessariamente a melhor. Afinal, não modelamos apenas com pontos, linhas, planos e caixas; e se eu quiser algum modelo curvado? Além disso, há toda uma outra categoria de tipos de geometria que é completamente abstrata, ou seja, define propriedades como orientação, volume ou relações entre as peças. Não podemos considerar um vetor, e então como o definimos em relação ao que vemos no espaço? Uma categorização mais detalhada da hierarquia geométrica deve acomodar a diferença entre Tipos abstratos ou “Auxiliares”, cada um dos quais podemos agrupar pelo que eles ajudam a fazer e os tipos que ajudam a descrever a forma dos elementos do modelo.

Aprofundar a geometria

A criação de modelos no Dynamo não se limita ao que podemos gerar com Nós. Aqui estão algumas maneiras importantes de levar o processo para o próximo nível com a Geometria:

1. O Dynamo permite importar arquivos: tente usar um CSV para nuvens de pontos ou SAT para trazer superfícies

2. Quando trabalhamos com o Revit, podemos referenciar os elementos do Revit para usar no Dynamo

3. O Dynamo Package Manager oferece funcionalidade adicional para tipos e operações estendidos de geometria: verifique o pacote Kit de ferramentas de malha

Como um ambiente de programação visual, o Dynamo permite criar a forma como os dados são processados. Os dados são números ou texto, mas também a geometria. Conforme entendido pelo computador, a geometria (ou às vezes chamada Geometria computacional) são os dados que podemos usar para criar modelos bonitos, intrincados ou orientados para o desempenho. Para fazer isso, precisamos compreender os pontos de entrada e saída dos diferentes tipos de geometria que podemos usar.

Vetor, plano e sistema de coordenadas no Dynamo

Vetor

Vetor é uma representação de magnitude e direção. É possível visualizá-lo como uma seta que acelera em uma determinada direção em uma velocidade especificada. É um componente-chave para os nossos modelos no Dynamo. Observe que, como eles estão na categoria Abstrata de “Auxiliares”, quando criamos um vetor, não veremos nada na Visualização do plano de fundo.

1. Podemos usar uma linha como suporte para uma visualização de Vetor.

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.

Plano

Plano é uma superfície bidimensional. É possível imaginá-lo como uma superfície plana que se estende indefinidamente. Cada plano tem uma Origem, Direção X, Direção Y e uma Direção Z (para cima).

1. Embora sejam abstratos, os planos têm uma posição de origem para que possam ser localizados no espaço.

2. No Dynamo, os planos são renderizados na Visualização de plano de fundo.

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.

Sistema de coordenadas

Sistema de coordenadas é um sistema para determinar a localização de pontos ou outros elementos geométricos. A imagem abaixo explica como o sistema de coordenadas é exibido no Dynamo e o que cada cor representa.

1. Embora sejam abstratos, os sistemas de coordenadas também têm uma posição de origem para que possamos localizá-los no espaço.

2. No Dynamo, os sistemas de coordenadas são renderizados na visualização do plano de fundo como um ponto (origem) e linhas que definem os eixos (X é vermelho, Y é verde e Z é azul, seguindo a convenção).

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.

Análise abrangente de...

Vetores, Planos e Sistemas de coordenadas constituem o grupo principal de Tipos de geometria abstratos. Eles nos ajudam a definir a localização, a orientação e o contexto espacial para outra geometria que descreva as formas. Se eu disser que estou em Nova Iorque, na rua 42nd e Broadway (Sistema de Coordenadas), de pé no nível da rua (Plano), olhando para o norte (Vetor), acabei de usar essas "Ajudas" para definir onde estou. O mesmo vale para um produto de caso de telefone ou um arranha-céu. Precisamos desse contexto para desenvolver nosso modelo.

Vetor

Um vetor é uma quantidade geométrica que descreve a direção e a magnitude. Os vetores são abstratos; isto é, eles representam uma quantidade, e não um elemento geométrico. Os vetores podem ser facilmente confundidos com pontos porque ambos são compostos por uma lista de valores. No entanto, há uma diferença fundamental: os pontos descrevem uma posição em um determinado sistema de coordenadas, enquanto os vetores descrevem uma diferença relativa na posição, o que é o mesmo que dizer “direção”.

Se a ideia de diferença relativa for confusa, pense no vetor AB como “Estou de pé no ponto A, olhando em direção ao ponto B”. A direção, daqui (A) até lá (B), é o nosso vetor.

Dividindo os vetores em suas partes, usando a mesma notação AB:

1. O Ponto inicial do vetor é chamado Base.

2. O *Ponto final **do vetor é chamado Ponta ou Sentido.

3. O vetor AB não é o mesmo que o vetor BA, que apontaria na direção oposta.

Se você precisar de uma anedota no que diz respeito aos vetores (e sua definição abstrata), veja a comédia clássica Airplane e ouça o diálogo engraçado:

Roger, Roger. Qual é o nosso vetor, Victor?

Plano

Os planos são "Ajudas" abstratas bidimensionais. Mais especificamente, os planos são conceitualmente "planos", estendendo-se infinitamente em duas direções. Normalmente, eles são renderizados como um retângulo menor perto de sua origem.

Você pode estar pensando: “Espere um segundo. Origem? Isso parece um sistema de coordenadas... como o que eu uso para modelar no meu software CAD!"

E você está correto! A maioria dos softwares de modelagem tira proveito dos planos de construção ou "níveis" para definir um contexto de duas dimensões locais na qual a inclinação será desenhada. XY, XZ, YZ, ou: Norte, Sudoeste, o plano pode parecer mais familiar. Todos esses são os Planos, definindo um contexto "plano" infinito. Os planos não têm profundidade, mas eles nos ajudam a descrever a direção também -

Sistema de coordenadas

Se estivermos confortáveis com o conceito de planos, estamos a um pequeno passo de entender os sistemas de coordenadas. Um plano tem todas as mesmas peças que um sistema de coordenadas, desde que seja um sistema de coordenadas padrão "Euclidean" ou "XYZ".

No entanto, há outros sistemas de coordenadas alternativos como Cilíndricos ou Esféricos. Como veremos em seções posteriores, os sistemas de coordenadas também podem ser aplicados a outros tipos de geometria para definir uma posição naquela geometria.

Adicionar sistemas de coordenadas alternativos: cilíndricos, esféricos

Quando estivermos prontos para nos aprofundar no desenvolvimento de programas visuais, precisaremos de uma compreensão mais profunda dos blocos de construção que usaremos. Este capítulo apresentará os conceitos fundamentais em torno dos dados: o que percorre os fios do nosso programa Dynamo.

Pontos no Dynamo

O que é um ponto?

Um ponto é definido por nada mais que um ou mais valores chamados coordenadas. A quantidade de valores de coordenadas que precisamos para definir o ponto depende do sistema de coordenadas ou do contexto em que ele se encontra.

Ponto 2D/3D

O tipo mais comum de ponto no Dynamo existe em nosso Sistema de coordenadas universais tridimensional e tem três coordenadas [X,Y,Z] (Ponto 3D no Dynamo).

Um ponto 2D no Dynamo tem duas coordenadas [X,Y].

Ponto em curvas e superfícies

Os parâmetros para curvas e superfícies são contínuos e se estendem além da aresta da geometria fornecida. Como as formas que definem o espaço paramétrico residem em um Sistema de coordenadas universais tridimensional, sempre podemos converter uma coordenada paramétrica em uma coordenada “Universal”. O ponto [0,2; 0,5] na superfície, por exemplo, é o mesmo que o ponto [1,8; 2,0; 4,1] nas coordenadas universais.

1. Ponto em coordenadas XYZ universais assumidas

2. Ponto relativo a um determinado sistema de coordenadas (cilíndrico)

3. Ponto como coordenada UV em uma 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.

Análise abrangente de...

Se a geometria é o idioma de um modelo, então os pontos são o alfabeto. Os pontos são a fundação na qual todas as outras geometrias são criadas: precisamos de ao menos dois pontos para criar uma curva, precisamos de ao menos três pontos para criar um polígono ou uma face de malha, e assim por diante. A definição de posição, ordem e relação entre os pontos (tente uma função de seno) nos permite definir uma geometria de ordem superior como as coisas que reconhecemos como círculos ou curvas.

1. Um círculo que usa as funções x=r*cos(t) e y=r*sin(t)

2. Uma curva senoidal que usa as funções x=(t) e y=r*sin(t)

Ponto como Coordenadas

Os pontos também podem existir em um sistema de coordenadas bidimensional. A convenção tem uma notação de letra diferente dependendo do tipo de espaço com que estamos trabalhando: podemos usar [X,Y] em um plano ou [U,V] se estivermos em uma superfície.

1. Um ponto no Sistema de coordenadas euclidianas: [X,Y,Z]

2. Um ponto em um sistema de coordenadas de parâmetro de curva: [t]

3. Um ponto em um sistema de coordenadas de parâmetro de superfície: [U,V]

Este índice fornece informações adicionais sobre todos os nós usados neste manual de introdução, bem como outros componentes que você pode considerar úteis. Esta é apenas uma introdução a alguns dos 500 nós disponíveis no Dynamo.

Exibição

Cor

Inspeção

Entrada

Lista

Lógica

Matemática

Sequência de caracteres

Geometria

Circle

Cuboide

Curva

Modificadores de geometria

Linha

NurbsCurve

NurbsSurface

Plano

Ponto

Policurva

Retângulo

Esfera

Superfície

UV

Vetor

CoordinateSystem

Operadores

Curvas no Dynamo

O que é uma curva?

As curvas são o primeiro tipo de dados geométricos que abordamos com um conjunto mais familiar de propriedades descritivas de forma: em que medida elas são mais curvas ou retas? Longas ou curtas? E lembre-se de que os Pontos ainda são os nossos blocos de construção para definir qualquer coisa, desde uma linha a uma spline e todos os tipos de curva entre elas.

1. Linha

2. Polilinha

3. Arco

4. Circle

5. Elipse

6. Curva NURBS

7. PolyCurve

Linha

Curva NURBS

NURBS é um modelo usado para representar curvas e superfícies com precisão. Uma curva senoidal no Dynamo usando dois métodos diferentes para criar curvas NURBS para comparar os resultados.

1. NurbsCurve.ByControlPoints usa a lista de pontos como pontos de controle

2. NurbsCurve.ByPoints desenha uma curva através da lista de pontos

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.

Análise abrangente de...

Curvas

O termo Curve é um termo mais abrangente que engloba todas as diferentes formas curvas (mesmo se forem retas). A curva capital “C” é a categorização principal para todos esses tipos de forma: linhas, círculos, splines, etc. Tecnicamente, uma curva descreve cada ponto possível que possa ser encontrado inserindo “t” em um conjunto de funções, que podem variar desde funções simples (x = -1.26*t, y = t) a funções que envolvam cálculos. Não importa com que tipo de curva estamos trabalhando, este Parâmetro chamado “t” é uma propriedade que podemos avaliar. Além disso, independentemente da aparência da forma, todas as curvas também têm um ponto inicial e um ponto final, que coincidem com os valores mínimo e máximo de “t” usados para criar a curva. Isso também nos ajuda a compreender sua direcionalidade.

É importante observar que o Dynamo assume que o domínio dos valores “t” de uma curva é compreendido entre 0,0 e 1,0.

Todas as curvas também possuem diversas propriedades ou características que podem ser usadas para descrever ou analisar. Quando a distância entre os pontos inicial e final for zero, a curva será "fechada". Além disso, cada curva tem vários pontos de controle, se todos esses pontos estão localizados no mesmo plano, a curva é "plana". Algumas propriedades se aplicam à curva como um todo, enquanto outras somente se aplicam a pontos específicos ao longo da curva. Por exemplo, a planaridade é uma propriedade global, enquanto um vetor tangente em um determinado valor "t" é uma propriedade local.

Linhas

As Linhas são a forma mais simples de Curvas. Podem não parecer curvas, mas na verdade são: apenas sem qualquer curvatura. Existem algumas maneiras diferentes de criar Linhas, sendo a mais intuitiva do ponto A ao ponto B. A forma da linha AB será desenhada entre os pontos, mas matematicamente ela se estende infinitamente em ambas as direções.

Quando nós conectamos duas linhas, temos uma Polilinha. Aqui temos uma representação simples do que é um Ponto de controle. Editar qualquer uma dessas localizações de ponto irá alterar a forma da D. Se a polilinha estiver fechada, temos um polígono. Se os comprimentos de aresta do polígono forem todos iguais, ele será descrito como normal.

Arcos, círculos, arcos de elipse e elipses

À medida que adicionamos mais complexidade às funções paramétricas que definem uma forma, podemos avançar mais uma etapa a partir de uma linha para criar um Arco, Círculo, Arco de elipse ou Ellipse descrevendo um ou dois raios. As diferenças entre a versão do arco e o círculo ou elipse são apenas se a forma está fechada.

NURBS + Policurvas

NURBS (Splines de base racional não uniforme) são representações matemáticas que podem modelar com precisão qualquer forma, desde uma linha simples bidimensional, um círculo, um arco ou um retângulo até a curva orgânica tridimensional mais complexa e de forma livre. Devido à sua flexibilidade (relativamente poucos pontos de controle, mas interpolação suave com base nas configurações de grau) e precisão (delimitado por uma matemática robusta), os modelos NURBS podem ser usados em qualquer processo, da ilustração e animação à fabricação.

Grau: o grau da curva determina o intervalo de influência que os pontos de controle têm em uma curva; quanto maior for o grau, maior será o intervalo. O grau é um número inteiro positivo. Este número é normalmente 1, 2, 3 ou 5, mas pode ser qualquer número inteiro positivo. As linhas e polilinhas NURBS são normalmente de grau 1 e a maioria das curvas de forma livre é de graus 3 ou 5.

Pontos de controle: os pontos de controle são uma lista de ao menos pontos de graus + 1. Uma das formas mais fáceis de alterar a forma de uma curva NURBS é mover seus Pontos de controle.

Peso: os pontos de controle têm um número associado denominado Peso. Os pesos são, normalmente, números positivos. Quando os Pontos de controle de uma curva têm o mesmo peso (normalmente 1), a Curva é chamada não racional, caso contrário, a Curva é chamada racional. A maioria das curvas NURBS é não racional.

Nós: os nós são uma lista de números (graus+N-1), em que N é o número de pontos de controle. Os nós são usados junto com os pesos para controlar a influência dos Pontos de controle na curva resultante. Um uso dos nós é a criação de pontos de inflexão em certos pontos da curva.

1. Grau = 1

2. Grau = 2

3. Grau = 3

O que é uma sequência de caracteres?

Formalmente, uma String é uma sequência de caracteres que representa uma constante literal ou algum tipo de variável. De forma informal, uma sequência de caracteres é jargão de programação para texto. Trabalhamos com números, tanto números inteiros quanto decimais, para controlar os parâmetros e podemos fazer o mesmo com o texto.

Criar sequências de caracteres

É possível usar as sequências de caracteres para uma ampla gama de aplicativos, incluindo a definição de parâmetros personalizados, a anotação de conjuntos de documentação e a análise através de conjuntos de dados com base em texto. O nó String está localizado em Núcleo>Categoria de entrada.

Os nós de amostra acima são sequências de caracteres. É possível representar um número como uma sequência de caracteres, assim como uma letra ou uma matriz de texto inteira.

Exercício

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.

Consultar as sequências de caracteres

É possível analisar rapidamente grandes quantidades de dados ao consultar sequências de caracteres. Falaremos sobre algumas operações básicas que podem acelerar um fluxo de trabalho e ajudar na interoperabilidade do software.

A imagem abaixo considera uma sequência de caracteres de dados proveniente de uma planilha externa. A sequência de caracteres representa os vértices de um retângulo no plano XY. Vamos analisar algumas operações de divisão de sequências de caracteres no exercício em miniatura:

1. O separador “;” divide cada vértice do retângulo. Isso cria uma lista com três itens para cada vértice.

1. Pressionando “+” no meio do nó, criamos um novo separador.

2. Adicione uma sequência de caracteres “,” à tela e conecte-se à nova entrada do separador.

3. Nosso resultado é agora uma lista de dez itens. Primeiro, o nó é dividido com base em separator0 e, em seguida, com base em separator1.

Embora a lista de itens acima possa parecer ser de números, eles ainda são considerados sequências de caracteres individuais no Dynamo. Para criar pontos, seu tipo de dados precisa ser convertido de uma sequência de caracteres em um número. Isso é feito com o nó String.ToNumber

1. Esse nó é simples. Conecte os resultados de String.Split à entrada. A saída não parece diferente, mas o tipo de dados é agora um número em vez de uma sequência de caracteres.

Com algumas operações adicionais básicas, agora temos um triângulo desenhado na origem com base na entrada original da sequência de caracteres.

Manipular sequências de caracteres

Como uma sequência de caracteres é um objeto de texto genérico, ela armazena uma ampla gama de aplicações. Vamos analisar algumas das principais ações em Núcleo>Categoria de sequência de caracteres no Dynamo:

Este é um método que consiste em mesclar duas sequências de caracteres em ordem. Usa cada sequência de caracteres literais de uma lista e cria uma sequência de caracteres mesclada.

Veja a seguir a representação da concatenação das três sequências de caracteres:

1. Adicione ou subtraia sequências de caracteres da concatenação clicando nos botões +/- no centro do nó.

2. A saída fornece uma sequência de caracteres concatenada, com espaços e sinais de pontuação incluídos.

O método de união é muito similar a concatenar, exceto que tem uma camada de pontuação adicionada.

Se você já tiver trabalhado no Excel, poderá já ter visto um arquivo CSV. Isso significa valores separados por vírgulas. É possível usar uma vírgula (ou, neste caso, dois traços) como separador com o nó String.Join para criar uma estrutura de dados similar.

A imagem a seguir representa a união das duas sequências de caracteres:

1. A entrada do separador permite criar uma sequência de caracteres que divide as sequências de caracteres unidas.

Trabalhar com sequências de caracteres

Neste exercício, vamos usar métodos de consulta e manipulação de sequências de caracteres para desconstruir a estrofe final de Robert Frost: Parando em bosques em uma noite de neve. Não é o aplicativo mais prático, mas nos ajuda a compreender as ações de sequências de caracteres conceituais conforme as aplicamos às linhas legíveis de ritmo e rima.

Vamos começar com uma divisão básica da sequência de caracteres da estrofe. Primeiro, percebemos que a escrita é formatada com base em vírgulas. Usaremos esse formato para separar cada linha em itens individuais.

1. A sequência de caracteres base é colada em um nó String.

2. Outro nó String é usado para indicar o separador. Neste caso, usamos uma vírgula.

3. Um nó String.Split é adicionado à tela e conectado às duas sequências de caracteres.

4. A saída mostra que separamos as linhas em elementos individuais.

Agora, vamos chegar à parte boa do poema: as duas últimas linhas. A estrofe original era um item de dados. Separamos esses dados em itens individuais na primeira etapa. Agora, precisamos pesquisar o texto que estamos procurando. Embora seja possível fazer isso selecionando os últimos dois itens da lista, se este fosse um livro inteiro, não iríamos querer ler tudo e isolar manualmente os elementos.

1. Em vez de pesquisar manualmente, usamos o nó String.Contains para executar uma pesquisa de um conjunto de caracteres. Isso é semelhante a usar o comando “Localizar” em um processador de texto. Neste caso, obteremos um retorno de “true” ou “false” se a subsequência de caracteres for encontrada no item.

2. Na entrada searchFor, definimos uma subsequência de caracteres que estamos procurando na estrofe. Vamos usar um nó String com o texto “E milhas”.

3. A saída nos fornece uma lista de valores false e true. Usaremos essa lógica booleana para filtrar os elementos na próxima etapa.

1. List.FilterByBoolMask é o nó que queremos usar para selecionar os valores false e true. A saída “in” retorna as declarações com uma entrada “mask” com valores “true”, enquanto a saída “out” retorna as que têm valores “false”.

2. Nosso resultado de “in” é conforme esperado, e isso nos dá as duas linhas finais da estrofe.

Agora, queremos enfatizar a repetição da estrofe, mesclando as duas linhas. Quando visualizamos a saída da etapa anterior, notamos que há dois itens na lista:

1. Usando dois nós List.GetItemAtIndex, podemos isolar os itens usando os valores de 0 e 1 como entrada do índice.

2. A saída de cada nó gera, em ordem, as duas linhas finais.

Para mesclar esses dois itens em um único, usamos o nó String.Join:

1. Após adicionar o nó String.Join, notamos que precisamos de um separador.

2. Para criar o separador, adicionamos um nó String à tela e digitamos uma vírgula.

3. O resultado final mesclou os últimos dois itens em um.

Pode parecer muito trabalhoso isolar as duas últimas linhas; e é verdade, as operações de sequência de caracteres geralmente exigem algum trabalho inicial. Mas elas são escalonáveis e podem ser aplicadas a grandes conjuntos de dados com relativa facilidade. Se você estiver trabalhando parametricamente com planilhas e interoperabilidade, lembre-se de considerar as operações de sequência de caracteres.

Superfícies no Dynamo

O que é a superfície?

Usamos Superfície no modelo para representar objetos que vemos em nosso mundo tridimensional. Embora as curvas nem sempre sejam planas, ou seja, sejam tridimensionais, o espaço que elas definem estará sempre vinculado a uma cota. As superfícies proporcionam outra dimensão e um conjunto de propriedades adicionais que podemos usar em outras operações de modelagem.

Superfície no parâmetro

Importe e avalie uma superfície em um parâmetro no Dynamo para ver o tipo de informações que podemos extrair.

1. Surface.PointAtParameter retorna o ponto em uma determinada coordenada UV

2. Surface.NormalAtParameter retorna o vetor normal em uma determinada coordenada UV

3. Surface.GetIsoline retorna a curva isoparamétrica em uma coordenada U ou V: observe a entrada isoDirection.

Faça o download dos arquivos de exemplo clicando no link abaixo.

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

Análise abrangente de...

Superfície

Uma superfície é uma forma matemática definida por uma função e dois parâmetros. Em vez de t para curvas, usamos U e V para descrever o espaço de parâmetro correspondente. Isso significa que temos mais dados geométricos para desenhar ao trabalhar com este tipo de geometria. Por exemplo, as curvas apresentam vetores tangentes e planos normais (que podem ser rotacionados ou girados ao longo do comprimento da curva), enquanto as superfícies apresentam vetores normais e planos tangentes que são consistentes na sua orientação.

1. Superfície

2. Isocurva U

3. Isocurva V

4. Coordenada UV

5. Plano perpendicular

6. Vetor normal

Surface Domain: um domínio de superfície é definido como o intervalo de parâmetros (U,V) que são avaliados em um ponto tridimensional naquela superfície. O domínio em cada cota (U ou V) normalmente é descrito como dois números (U mín a U máx) e (V mín a V máx).

Embora a forma da superfície não pareça “retangular” e localmente possa haver um conjunto de isocurvas mais rígido ou mais solto, o “espaço” definido por seu domínio é sempre bidimensional. No Dynamo, as superfícies sempre são consideradas como tendo um domínio definido por um mínimo de 0,0 e um máximo de 1,0 nas direções U e V. As superfícies planas ou aparadas podem apresentar diferentes domínios.

Isocurva (ou curva isoparamétrica): uma curva definida por um valor U ou V constante na superfície e um domínio de valores para a outra direção U ou V correspondente.

Coordenada UV: o ponto no espaço de parâmetro UV definido por U, V e, às vezes, W.

Plano perpendicular: um plano que é perpendicular às Isocurvas U e V em uma determinada coordenada UV.

Vetor normal: um vetor que define a direção “para cima” em relação ao plano perpendicular.

Superfícies NURBS

As superfícies NURBS são muito similares às curvas NURBS. É possível considerar as superfícies NURBS como uma grade de curvas NURBS que estão em duas direções. A forma de uma superfície NURBS é definida por um número de pontos de controle e o grau da superfície nas direções U e V. Os mesmos algoritmos são usados para calcular a forma, as normais, as tangentes, as curvaturas e outras propriedades por meio de pontos de controle, espessuras e graus.

No caso de superfícies NURBS, há duas direções implícitas pela geometria, porque as superfícies NURBS são, independentemente da forma que vemos, grades retangulares de pontos de controle. E, embora essas direções sejam muitas vezes arbitrárias em relação ao sistema de coordenadas universal, nós as usaremos com frequência para analisar nossos modelos ou gerar outra geometria com base na superfície.

1. Grau (U,V) = (3,3)

2. Grau (U,V) = (3,1)

3. Grau (U,V) = (1,2)

4. Grau (U,V) = (1,1)

Polysurfaces

As Polysurfaces são compostas por superfícies que são unidas através de uma aresta. As Polysurfaces oferecem muito mais do que uma definição UV bidimensional, pois agora podemos percorrer as formas conectadas por meio de sua topologia.

Embora “Topologia” geralmente descreva um conceito sobre como as peças são conectadas e/ou relacionadas, a topologia no Dynamo também é um tipo de geometria. Especificamente, é uma categoria principal para Superfícies, Polysurfaces e Sólidos.

Às vezes chamada de patches, a união de superfícies dessa maneira permite criar formas mais complexas, além de definir detalhes na junção. Convenientemente, podemos aplicar uma operação de arredondamento ou chanfro às arestas de uma PolySurface.

A Lógica ou, mais especificamente, a Lógica condicional, permite especificar uma ação ou conjunto de ações com base em um teste. Após avaliar o teste, teremos um valor booleano que representa True ouFalse, que podemos usar para controlar o fluxo do programa.

Booleanos

As variáveis numéricas podem armazenar um intervalo completo de números diferentes. As variáveis booleanas somente podem armazenar dois valores referidos como True ou False, Yes ou No, 1 ou 0. Raramente usamos operações booleanas para realizar cálculos devido ao seu intervalo limitado.

Declarações condicionais

A declaração “If” é um conceito-chave em programação: “se isso for verdadeiro, aquilo acontecerá; caso contrário, outra coisa acontecerá. A ação resultante da declaração é controlada por um valor booleano. Há várias maneiras de definir uma declaração “If” no Dynamo:

Vamos examinar um breve exemplo de cada um desses três nós em ação usando a declaração condicional “Se”.

Nessa imagem, o valor booleano está definido como true, o que significa que o resultado é uma sequência de caracteres com a inscrição: “this is the result if true” (esse será o resultado se for verdadeiro). Os três nós que criam a declaração If estão funcionando de forma idêntica aqui.

Novamente, os nós estão funcionando de forma idêntica. Se o valor booleano for alterado para false, nosso resultado será o número Pi, conforme definido na declaração If original.

Exercício: Lógica e geometria

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.

Parte I: Filtrar uma lista

1. Vamos usar a lógica para separar uma lista de números em uma lista de números pares e uma lista de números ímpares.

a. Intervalo de números – adicione um intervalo de números à tela.

b. Números – adicione três nós de número à tela. O valor para cada nó de número deve ser: 0,0 para início, 10,0 para fim e 1,0 para etapa.

c. Saída – nossa saída é uma lista de 11 números que varia entre 0 e 10.

d. Módulo (%) – Intervalo de números em x e 2,0 em y. Isso calcula o resto de cada número na lista dividida por 2. A saída dessa lista fornece uma lista de valores alternados entre 0 e 1.

e. Teste de igualdade (==) – adicione um teste de igualdade à tela. Conecte a saída módulo à entrada x e 0,0 à entrada y.

f. Inspeção – a saída do teste de igualdade é uma lista de valores que alternam entre true e false. Esses são os valores usados para separar os itens na lista. 0 (ou true) representa números pares e (1 ou false) representa números ímpares.

g. List.FilterByBoolMask – esse nó filtrará os valores em duas listas diferentes com base no booleano de entrada. Conecte o intervalo de números original à entrada lista e a saída teste de igualdade à entrada máscara. A saída in representa valores true, enquanto a saída out representa valores false.

h. Inspeção – como resultado, agora temos uma lista de números pares e uma lista de números ímpares. Usamos operadores lógicos para separar as listas em padrões.

Parte II: Da lógica à geometria

Desenvolvendo a lógica estabelecida no primeiro exercício, vamos aplicar essa configuração a uma operação de modelagem.

2. Vamos passar do exercício anterior com os mesmos nós. As únicas exceções (além da alteração do formato) são:

a. Use um nó Sequência com esses valores de entrada.

b. Desconectamos a entrada da lista in em List.FilterByBoolMask. Colocaremos esses nós de lado por enquanto, mas eles serão úteis no exercício posteriormente.

3. Vamos começar criando um grupo separado de gráficos, como mostrado na imagem acima. Esse grupo de nós representa uma equação paramétrica para definir uma curva de linha. Algumas observações:

a. O primeiro Controle deslizante de número representa a frequência da onda; deve ter um mínimo de 1, um máximo de 4 e uma etapa de 0,01.

b. O segundo Controle deslizante de número representa a amplitude da onda; deve ter um mínimo de 0, um máximo de 1 e uma etapa de 0,01.

c. PolyCurve.ByPoints – se o diagrama de nós acima for copiado, o resultado será uma curva sinusoidal na viewport de Visualização do Dynamo.

Método para as entradas: use os nós de número nas propriedades mais estáticas e os controles deslizantes de número nas mais flexíveis. Queremos manter o intervalo de números original que estávamos definindo no início desta etapa. No entanto, a curva seno criada aqui deve ter alguma flexibilidade. É possível mover esses controles deslizantes para observar a curva atualizar sua frequência e amplitude.

4. Vamos pular um pouco a definição e examinar o resultado final para que possamos fazer referência ao ponto em que estamos chegando. As duas primeiras etapas são feitas separadamente. Agora queremos conectar as duas. Usaremos a curva sinusoidal base para controlar a localização dos componentes do compactador e usaremos a lógica true/false para alternar entre caixas pequenas e caixas maiores.

a. Math.RemapRange – usando a sequência de números criada na etapa 02, vamos criar uma nova série de números remapeando o intervalo. Os números originais da etapa 01 variam entre 0 e 100. Esses números variam entre 0 e 1 nas entradas newMin e newMax, respectivamente.

5. Crie um nó Curve.PointAtParameter e, em seguida, conecte a saída Math.RemapRange da etapa 04 como sua entrada de parâmetro.

Essa etapa cria pontos ao longo da curva. Remapeamos os números de 0 a 1, pois a entrada parâmetro está procurando valores nesse intervalo. Um valor de 0 representa o ponto inicial e um valor de 1 representa os pontos finais. Todos os números entre esses valores avaliam dentro do intervalo [0,1].

6. Conecte a saída de Curve.PointAtParameter a List.FilterByBoolMask para separar a lista de índices ímpares e pares.

a. List.FilterByBoolMask – conecte Curve.PointAtParameter da etapa anterior à entrada lista.

b. Inspeção – um nó de inspeção para in e um nó de inspeção para out mostram que temos duas listas que representam índices pares e ímpares. Esses pontos estão ordenados da mesma maneira na curva, o que demonstramos na próxima etapa.

7. Em seguida, vamos usar o resultado de saída de List.FilterByBoolMask na etapa 05 para gerar geometrias com tamanhos de acordo com seus índices.

Cuboid.ByLengths – recrie as conexões vistas na imagem acima para obter um compactador ao longo da curva sinusoidal. Um cuboide é apenas uma caixa aqui, e estamos definindo seu tamanho com base no ponto da curva no centro da caixa. A lógica da divisão par/ímpar agora deve estar clara no modelo.

a. Lista de cuboides em índices pares.

b. Lista de cuboides em índices ímpares.

Pronto. Você acabou de programar um processo de definição das cotas de geometria de acordo com a operação lógica demonstrada neste exercício.

Os dados são a matéria dos nossos programas. Eles percorrem os fios, fornecendo entradas para os nós onde são processados em uma nova forma de dados de saída. Vamos revisar a definição de dados, como eles são estruturados e começar a usá-los no Dynamo.

O que são os dados?

Os dados são um conjunto de valores de variáveis qualitativas ou quantitativas. A forma mais simples de dados são os números como 0, 3.14 ou 17. Mas os dados também podem ser de diferentes tipos: uma variável representando a alteração de números (height); caracteres (myName); geometria (Circle); ou uma lista de itens de dados (1,2,3,5,8,13,...).

No Dynamo, adicionamos dados às portas de entrada dos nós. Podemos ter dados sem ações, mas precisamos de dados para processar as ações que nossos nós representam. Quando adicionamos um nó ao espaço de trabalho, se ele não tiver nenhuma entrada fornecida, o resultado será uma função, e não o resultado da própria ação.

1. Dados simples

2. Dados e ações (nó A) executados com êxito

3. A ação (nó A) sem entradas de dados retorna uma função genérica

Null – Ausência de dados

Cuidado com os nós Nulls O tipo 'null' representa a ausência de dados. Embora seja um conceito abstrato, provavelmente ele aparecerá ao trabalhar com a programação visual. Se uma ação não criar um resultado válido, o nó retornará nulo.

Testar para verificar se existem nulos e a sua remoção da estrutura de dados é uma parte crucial para criar programas robustos.

Estruturas de dados

Quando estamos fazendo a programação visual, podemos gerar muitos dados muito rapidamente e necessitar de um meio para gerenciar sua hierarquia. Essa é a função das estruturas de dados, os esquemas organizacionais nos quais armazenamos dados. As especificidades das estruturas de dados e de como usá-las variam conforme a linguagem de programação usada.

No Dynamo, adicionamos hierarquia aos nossos dados através das listas. Vamos explorar isso em profundidade em capítulos posteriores. Para já, vamos começar de forma simples:

Uma lista representa um conjunto de itens colocados em uma estrutura de dados:

• Tenho cinco dedos (itens) na minha mão (lista).

• Há dez casas (itens) na minha rua (lista).

1. Um nó Sequência de números define uma lista de números usando as entradas início, quantidade e etapa. Com esses nós, criamos duas listas separadas de dez números, uma que vai de 100 a 109 e outra que vai de 0 a 9.

2. O nó List.GetItemAtIndex seleciona um item de uma lista em um índice específico. Escolhendo 0, obtemos o primeiro item da lista (100 neste caso).

3. Aplicando o mesmo processo à segunda lista, obtemos um valor de 0, o primeiro item da lista.

4. Agora, mesclamos as duas listas em uma usando o nó List.Create. Observe que o nó cria uma lista de listas. Isso altera a estrutura dos dados.

5. Usando List.GetItemAtIndex novamente, com o índice definido como 0, obtemos a primeira lista na lista de listas. Isso é o que significa tratar uma lista como um item, o que é um pouco diferente de outras linguagens de script. Nos capítulos posteriores, aprofundaremos mais nos temas de manipulação de listas e estrutura de dados.

O conceito-chave para entender a hierarquia dos dados no Dynamo: em relação à estrutura de dados, as listas são consideradas itens. Ou seja, o Dynamo funciona com um processo descendente para compreender as estruturas dos dados. O que isso significa? Vamos analisar isso com um exemplo.

Exercício: Usar dados para criar uma cadeia de cilindros

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 primeiro exemplo, montamos um cilindro com camadas que percorre a hierarquia da geometria discutida nesta seção.

Parte I: Configurar o gráfico para um cilindro com alguns parâmetros alteráveis.

1. Adicionar Point.ByCoordinates – após adicionarmos o nó à tela, vemos um ponto na origem da grade de visualização do Dynamo. Os valores padrão das entradas x,y e z são 0,0, especificando um ponto nesse local.

2. Plane.ByOriginNormal – a próxima etapa na hierarquia da geometria é o plano. Existem diversas maneiras de construir um plano, e estamos usando uma origem e um normal para a entrada. A origem é o nó de ponto criado na etapa anterior.

Vector.ZAxis – esse é um vetor unificado na direção z. Observe que não há entradas, somente um vetor de valor [0,0,1]. Usamos isso como a entrada normal para o nó Plane.ByOriginNormal. Isso nos fornece um plano retangular na visualização do Dynamo.

3. Circle.ByPlaneRadius – subindo na hierarquia, agora criamos uma curva com base no plano da etapa anterior. Após a conexão ao nó, obtemos um círculo na origem. O raio padrão no nó é o valor de 1.

4. Curve.Extrude – agora vamos fazer isso surgir fornecendo alguma profundidade e entrando na terceira dimensão. Esse nó cria uma superfície com base na curva por meio de extrusão. A distância padrão no nó é 1 e devemos ver um cilindro na viewport.

5. Surface.Thicken – esse nó fornece um sólido fechado deslocando a superfície por uma determinada distância e fechando a forma. O valor padrão da espessura é 1 e vemos um cilindro com camadas na viewport em linha com esses valores.

6. Controle deslizante de número – em vez de usar os valores padrão para todas essas entradas, vamos adicionar um controle paramétrico ao modelo.

Edição de domínio – após adicionar o controle deslizante de número à tela, clique no acento circunflexo no canto superior esquerdo para exibir as opções de domínio.

Mín/Máx/Etapa – altere os valores mín, máx e etapa para 0,2 e 0,01 respectivamente. Estamos fazendo isso para controlar o tamanho da geometria geral.

7. Controles deslizantes de número – em todas as entradas padrão, vamos copiar e colar esse controle deslizante de número (selecione o controle deslizante, pressione Ctrl+C e, em seguida, Ctrl+V) diversas vezes, até que todas as entradas com padrões tenham um controle deslizante. Alguns dos valores do controle deslizante terão que ser maiores que zero para que a definição funcione (isto é, você precisa de uma profundidade de extrusão para que uma superfície se torne mais espessa).

8. Acabamos de criar um cilindro paramétrico com camadas com esses controles deslizantes. Tente flexibilizar alguns desses parâmetros e veja a atualização da geometria dinamicamente na viewport do Dynamo.

Controles deslizantes de número – aprofundando isso um pouco mais, adicionamos muitos controles deslizantes à tela e precisamos limpar a interface da ferramenta que acabamos de criar. Clique com o botão direito do mouse em um controle deslizante, selecione “Renomear...” e altere cada controle deslizante com o nome apropriado para seu parâmetro (espessura, raio, altura etc.).

Parte II: Preencher uma matriz de cilindros com base na Parte I

9. Acabamos de criar um item incrível de cilindro que aumenta de espessura. Esse é um objeto atualmente, vamos analisar como criar uma matriz de cilindros que permanece vinculada de forma dinâmica. Para fazer isso, criaremos uma lista de cilindros, em vez de trabalhar com um único item.

Adição (+) – nosso objetivo é adicionar uma linha de cilindros ao lado do cilindro que criamos. Se desejarmos adicionar um cilindro adjacente ao atual, precisaremos considerar o raio do cilindro e a espessura de sua camada. Obtemos esse número adicionando os dois valores dos controles deslizantes.

10. Essa etapa é mais complicada, portanto, vamos explicá-la devagar: o objetivo final é criar uma lista de números que definem as localizações de cada cilindro em uma linha.

a. Multiplicação ð primeiro, desejamos multiplicar o valor da etapa anterior por 2. O valor da etapa anterior representa um raio e desejamos mover o cilindro ao longo de todo o diâmetro.

b. Sequência de números – criamos uma matriz de números com esse nó. A primeira entrada é o nó_multiplicação_ da etapa anterior para o valor etapa. É possível definir o valor inicial como 0,0 usando um nó de número.

c. Controle deslizante de número inteiro – para o valor quantidade, conectamos um controle deslizante de número inteiro. Isso definirá quantos cilindros são criados.

d. Saída – essa lista mostra a distância de movimentação de cada cilindro na matriz, e é orientada parametricamente pelos controles deslizantes originais.

11. Essa etapa é muito simples: conecte a sequência definida na etapa anterior à entrada x do Point.ByCoordinates original. Isso substituirá o controle deslizante pointX, que pode ser excluído. Agora, vemos uma matriz de cilindros na viewport (certifique-se de que o controle deslizante de número inteiro seja maior que 0).

12. A cadeia de cilindros ainda está dinamicamente vinculada a todos os controles deslizantes. Flexibilize cada controle deslizante para assistir à atualização da definição.

Malha no Dynamo

O que é a malha?

No campo da modelagem de cálculo, as malhas são uma das formas mais difundidas de representar a geometria 3D. A geometria de malha é geralmente feita com um conjunto de quadriláteros ou triângulos, pode ser uma alternativa leve e flexível para trabalhar com NURBS. As malhas são usadas em tudo, desde renderização e visualizações até fabricação digital e impressão 3D.

Elementos de malha

O Dynamo define malhas usando uma estrutura de dados Face-Vértice. Em seu nível mais básico, esta estrutura é simplesmente uma coleção de pontos que são agrupados em polígonos. Os pontos de uma malha são chamados de vértices, enquanto os polígonos como a superfície são chamados de faces.

Para criar uma malha, precisamos de uma lista de vértices e um sistema de agrupamento desses vértices em faces, o que é denominado grupo de índice.

1. Lista de vértices

2. Lista de grupos de índice para definir faces

Kit de ferramentas de malha

Os recursos de malha do Dynamo podem ser estendidos instalando o pacote Kit de ferramentas de malha. O Kit de ferramentas de malha do Dynamo fornece ferramentas para importar malhas de formatos de arquivo externo, criar uma malha de objetos de geometria do Dynamo e criar manualmente malhas de acordo com seus vértices e índices.

A biblioteca também fornece ferramentas para modificar malhas, reparar malhas ou extrair fatias horizontais para uso na fabricação.

Consulte Estudos de caso do kit de ferramentas de malha, por exemplo, para saber como usar esse pacote.

Análise abrangente de...

Malha

Uma Malha é uma coleção de quadriláteros e triângulos que representam uma geometria de superfície ou sólido. Como os sólidos, a estrutura de um objeto de malha inclui vértices, arestas e faces. Há propriedades adicionais que também tornam as Malhas exclusivas, como as normais.

1. Vértices de malha

2. Arestas de malha *Arestas com apenas uma face adjacente são chamadas "Naked". Todas as outras arestas são "Clothed"

3. Faces de malha

Vértices + normais de vértice

Os vértices de uma malha são simplesmente uma lista de pontos. O índice dos vértices é muito importante ao construir uma malha ou obter informações sobre a estrutura de uma malha. Para cada vértice, há também uma normal de vértice correspondente (vetor) que descreve a direção média das faces anexadas e nos ajuda a compreender a orientação “dentro” e “fora” da malha.

1. Vértices

2. Normais de vértice

Faces

Uma face é uma lista ordenada de três ou quatro vértices. A representação "superfície" de uma face de malha, portanto, é implícita de acordo com a posição dos vértices que estão sendo indexados. Já temos a lista de vértices que compõem a malha, por isso, em vez de fornecer pontos individuais para definir uma face, basta usar o índice dos vértices. Isso também nos permite usar o mesmo vértice em mais de uma face.

1. Uma face de quadrados feita com índices 0, 1, 2 e 3

2. Uma face de triângulo feita com índices 1, 4 e 2. Observe que os grupos de índice podem ser deslocados em sua ordem, desde que a sequência seja ordenada de forma anti-horária, a face será definida corretamente

Malhas versus superfícies NURBS

Como a geometria de malha é diferente da geometria NURBS? Em que casos é recomendado utilizar um e não o outro?

Parametrização

Em um capítulo anterior, vimos que as superfícies NURBS são definidas por uma série de curvas NURBS seguindo em duas direções. Essas direções são legendadas como U eV, e permitem que uma superfície NURBs seja parametrizada de acordo com um domínio de superfície bidimensional. As curvas em si são armazenadas como equações no computador, permitindo que as superfícies resultantes sejam calculadas para um grau arbitrariamente pequeno de precisão. No entanto, pode ser difícil combinar várias superfícies NURBS juntas. A união de duas superfícies NURBS resultará em uma polysurface, onde diferentes seções da geometria terão diferentes parâmetros UV e definições de curva.

1. Superfície

2. Curva isoparamétrica (Isoparm)

3. Ponto de controle de superfície

4. Polígono de controle de superfície

5. Ponto isoparamétrico

6. Estrutura da superfície

7. Malha

8. Aresta consolidada

9. Rede de malha

10. Arestas de malha

11. Normal de vértice

12. Face de malha/normal de face de malha

As malhas, por outro lado, são compostas de um número discreto de vértices e faces exatamente definidos. A rede de vértices geralmente não pode ser definida por coordenadas simples UV e, como as faces são separadas, a quantidade de precisão é incorporada à malha e só pode ser alterada refinando a malha e adicionando mais faces. A falta de descrições matemáticas permite que as malhas manipulem com mais flexibilidade a geometria complexa em uma única malha.

Influência local versus global

Outra diferença importante é a extensão para a qual uma alteração local na geometria de Malha ou NURBS afeta toda a forma. Mover um vértice de uma malha somente afeta as faces que são adjacentes a esse vértice. Em superfícies NURBS, a extensão da influência é mais complicada e depende do grau da superfície, bem como dos pesos e nós dos pontos de controle. Em geral, no entanto, mover um único ponto de controle em uma superfície NURBS cria uma alteração mais suave e mais extensa na geometria.

1. Superfície NURBS: mover um ponto de controle tem influência que se estende através da forma

2. Geometria de malha: mover um vértice tem influência somente em elementos adjacentes

Uma analogia que pode ser útil é para comparar uma imagem vetorial (composta de linhas e curvas) com uma imagem raster (composta de pixels individuais). Se você aproximar o zoom em uma imagem de vetor, as curvas permanecem definidas e claras, ao efetuar o zoom em uma imagem raster resulta em uma vista em que os pixels individuais se tornam maiores. Nesta analogia, as superfícies NURBS podem ser comparadas a uma imagem vetorial porque há uma relação matemática suave, enquanto uma malha se comporta de forma similar a uma imagem raster com uma resolução definida.

Sólidos no Dynamo

O que é um sólido?

Se quisermos criar modelos mais complexos que não possam ser criados com base em uma única superfície ou se desejarmos definir um volume explícito, agora precisaremos nos aventurar no domínio dos sólidos (e das Polysurfaces). Até mesmo um cubo simples é suficientemente complexo para precisar de seis superfícies, uma por face. Os sólidos dão acesso a dois conceitos-chave que as superfícies não têm: uma descrição topológica mais refinada (faces, arestas, vértices) e operações booleanas.

Operação booleana para criar um sólido esférico pontiagudo

É possível usar operações booleanas para modificar os sólidos. Vamos usar algumas operações booleanas para criar uma bola pontiaguda.

1. Sphere.ByCenterPointRadius: crie o sólido da base.

2. Topology.Faces, Face.SurfaceGeometry: consulte as faces do sólido e converta-as em geometria da superfície. Neste caso, a esfera tem apenas uma face.

3. Cone.ByPointsRadii: crie cones usando pontos na superfície.

4. Solid.UnionAll: una os cones e a esfera.

5. Topology.Edges: consulte as arestas do novo sólido

6. Solid.Fillet: arredonde as arestas da esfera pontiaguda

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.

Congelar

As operações booleanas são complexas e seu cálculo pode ser lento. É possível usar a funcionalidade “congelar” para suspender a execução dos nós selecionados e dos nós a jusante afetados.

1. Use o menu de contexto do botão direito do mouse para congelar a operação de União de sólidos

2. O nó selecionado e todos os nós a jusante serão visualizados em um modo duplicado cinza claro, e os fios afetados serão exibidos como linhas tracejadas. A visualização da geometria afetada também será duplicada. Agora é possível alterar os valores anteriores sem calcular a união booleana.

3. Para descongelar os nós, clique com o botão direito do mouse e desmarque Congelar.

4. Todos os nós afetados e as visualizações de geometria associadas serão atualizados e revertidos para o modo de visualização padrão.

Análise abrangente de...

Sólidos

Os sólidos consistem em uma ou mais superfícies que contêm volume por meio de um limite fechado que define a “entrada” ou a “saída”. Independentemente de quantas superfícies existem, elas devem formar um volume “hermético” para serem consideradas como um sólido. Os sólidos podem ser criados unindo superfícies ou Polysurfaces ou usando operações como elevação, varredura e revolução. As primitivas Esfera, Cubo, Cone e Cilindro também são sólidos. Um cubo com, pelo menos, uma face removida conta como uma Polysurface, que tem algumas propriedades similares, mas não é um sólido.

1. Um plano é composto por uma única superfície e não é um sólido.

2. Uma esfera é composta por uma superfície, mas é um sólido.

3. Um cone é composto por duas superfícies unidas para criar um sólido.

4. Um cilindro é composto por três superfícies unidas para criar um sólido.

5. Um cubo é composto de seis superfícies unidas para criar um sólido.

Topologia

Os sólidos são compostos de três tipos de elementos: vértices, arestas e faces. As faces são as superfícies que compõem o sólido. As arestas são as curvas que definem a conexão entre as faces adjacentes e os vértices são os pontos inicial e final dessas curvas. É possível consultar esses elementos usando os nós de topologia.

1. Faces

2. Arestas

3. Vértices

Operações

É possível modificar os sólidos arredondando ou chanfrando suas bordas para eliminar os cantos e os ângulos agudos. A operação de chanfro cria uma superfície regular entre duas faces, enquanto o arredondamento é mesclado entre as faces para manter a tangência.

1. Cubo sólido

2. Cubo chanfrado

3. Cubo arredondado

Operações booleanas

As operações booleanas de sólidos são métodos para combinar dois ou mais sólidos. Uma única operação booleana significa realizar quatro operações:

1. Fazer interseção de dois ou mais objetos.

2. Dividir os objetos nas interseções.

3. Excluir as partes indesejadas da geometria.

4. Unir tudo novamente.

1. União: remove as partes sobrepostas dos sólidos e une-as em um único sólido.

2. Diferença: subtrai um sólido de outro. O sólido a ser subtraído é chamado de ferramenta. Observe que é possível alternar qual sólido é a ferramenta para manter o volume inverso.

3. Interseção: mantém somente o volume de interseção dos dois sólidos.

1. UnionAll: operação de união com esfera e cones virados para fora

2. DifferenceAll: operação de diferença com esfera e cones virados para dentro

O que é uma lista?

Uma lista é uma coleção de elementos ou de itens. Por exemplo, uma penca de bananas. Cada banana é um item na lista (ou penca). É mais fácil pegar uma penca de bananas em vez de cada banana individualmente, e o mesmo vale para agrupar elementos por relações paramétricas em uma estrutura de dados.

Foto de Augustus Binu.

Quando fazemos compras, colocamos todos os itens comprados em uma sacola. Essa sacola também é uma lista. Para fazer pão de banana, precisaremos de três pencas de bananas (vamos fazer muito pão de banana). O saco representa uma lista de pencas de bananas e cada penca representa uma lista de bananas. O saco é uma lista de listas (bidimensionais) e a penca de bananas é uma lista (unidimensional).

No Dynamo, os dados da lista são ordenados e o primeiro item em cada lista tem um índice “0”. Abaixo, vamos discutir como as listas são definidas no Dynamo e como várias listas se relacionam entre si.

Índices com base em zero

Uma coisa que pode parecer estranha no início é que o primeiro índice de uma lista é sempre 0; não 1. Portanto, quando falamos sobre o primeiro item de uma lista, na verdade, queremos dizer o item que corresponde ao índice 0.

Por exemplo, se você contasse o número de dedos que temos na mão direita, as chances são de que você teria contado de 1 a 5. No entanto, se você colocar seus dedos em uma lista, o Dynamo teria dado índices de 0 a 4. Embora isso possa parecer um pouco estranho para programadores iniciantes, o índice com base em zero é uma prática padrão na maioria dos sistemas de cálculo.

Observe que ainda temos cinco itens na lista; é apenas que a lista está usando um sistema de contagem baseado em zero. E os itens que estão sendo armazenados na lista não precisam ser apenas números. Eles podem ser qualquer tipo de dados que o Dynamo suporta, como pontos, curvas, superfícies, famílias etc.

a. Índice

b. Ponto

c. Item

Muitas vezes, a maneira mais fácil de analisar o tipo de dados armazenados em uma lista é conectar um nó de inspeção à saída de outro nó. Por padrão, o nó de inspeção exibe automaticamente todos os índices no lado esquerdo da lista e exibe os itens de dados na direita.

Esses índices são um elemento crucial ao trabalhar com listas.

Entradas e saídas

Nas listas, as entradas e as saídas variam de acordo com o nó do Dynamo que está sendo usado. Como exemplo, vamos usar uma lista de cinco pontos e conectar essa saída a dois nós diferentes do Dynamo: PolyCurve.ByPoints e Circle.ByCenterPointRadius:

1. A entrada pontos para PolyCurve.ByPoints está procurando “Point[]”. Isso representa uma lista de pontos

2. A saída para PolyCurve.ByPoints é uma policurva única criada com base em uma lista de cinco pontos.

3. A entrada centerPoint para Circle.ByCenterPointRadius solicita “Ponto”.

4. A saída para Circle.ByCenterPointRadius é uma lista de cinco círculos, cujos centros correspondem à lista original de pontos.

Os dados de entrada para PolyCurve.ByPoints e Circle.ByCenterPointRadius são os mesmos. No entanto, o nó Polycurve.ByPoints gera uma policurva, enquanto o nó Circle.ByCenterPointRadius gera cinco círculos com centros em cada ponto. Isso faz sentido intuitivamente: a policurva é desenhada como uma curva que conecta os cinco os pontos, enquanto os círculos criam um círculo diferente em cada ponto. O que está acontecendo com os dados?

Passando o cursor do mouse sobre a entrada pontos para Polycurve.ByPoints, vemos que a entrada está procurando “Point[]”. Observe os colchetes no final. Isso representa uma lista de pontos e, para criar uma policurva, a entrada precisa ser uma lista para cada policurva. Esse nó, portanto, condensará cada lista em uma policurva.

Por outro lado, a entrada centerPoint para Circle.ByCenterPointRadius solicita “Ponto”. Esse nó procura um ponto, como um item, para definir o ponto central do círculo. É por isso que obtemos cinco círculos com base nos dados de entrada. Reconhecer essa diferença com as entradas no Dynamo ajuda a compreender melhor como os nós funcionam ao gerenciar os dados.

Amarra

A correspondência de dados é um problema sem uma solução fácil. Isso ocorre quando um nó tem acesso a entradas de tamanhos diferentes. Alterar o algoritmo de correspondência de dados pode gerar resultados muito diferentes.

Imagine um nó que cria segmentos de linha entre pontos (Line.ByStartPointEndPoint). Ele terá dois parâmetros de entrada que fornecem as coordenadas dos pontos:

Lista mais curta

A maneira mais simples é conectar as entradas individualmente até que um dos fluxos se esgote. Isso é denominado algoritmo “Lista mais curta”. Este é o comportamento padrão dos nós do Dynamo:

Lista mais longa

O algoritmo “Lista mais longa” continua conectando entradas, reusando elementos, até que todos os fluxos se esgotem:

Produto transversal

Por fim, o método “Produto transversal” torna todas as conexões possíveis:

Como você pode ver, há diferentes maneiras de desenhar linhas entre estes conjuntos de pontos. É possível encontrar as opções de amarra clicando com o botão direito do mouse no centro de um nó e selecionando o menu “Amarra”.

Exercício

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 demonstrar as operações de amarra abaixo, vamos usar esse arquivo base para definir a lista mais curta, a lista mais longa e o produto transversal.

Vamos alterar a amarra em Point.ByCoordinates, mas não alteraremos mais nada no gráfico acima.

Lista mais curta

Escolhendo lista mais curta como a opção de amarra (também é a opção padrão), obtemos uma linha diagonal básica composta por cinco pontos. Cinco pontos são o comprimento da lista menor; portanto, a amarra da lista mais curta é interrompida após atingir o final de uma lista.

Lista mais longa

Alterando a amarra para lista mais longa, obtemos uma linha diagonal que se estende verticalmente. Pelo mesmo método que o diagrama conceitual, o último item na lista de cinco itens será repetido para alcançar o comprimento da lista mais longa.

Produto transversal

Alterando a amarra para Produto transversal, temos todas as combinações entre cada lista, dando-nos uma grade de pontos 5 x 10. Essa é uma estrutura de dados equivalente ao produto transversal, como mostrado no diagrama conceitual acima, exceto pelo fato de que nossos dados agora são uma lista de listas. Conectando uma policurva, podemos ver que cada lista é definida pelo seu valor X, dando-nos uma linha de linhas verticais.

Em um passo mais avançado, vamos adicionar ainda mais camadas à hierarquia. A estrutura de dados pode se expandir muito além de uma lista bidimensional de listas. Como as listas são itens por si só no Dynamo, podemos criar dados com tantas dimensões quanto possível.

A analogia com a qual vamos trabalhar aqui são as bonecas russas. Cada lista pode ser considerada como um contêiner com vários itens. Cada lista tem suas próprias propriedades e também é considerada como seu próprio objeto.

Um conjunto de bonecas russas (Foto de Zeta) é uma analogia das Listas n-dimensionais. Cada camada representa uma lista e cada lista contém itens. No caso do Dynamo, cada contêiner pode ter vários contêineres dentro (representando os itens de cada lista).

As listas n-dimensionais são difíceis de explicar visualmente, mas criamos alguns exercícios neste capítulo, focados no trabalho com listas que vão além de duas dimensões.

Mapeamento e combinações

O mapeamento é, sem dúvida, a parte mais complexa do gerenciamento de dados no Dynamo e é especialmente relevante ao trabalhar com hierarquias complexas de listas. Com a série de exercícios abaixo, vamos demonstrar quando usar o mapeamento e as combinações, à medida que os dados se tornam multidimensionais.

A introdução inicial a List.Map e List.Combine pode ser encontrada na seção anterior. No último exercício abaixo, vamos usar esses nós em uma estrutura de dados complexa.

Exercício – Listas 2D – Básico

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 é o primeiro de uma série de três focado na articulação da geometria importada. Cada parte desta série de exercícios aumenta a complexidade da estrutura de dados.

1. Vamos começar com o arquivo .sat na pasta de arquivos de exercícios. É possível selecionar esse arquivo usando o nó Caminho do arquivo.

2. Com Geometry.ImportFromSAT, a geometria é importada para nossa visualização do Dynamo como duas superfícies.

Neste exercício, queremos mantê-la simples e trabalhar com uma das superfícies.

1. Vamos selecionar o índice de 1 para selecionar a superfície superior. Isso é feito com o nó List.GetItemAtIndex.

2. Desative a visualização da geometria da visualização de Geometry.ImportFromSAT.

A próxima etapa é dividir a superfície em um eixo de pontos.

1. Usando o Bloco de código, insira estas duas linhas de código: 0..1..#10; 0..1..#5;

2. Com Surface.PointAtParameter, conecte os dois valores do bloco de código a u e v. Altere a amarra desse nó para “Produto transversal”.

3. A saída exibe a estrutura de dados, que também está visível na visualização do Dynamo.

Em seguida, usamos os Pontos da última etapa para gerar dez curvas ao longo da superfície.

1. Para obter uma visão de como a estrutura de dados está organizada, vamos conectar NurbsCurve.ByPoints à saída de Surface.PointAtParameter.

2. Você pode desativar a visualização do nó List.GetItemAtIndex por enquanto para obter um resultado mais claro.

1. Um List.Transpose básico inverterá as colunas e as linhas de uma lista de listas.

2. Conectando a saída de List.Transpose a NurbsCurve.ByPoints, agora obtemos cinco curvas sendo executadas horizontalmente na superfície.

3. Você pode desativar a visualização do nó NurbsCurve.ByPoints na etapa anterior para obter o mesmo resultado na imagem.

Exercício – Listas 2D – Avançado

Vamos aumentar a complexidade. Suponha que desejamos executar uma operação nas curvas criadas no exercício anterior. Talvez desejemos relacionar essas curvas com outra superfície e fazer a transição entre elas. Isso requer mais atenção à estrutura de dados, mas a lógica é a mesma.

1. Comece com uma etapa do exercício anterior, isolando a superfície superior da geometria importada com o nó List.GetItemAtIndex.

1. Usando Surface.Offset, desloque a superfície por um valor de 10.

1. Da mesma forma que no exercício anterior, defina um bloco de código com estas duas linhas de código: 0..1..#10; 0..1..#5;

2. Conecte essas saídas aos dois nós Surface.PointAtParameter, cada um com a amarra definida como “Produto transversal”. Um desses nós está conectado à superfície original, enquanto o outro está conectado à superfície de deslocamento.

1. Desative a visualização dessas superfícies.

2. Como no exercício anterior, conecte as saídas aos dois nós NurbsCurve.ByPoints. O resultado mostra curvas correspondentes às duas superfícies.

1. Usando List.Create, é possível combinar os dois conjuntos de curvas em uma lista de listas.

2. Observe que, na saída, temos duas listas com dez itens em cada uma, representando cada conjunto de conexão de curvas Nurbs.

3. Executando o nó Surface.ByLoft, podemos entender visualmente essa estrutura de dados. O nó efetua a transição de todas as curvas em cada sublista.

1. Desative a visualização do nó Surface.ByLoft na etapa anterior.

2. Se List.Transpose for usado, lembre-se de que estamos invertendo todas as colunas e linhas. Esse nó transferirá duas listas de dez curvas em dez listas de duas curvas. Agora, temos cada curva Nurbs relacionada à curva vizinha na outra superfície.

3. Usando Surface.ByLoft, chegamos a uma estrutura nervurada.

Em seguida, demonstraremos um processo alternativo para alcançar esse resultado

1. Antes de começarmos, desative a visualização de Surface.ByLoft na etapa anterior para evitar confusão.

2. Uma alternativa para List.Transpose é usar List.Combine. Isso executará um “combinador” em cada sublista.

3. Neste caso, estamos usando List.Create como o “combinador”, o que criará uma lista de cada item nas sublistas.

4. Usando o nó Surface.ByLoft, obtemos as mesmas superfícies que as da etapa anterior. A transposição é mais fácil de usar nesse caso, mas quando a estrutura de dados se torna ainda mais complexa, List.Combine é mais confiável.

1. Retrocedendo algumas etapas, se quisermos alternar a orientação das curvas na estrutura nervurada, deveremos usar List.Transpose antes de conectar a NurbsCurve.ByPoints. Isso inverterá as colunas e linhas, resultando em cinco nervuras horizontais.

Exercício – Listas 3D

Agora, vamos um pouco mais longe. Neste exercício, vamos trabalhar com as duas superfícies importadas, criando uma hierarquia de dados complexa. Ainda assim, nosso objetivo é concluir a mesma operação com a mesma lógica subjacente.

Comece com o arquivo importado do exercício anterior.

1. Como no exercício anterior, use o nó Surface.Offset para deslocar por um valor de 10.

2. Observe, na saída, que criamos duas superfícies com o nó de deslocamento.

1. Da mesma forma que no exercício anterior, defina um Bloco de código com estas duas linhas de código: 0..1..#20; 0..1..#20;

2. Conecte essas saídas aos dois nós Surface.PointAtParameter, cada um com a amarra definida como “Produto transversal”. Um desses nós está conectado às superfícies originais, enquanto o outro está conectado às superfícies de deslocamento.

1. Como no exercício anterior, conecte as saídas aos dois nós NurbsCurve.ByPoints.

2. Observando a saída de NurbsCurve.ByPoints,, é possível ver que esta é uma lista de duas listas, que é mais complexa do que no exercício anterior. Os dados são categorizados pela superfície subjacente; portanto, adicionamos outro nível aos dados estruturados.

3. Observe que as coisas se tornam mais complexas no nó Surface.PointAtParameter. Neste caso, temos uma lista de listas de listas.

1. Antes de prosseguir, desative a visualização das superfícies existentes.

2. Usando o nó List.Create, mesclamos as curvas Nurbs em uma estrutura de dados, criando uma lista de listas de listas.

3. Conectando um nó Surface.ByLoft, obtemos uma versão das superfícies originais, pois cada uma delas permanece em sua própria lista, conforme foram criadas com base na estrutura de dados original.

1. No exercício anterior, usamos List.Transpose para criar uma estrutura nervurada. Isso não funcionará aqui. A transposição deve ser usada em uma lista bidimensional e, como nós temos uma lista tridimensional, uma operação de “inverter colunas e linhas” não funcionará tão facilmente. Lembre-se de que as listas são objetos; portanto, List.Transpose inverterá nossas listas com as sublistas, mas não inverterá as curvas Nurbs uma lista mais abaixo na hierarquia.

1. List.Combine funcionará melhor neste caso. Devemos usar os nós List.Map e List.Combine quando chegarmos a estruturas de dados mais complexas.

2. Usando List.Create como o “combinador”, criamos uma estrutura de dados que funcionará melhor.

1. A estrutura de dados ainda precisa ser transposta uma etapa abaixo na hierarquia. Para fazer isso, vamos usar List.Map. Isso funciona como List.Combine, mas com uma lista de entrada, em vez de duas ou mais.

2. A função que será aplicada a List.Map é List.Transpose, que inverterá as colunas e as linhas das sublistas em nossa lista principal.

1. Finalmente, podemos fazer a transição entre as curvas Nurbs junto com uma hierarquia de dados adequada, gerando uma estrutura nervurada.

1. Vamos adicionar alguma profundidade à geometria com um nó Surface.Thicken, com as configurações de entrada conforme mostrado.

1. É recomendado adicionar uma superfície de apoio a duas estruturas; portanto, adicione outro nó Surface.ByLoft e use a primeira saída de NurbsCurve.ByPoints de uma etapa anterior como entrada.

2. À medida que a visualização for ficando confusa, desative a visualização desses nós clicando com o botão direito do mouse em cada um deles e desmarque a opção “Visualização” para ver melhor o resultado.

1. Depois de tornarmos mais espessas essas superfícies selecionadas, nossa articulação estará completa.

Não é a cadeira de balanço mais confortável de todos os tempos, mas há muitos dados em jogo.

Última etapa: vamos inverter a direção dos membros com listras. Como usamos a função de transposição no exercício anterior, faremos algo semelhante aqui.

1. Como temos mais um nível para a hierarquia, vamos precisar usar List.Map com uma função de List.Tranpose para alterar a direção das curvas Nurbs.

1. Podemos querer aumentar o número de degraus, então podemos alterar o Bloco de código para 0..1..#20; 0..1..#30;

Como a primeira versão da cadeira de balanço era elegante, nosso segundo modelo oferece uma versão alternativa, de utilidade esportiva para descanso dorsal.

As listas são a forma como organizamos os dados. No sistema operacional do computador, você tem arquivos e pastas. No Dynamo, podemos considerá-las como itens e listas, respectivamente. Como no sistema operacional, há muitas formas de criar, modificar e consultar os dados. Neste capítulo, veremos como as listas são gerenciadas no Dynamo.

O Dynamo 2.0 expõe uma variedade de nós de dicionário para serem usados. Isso inclui os nós criar, ação e consulta.

Criar

1. Dictionary.ByKeysValues criará um dicionário com os valores e chaves fornecidos. (O número de entradas será o da lista de entradas mais curta)

Ação

1. Dictionary.Components produzirá os componentes do dicionário de entrada. (Isso é o inverso do nó criar)

2. Dictionary.RemoveKeys produzirá um novo objeto de dicionário com as chaves de entrada removidas.

3. Dictionary.SetValueAtKeys produzirá um novo dicionário com base nas chaves de entrada e nos valores para substituir o valor atual nas chaves correspondentes.

4. Dictionary.ValueAtKey retornará o valor na chave de entrada.

Contagem

1. Dictionary.Count informará quantos pares de valores-chave estão no dicionário.

2. Dictionary.Keys retornará quais chaves estão atualmente armazenadas no dicionário.

3. Dictionary.Values retornará quais valores estão armazenados no momento no dicionário.

A relação global de dados com dicionários é uma ótima alternativa ao método antigo de trabalho com índices e listas.

Trabalhar com listas

Agora que estabelecemos o que é uma lista, vamos falar sobre as operações que podemos realizar nela. Imagine uma lista como um baralho de cartas. O baralho é a lista e cada carta representa um item.

Consulta

Quais consultas podemos fazer na lista? Isso acessa as propriedades existentes.

• Número de cartas no baralho? 52.

• Número de naipes? 4.

• Material? Papel.

• Comprimento? 3,5 pol. ou 89 mm.

• Largura? 2,5 pol. ou 64 mm.

Ação

Quais ações podemos executar na lista? Isso altera a lista com base em uma determinada operação.

• Podemos embaralhar as cartas.

• Podemos classificar as cartas por valor.

• Podemos classificar as cartas por naipe.

• Podemos dividir o baralho.

• Podemos dividir o baralho, distribuindo cada uma das mãos da rodada.

• É possível selecionar uma carta específica no baralho.

Todas as operações listadas acima têm nós análogos do Dynamo para trabalhar com listas de dados genéricos. As lições abaixo demonstrarão algumas das operações fundamentais que podemos executar nas listas.

Exercício

Operações de lista

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.

A imagem abaixo é o gráfico de base no qual estamos desenhando linhas entre dois círculos para representar operações básicas de lista. Vamos explorar como gerenciar dados em uma lista e demonstrar os resultados visuais através das ações da lista abaixo.

1. Comece com um Bloco de código com um valor de 500;

2. Conecte-se à entrada x de um nó Point.ByCoordinates.

3. Conecte o nó da etapa anterior à entrada de origem de um nó Plane.ByOriginNormal.

4. Usando um nó Circle.ByPlaneRadius, conecte o nó da etapa anterior à entrada do plano.

5. Usando o Bloco de código, designe um valor de 50; para o raio. Esse é o primeiro círculo que criaremos.

6. Com um nó Geometry.Translate, movimente o círculo 100 unidades para cima na direção Z.

7. Com um nó de Bloco de código, defina um intervalo de dez números entre 0 e 1 com esta linha de código: 0..1..#10;

8. Conecte o bloco de código da etapa anterior à entrada parâmetro de dois nós Curve.PointAtParameter. Conecte Circle.ByPlaneRadius à entrada de curva do nó superior e Geometry.Translate à entrada de curva do nó abaixo dele.

9. Usando Line.ByStartPointEndPoint, conecte os dois nós Curve.PointAtParameter.

List.Count

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.

O nó List.Count é simples: conta o número de valores em uma lista e retorna esse número. Esse nó ganha mais nuances à medida que trabalhamos com listas de listas, mas vamos demonstrar isso nas seções a seguir.

1. O nó **List.Count ****** retorna o número de linhas no nó Line.ByStartPointEndPoint. Neste caso, o valor é 10, que concorda com o número de pontos criados no nó original do Bloco de código.

List.GetItemAtIndex

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.

List.GetItemAtIndex é uma forma fundamental de consultar um item na lista.

1. Primeiro, clique com o botão direito do mouse no nó Line.ByStartPointEndPoint para desativar sua visualização.

2. Usando o nó List.GetItemAtIndex, estamos selecionando o índice “0” ou o primeiro item na lista de linhas.

Altere o valor do controle deslizante entre 0 e 9 para selecionar outro item usando List.GetItemAtIndex.

List.Reverse

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.

List.Reverse inverte a ordem de todos os itens em uma lista.

1. Para visualizar corretamente a lista invertida de linhas, crie mais linhas alterando o Bloco de código para 0..1..#50;

2. Duplique o nó Line.ByStartPointEndPoint, insira um nó List.Reverse entre Curve.PointAtParameter e o segundo Line.ByStartPointEndPoint

3. Use os nós Watch3D para visualizar dois resultados diferentes. O primeiro mostra o resultado sem uma lista invertida. As linhas se conectam verticalmente aos pontos adjacentes. A lista invertida, no entanto, conectará todos os pontos à ordem oposta na outra lista.

List.ShiftIndices

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.

List.ShiftIndices é uma boa ferramenta para criar padrões de torções ou helicoidais, ou qualquer outra manipulação de dados semelhante. Esse nó altera os itens em uma lista por um determinado número de índices.

1. No mesmo processo que a lista inversa, insira um List.ShiftIndices no Curve.PointAtParameter e Line.ByStartPointEndPoint.

2. Usando um Bloco de código, foi designado o valor de “1” para mudar a lista em um índice.

3. Observe que a alteração é sutil, mas todas as linhas no nó inferior Watch3D mudaram um índice ao se conectarem ao outro conjunto de pontos.

Se o Bloco de código for alterado para um valor maior, “30”, por exemplo, perceberemos uma diferença significativa nas linhas diagonais. A mudança está funcionando como a íris da câmera nesse caso, criando uma torção na forma cilíndrica original.

List.FilterByBooleanMask

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.

List.FilterByBooleanMask removerá determinados itens com base em uma lista de booleanos ou valores “true” ou “false”.

Para criar uma lista de valores “true” ou “false”, é necessário um pouco mais de trabalho...

1. Usando um Bloco de código, defina uma expressão com a sintaxe: 0..List.Count(list);. Conecte o nó Curve.PointAtParameter à entrada lista. Vamos abordar mais essa configuração no capítulo do bloco de código, mas a linha de código nesse caso fornece uma lista que representa cada índice do nó Curve.PointAtParameter.

2. Usando um nó %** (módulo)**, conecte a saída do bloco de código à entrada x e um valor de 4 à entrada y. Isso vai gerar o resto ao dividir a lista de índices por 4. O módulo é um nó muito útil para a criação do padrão. Todos os valores serão lidos como os possíveis restos de 4: 0, 1, 2, 3.

3. No nó %** (módulo)**, sabemos que um valor de 0 significa que o índice é divisível por 4 (0, 4, 8 etc...). Usando um nó ==, podemos testar a divisibilidade com um valor de “0”.

4. O nó Watch revela apenas isso: temos um padrão true/false com a indicação: true,false,false,false....

5. Usando esse padrão true/false, conecte-se à entrada de máscara dos dois nós List.FilterByBooleanMask.

6. Conecte o nó Curve.PointAtParameter a cada entrada da lista do List.FilterByBooleanMask.

7. A saída de Filter.ByBooleanMask é “in” e “out”. “In” representa valores que tinham um valor de máscara “true”, enquanto “out” representa valores que tinham um valor “false”. Conectando as saídas “in” às entradas startPoint e endPoint de um nó Line.ByStartPointEndPoint, criamos uma lista de linhas filtrada.

8. O nó Watch3D revela que temos menos linhas do que pontos. Selecionamos somente 25% dos nós filtrando somente os valores true.

Se a forma mais simples de dados forem os números, a forma mais fácil de relacionar esses números será através da matemática. De operadores simples, como dividir até funções trigonométricas, ou fórmulas mais complexas, a matemática é uma ótima forma de começar a explorar as relações e os padrões numéricos.

Operadores aritméticos

Os operadores são um conjunto de componentes que usam funções algébricas com dois valores de entrada numéricos, o que resulta em um valor de saída (adição, subtração, multiplicação, divisão etc.). Eles podem ser encontrados em Operadores>Ações.

Exercício: Fórmula da espiral dourada

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.

Parte I: Fórmula paramétrica

Combine operadores e variáveis para formar uma relação mais complexa através de Fórmulas. Use os controles deslizantes para criar uma fórmula que pode ser controlada com parâmetros de entrada.

1. Crie a sequência de números que representa o “t” na equação paramétrica; portanto, queremos usar uma lista suficientemente grande para definir uma espiral.

Sequência de números: defina uma sequência de números com base em três entradas: início, quantidade e etapa.

2. A etapa acima criou uma lista de números para definir o domínio paramétrico. Em seguida, crie um grupo de nós que representa a equação da espiral dourada.

A espiral dourada é definida como a equação:

A imagem abaixo representa a espiral dourada na forma de programação visual. Quando você percorrer o grupo de nós, tente prestar atenção ao paralelo entre o programa visual e a equação escrita.

a. Controle deslizante de número: adicione dois controles deslizantes de número à tela. Esses controles deslizantes representarão as variáveis a e b da equação paramétrica. Eles representam uma constante que é flexível ou parâmetros que podem ser ajustados para um resultado desejado.

b. Multiplicação (*): o nó de multiplicação é representado por um asterisco. Usaremos isso repetidamente para conectar variáveis de multiplicação

c. Math.RadiansToDegrees: os valores “t” precisam ser convertidos em graus para sua avaliação nas funções trigonométricas. Lembre-se de que o Dynamo usa como padrão a unidade de graus para avaliar essas funções.

d. Math.Pow: como uma função de “t” e o número “e” que cria a sequência de Fibonacci.

e. Math.Cos e Math.Sin: essas duas funções trigonométricas diferenciarão a coordenada x e a coordenada y, respectivamente, de cada ponto paramétrico.

f. Inspeção: agora vemos que nossa saída é formada por duas listas, que serão as coordenadas x e y dos pontos usados para gerar a espiral.

Parte II: Da fórmula à geometria

Point.ByCoordinates: conecte o nó de multiplicação superior à entrada “x” e a parte inferior à entrada “y”. Agora vemos uma espiral paramétrica de pontos na tela.

Polycurve.ByPoints: conecte Point.ByCoordinates da etapa anterior a pontos. Podemos deixar connectLastToFirst sem entrada porque não estamos criando uma curva fechada. Isso cria uma espiral que passa por cada ponto definido na etapa anterior.

Agora concluímos a espiral de Fibonacci. A partir daqui, vamos aprofundar isso em dois exercícios separados, que chamaremos de nautiloide e girassol. Esses são abstrações de sistemas naturais, mas os dois aplicativos diferentes da espiral de Fibonacci serão bem representados.

Parte III: Da espiral ao nautiloide

Circle.ByCenterPointRadius: vamos usar um nó de círculo aqui com as mesmas entradas da etapa anterior. O valor do raio tem como padrão 1,0, de modo que vemos uma saída imediata de círculos. Torna-se imediatamente legível como os pontos se afastam da origem.

Sequência de números: essa é a matriz original de “t”. Conectando isso ao valor do raio de Circle.ByCenterPointRadius, os centros do círculo ainda ficam bastante afastados da origem, mas o raio dos círculos está aumentando, criando um gráfico de círculo de Fibonacci moderno.

Você ganhará pontos de bônus se fizer em 3D.

Parte IV: Do nautiloide à filotaxia

Como ponto de partida, vamos começar com a mesma etapa do exercício anterior: criar uma matriz de espiral de pontos com o nó Point.ByCoordinates.


Em seguida, siga estas minietapas para gerar uma série de espirais em várias rotações.

a. Geometry.Rotate: há diversas opções de Geometry.Rotate; assegure-se de que você selecionou o nó com geometry,basePlane e degrees como entradas. Conecte Point.ByCoordinates à entrada da geometria. Clique com o botão direito do mouse nesse nó e verifique se a amarra está definida como “Produto transversal”

b. Plane.XY: conecte à entrada basePlane. Vamos rotacionar em torno da origem, que é a mesma localização da base da espiral.

c. Intervalo de números: para nossa entrada de graus, desejamos criar várias rotações. Podemos fazer isso rapidamente com um componente do Intervalo de números. Conecte isso à entrada graus.

d. Número: para definir o intervalo de números, adicione três nós de número à tela na ordem vertical. De cima para baixo, atribua valores de 0,0,360,0, e 120,0, respectivamente. Esses valores controlam a rotação da espiral. Observe os resultados de saída no nó Intervalo de números após conectar os três nós de número ao nó.

Nossa saída está começando a se parecer com um redemoinho. Vamos ajustar alguns dos parâmetros de Intervalo de números e ver como os resultados mudam.

Altere o tamanho da etapa do nó Intervalo de números de 120,0 para 36,0. Observe que isso está criando mais rotações e, portanto, nos oferece um eixo mais denso.

Altere o tamanho da etapa do nó Intervalo de números de 36,0 para 3,6. Isso nos oferece agora um eixo muito mais denso, e a direcionalidade da espiral é pouca clara. Senhoras e senhores, criamos um girassol.

O Dynamo 2.0 não só apresenta os nós anteriormente discutidos dos dicionários, como também existe uma nova funcionalidade nos blocos de código para isso.

É possível usar a sintaxe como indicado abaixo ou as representações com base em DesignScript dos nós.

Como um dicionário é um tipo de objeto no Dynamo, podemos confirmar as seguintes ações sobre ele.

Manter esse tipo de interações é especialmente útil ao relacionar dados do Revit com sequências de caracteres. A seguir, vamos examinar alguns casos de uso do Revit.

Listas de listas

Vamos adicionar mais um nível à hierarquia. Se pegarmos o maço de cartas do exemplo original e criarmos uma caixa que contém vários maços, a caixa agora representará uma lista de maços e cada maço representará uma lista de cartas. Esta é uma lista de listas. Para a analogia nesta seção, a imagem abaixo contém uma lista de rolos de moeda e cada rolo contém uma lista de moedas de um centavo.

Consulta

Quais consultas podemos fazer na lista de listas? Isso acessa as propriedades existentes.

• Quantidade de tipos de moeda? 2.

• Valores de tipo de moeda? $ 0,01 e $ 0,25.

• Material das moedas de vinte e cinco centavos? 75% de cobre e 25% de níquel.

• Material de moedas de um centavo? 97,5% de zinco e 2,5% de cobre.

Ação

Quais ações podemos executar na lista de listas? Isso altera a lista de listas com base em uma operação fornecida.

• Selecione uma pilha específica de moedas de vinte e cinco centavos ou de um centavo.

• Selecione uma moeda específica de vinte e cinco centavos ou um centavo.

• Reorganize as pilhas de moedas de vinte e cinco centavos e de um centavo.

• Misture as pilhas.

Novamente, o Dynamo tem um nó análogo para cada uma das operações acima. Como estamos trabalhando com dados abstratos, e não com objetos físicos, precisamos de um conjunto de regras para controlar como movemos para cima e para baixo na hierarquia de dados.

Ao lidar com listas de listas, os dados são complexos e dispostos em camadas, mas isso proporciona a oportunidade de executar algumas operações paramétricas incríveis. Vamos separar os conceitos básicos e discutir mais algumas operações nas lições abaixo.

Exercício

Hierarquia de cima para baixo

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.

O conceito fundamental a ser aprendido nesta seção: o Dynamo trata as listas intrinsecamente como objetos. Essa hierarquia de cima para baixo é desenvolvida considerando a programação orientada a objetos. Em vez de selecionar subelementos com um comando como List.GetItemAtIndex, o Dynamo seleciona o índice da lista principal na estrutura de dados. E esse item pode ser outra lista. Vamos explicar em detalhes com uma imagem de exemplo:

1. Com o Bloco de código, definimos dois intervalos: 0..2; 0..3;

2. Esses intervalos são conectados a um nó Point.ByCoordinates com amarra definida como “Produto transversal”. Isso cria um eixo de pontos e também retorna uma lista de listas como uma saída.

3. Observe que o nó Inspeção fornece três listas com quatro itens cada.

4. Usando List.GetItemAtIndex, com um índice de 0, o Dynamo seleciona a primeira lista e todo seu conteúdo. Outros programas podem selecionar o primeiro item de cada lista na estrutura de dados, mas o Dynamo emprega uma hierarquia de cima para baixo ao lidar com os dados.

List.Flatten

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.

Mesclar remove todos os níveis de dados de uma estrutura de dados. Isso é útil quando as hierarquias de dados não são necessárias para sua operação, mas pode ser arriscado porque remove as informações. O exemplo abaixo mostra o resultado do nivelamento de uma lista de dados.

1. Insira uma linha de código para definir um intervalo em Bloco de código: -250..-150..#4;

2. Conectando o bloco de código à entrada x e y de um nó Point.ByCoordinates, definimos a amarra como “Produto transversal” para obter um eixo de pontos.

3. O nó Inspeção mostra que temos uma lista de listas.

4. Um nó PolyCurve.ByPoints fará referência a cada lista e criará uma policurva respectiva. Observe na visualização do Dynamo que temos quatro policurvas que representam cada linha no eixo.

1. Se inserirmos um nivelamento antes do nó da policurva, criaremos uma única lista para todos os pontos. O nó PolyCurve.ByPoints faz referência a uma lista para criar uma curva e, como todos os pontos estão em uma lista, obtemos uma policurva em ziguezague que segue em toda a lista de pontos.

Há também opções para aplainar níveis isolados de dados. Usando o nó List.Flatten, é possível definir um número determinado de níveis de dados para aplainar desde o topo da hierarquia. Essa será uma ferramenta realmente útil se você estiver lidando com estruturas de dados complexas, que não são necessariamente relevantes para o fluxo de trabalho. Outra opção é usar o nó de nivelamento como uma função em List.Map. Discutiremos mais sobre List.Map abaixo.

Cortar

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.

Durante a modelagem paramétrica, também há ocasiões em que você desejará modificar a estrutura de dados para uma lista existente. Há muitos nós disponíveis para isso também, e o corte é a versão mais básica. Com o corte, é possível particionar uma lista em sublistas com um número definido de itens.

O comando de corte divide as listas com base em um determinado comprimento de lista. De certa forma, o corte é o oposto da mesclagem: em vez de remover a estrutura de dados, ele adiciona novos níveis a ela. Essa é uma ferramenta útil para operações geométricas como o exemplo abaixo.

List.Map

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.

List.Map/Combine aplica uma função definida a uma lista de entrada, mas um degrau abaixo na hierarquia. As combinações são o mesmo que os mapas, exceto pelo fato de que as combinações podem ter várias entradas correspondentes à entrada de uma determinada função.

Como uma rápida introdução, vamos revisar o nó List.Count de uma seção anterior.

O nó List.Count conta todos os itens em uma lista. Usaremos isso para demonstrar como List.Map funciona.

1. Insira duas linhas de código no Bloco de código: -50..50..#Nx; -50..50..#Ny;

   Após digitar esse código, o bloco de código criará duas entradas para Nx e Ny.

2. Com dois controles deslizantes de número inteiro, defina os valores Nx e Ny conectando-os ao Bloco de código.

3. Conecte cada linha do bloco de código às respectivas entradas X e Y de um nó Point.ByCoordinates. Clique com o botão direito do mouse no nó, selecione “Amarra” e selecione “Produto transversal”. Isso cria um eixo de pontos. Como definimos o intervalo de -50 a 50, estamos expandindo o eixo padrão do Dynamo.

4. Um nó Inspeção revela os pontos criados. Observe a estrutura de dados. Criamos uma lista de listas. Cada lista representa uma linha de pontos do eixo.

1. Anexe um nó List.Count à saída do nó de inspeção da etapa anterior.

2. Conecte um nó Inspeção à saída List.Count.

Observe que o nó List.Count fornece um valor igual a 5. Isso é igual à variável “Nx”, conforme definido no bloco de código. Por que isso ocorre?

• Primeiro, o nó Point.ByCoordinates usa a entrada “x” como entrada principal para criar listas. Quando Nx é 5 e Ny é 3, obtemos uma lista de 5 listas, cada uma com 3 itens.

• Como o Dynamo trata as listas intrinsecamente como objetos, um nó List.Count é aplicado à lista principal na hierarquia. O resultado é um valor igual a 5 ou o número de listas na lista principal.

1. Usando um nó List.Map, descemos um degrau na hierarquia e executamos uma “função” neste nível.

2. Observe que o nó List.Count não tem nenhuma entrada. Ele está sendo usado como uma função para que o nó List.Count seja aplicado a cada lista individual um degrau abaixo na hierarquia. A entrada em branco de List.Count corresponde à entrada de lista de List.Map.

3. Os resultados de List.Count agora fornecem uma lista de 5 itens, cada um com o valor de 3. Isso representa o tamanho de cada sublista.

List.Combine

Neste exercício, usaremos List.Combine para demonstrar como pode ser usado para aplicar uma função em listas separadas de objetos.

Comece configurando duas listas de pontos.

1. Use o nó Sequência para gerar 10 valores, cada um com um incremento de 10 etapas.

2. Conecte o resultado à entrada x de um nó Point.ByCoordinates. Isso criará uma lista de pontos no Dynamo.

3. Adicione um segundo nó Point.ByCoordinates ao espaço de trabalho, use a mesma saída de Sequência como sua entrada x, mas use um Controle deslizante de número inteiro como sua entrada y e defina seu valor como 31 (pode ser qualquer valor, desde que não se sobreponha ao primeiro conjunto de pontos) para que os dois conjuntos de pontos não se sobreponham um ao outro.

Em seguida, usaremos List.Combine para aplicar uma função em objetos em duas listas separadas. Neste caso, será uma função de linha de desenho simples.

1. Adicione List.Combine ao espaço de trabalho e conecte os dois conjuntos de pontos como suas entradas list0 e list1.

2. Use Line.ByStartPointEndPoint como a função de entrada para List.Combine.

Após a conclusão, os dois conjuntos de pontos são compactados/emparelhados por meio de uma função Line.ByStartPointEndPoint e retornam 10 linhas no Dynamo.

List@Level

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.

Com preferência em relação a List.Map, o recurso List@Level permite selecionar diretamente com qual nível de lista você deseja trabalhar diretamente na porta de entrada do nó. É possível aplicar esse recurso a qualquer entrada de nó e permitirá que você acesse os níveis de suas listas com mais rapidez e facilidade do que com outros métodos. Basta informar ao nó qual nível da lista você deseja usar como entrada e deixar que o nó faça o restante.

Neste exercício, usaremos o recurso List@Level para isolar um nível de dados específico.

Começaremos com um eixo de pontos 3D simples.

1. Como o eixo é construído com um intervalo para X, Y e Z, sabemos que os dados estão estruturados com três níveis: uma lista X, uma lista Y e uma lista Z.

2. Esses níveis existem em diferentes Níveis. Os níveis são indicados na parte inferior da bolha de visualização. As colunas de níveis da lista correspondem aos dados da lista acima para ajudar a identificar em qual nível se deve trabalhar.

3. Os níveis da lista estão organizados em ordem inversa para que os dados de menor nível estejam sempre em “L1”. Isso ajudará a garantir que os gráficos funcionem conforme planejado, mesmo que algo seja alterado a montante.

1. Para usar a função List@Level, clique em “>”. Nesse menu, existem duas caixas de seleção.

2. Usar níveis – Ativa a funcionalidade List@Level. Após clicar nessa opção, você poderá clicar e selecionar os níveis da lista de entrada que deseja que o nó use. Com esse menu, você pode experimentar rapidamente diferentes opções de nível clicando para cima ou para baixo.

3. Manter a estrutura da lista – Se essa opção estiver ativada, você poderá manter a estrutura de nível da entrada. Às vezes, você pode ter organizado intencionalmente os dados em sublistas. Ao marcar essa opção, é possível manter a organização da lista intacta e não perder nenhuma informação.

Com nosso eixo 3D simples, podemos acessar e visualizar a estrutura de lista alternando entre os níveis de lista. Cada combinação de nível de lista e índice retorna um conjunto de pontos diferente do nosso conjunto 3D original.

1. “@L2” em DesignScript nos permite selecionar somente a lista no Nível 2. A lista no Nível 2 com o índice 0 inclui somente o primeiro conjunto de pontos Y, retornando somente o eixo XZ.

2. Se alterarmos o filtro Nível para “L1”, poderemos ver tudo no primeiro nível da lista. A lista no Nível 1 com índice 0 inclui todos os nossos pontos 3D em uma lista plana.

3. Se tentarmos fazer o mesmo para “L3”, veremos somente os pontos do terceiro nível da lista. A lista no Nível 3 com índice 0 inclui somente o primeiro conjunto de pontos Z, retornando somente um eixo XY.

4. Se tentarmos o mesmo para “L4”, veremos somente os pontos do terceiro nível da lista. A lista no Nível 4 com índice 0 inclui somente o primeiro conjunto de pontos X, retornando somente um eixo YZ.

Embora este exemplo específico também possa ser criado com List.Map, o recurso List@Level simplifica muito a interação, facilitando o acesso aos dados do nó. Confira abaixo uma comparação entre os métodos List.Map e List@Level:

1. Embora ambos os métodos ofereçam acesso aos mesmos pontos, o método List@Level permite alternar facilmente entre as camadas de dados em um único nó.

2. Para acessar um eixo de pontos com List.Map, precisamos de um nó List.GetItemAtIndex junto com List.Map. Para cada nível de lista que descermos, precisaremos usar um nó List.Map adicional. Dependendo da complexidade das listas, isso pode exigir a adição de uma quantidade significativa de nós List.Map ao gráfico para acessar o nível de informações correto.

3. Neste exemplo, um nó List.GetItemAtIndex com um nó List.Map retorna o mesmo conjunto de pontos com a mesma estrutura de lista que o List.GetItemAtIndex com “@L3” selecionado.

Transpor

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.

Transpor é uma função fundamental ao lidar com listas de listas. Assim como nos programas de planilha, uma transposição inverte as colunas e linhas de uma estrutura de dados. Vamos demonstrar isso com uma matriz básica abaixo e, na seção a seguir, vamos demonstrar como uma transposição pode ser usada para criar relações geométricas.

Vamos excluir os nós List.Count do exercício anterior e usar alguma geometria para ver como os dados se estruturaram.

1. Conecte PolyCurve.ByPoints à saída do nó de inspeção de Point.ByCoordinates.

2. A saída mostra 5 policurvas e podemos ver as curvas na visualização do Dynamo. O nó do Dynamo está procurando uma lista de pontos (ou uma lista de listas de pontos neste caso) e criando uma única PolyCurve com base neles. Essencialmente, cada lista foi convertida em uma curva na estrutura de dados.

1. Um nó List.Transpose alternará todos os itens com todas as listas em uma lista de listas. Isso parece complicado, mas é a mesma lógica do recurso Transpor no Microsoft Excel: alternar colunas com linhas em uma estrutura de dados.

2. Observe o resultado abstrato: a transposição alterou a estrutura da lista de 5 listas com 3 itens cada uma para 3 listas com 5 itens cada uma.

3. Observe o resultado geométrico: usando PolyCurve.ByPoints, obtemos 3 policurvas na direção perpendicular às curvas originais.

Bloco de código para criação de lista

Consulta do bloco de código

Exercício – Consultar e inserir dados

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 usa uma lógica estabelecida no exercício anterior para editar uma superfície. Nosso objetivo aqui é intuitivo, mas a navegação na estrutura de dados estará mais envolvida. Desejamos articular uma superfície movendo um ponto de controle.

Comece com a cadeia de caracteres dos nós acima. Estamos criando uma superfície básica que abrange o eixo padrão do Dynamo.

1. Usando o Bloco de código, insira essas duas linhas de código e conecte-se às entradas u e v de Surface.PointAtParameter, respectivamente: -50..50..#3; -50..50..#5;

2. Certifique-se de configurar a Amarra de Surface.PointAtParameter como “Produto transversal”.

3. O nó Inspeção mostra que temos uma lista de 3 listas, cada uma com 5 itens.

Nesta etapa, queremos consultar o ponto central no eixo que criamos. Para fazer isso, vamos selecionar o ponto médio na lista do meio. Faz sentido, certo?

1. Para confirmar que esse é o ponto correto, também podemos clicar nos itens do nó de inspeção para confirmar que estamos selecionando o item correto.

2. Usando o Bloco de código, vamos escrever uma linha básica de código para consultar uma lista de listas: points[1][2];

3. Usando Geometry.Translate, vamos mover o ponto selecionado para cima na direção Z por 20 unidades.

1. Vamos também selecionar a linha média de pontos com um nó List.GetItemAtIndex. Observação: De forma similar a uma etapa anterior, também é possível consultar a lista com o Bloco de código, usando uma linha de points[1];

Até agora, consultamos com êxito o ponto central e o movemos para cima. Agora, queremos inserir esse ponto movido de volta na estrutura de dados original.

1. Primeiro, queremos substituir o item da lista que isolamos em uma etapa anterior.

2. Usando List.ReplaceItemAtIndex, vamos substituir o item do meio e o índice de “2” pelo item de substituição conectado ao ponto movido (Geometry.Translate).

3. A saída mostra que inserimos o ponto movido no item do meio da lista.

Agora que modificamos a lista, precisamos inseri-la de volta na estrutura de dados original: a lista de listas.

1. Seguindo a mesma lógica, use List.ReplaceItemAtIndex para substituir a lista do centro pela nossa lista modificada.

2. Observe que os Blocos de código que definem o índice para esses dois nós são 1 e 2, que coincidem com a consulta original do Bloco de código (pontos[1][2]).

3. Se selecionarmos a lista no índice 1, veremos a estrutura de dados realçada na visualização do Dynamo. Mesclamos com êxito o ponto movido para a estrutura de dados original.

Existem várias maneiras de criar uma superfície com base nesse conjunto de pontos. Neste caso, vamos criar uma superfície por meio da elevação de curvas.

1. Crie um nó NurbsCurve.ByPoints e conecte a nova estrutura de dados para criar três curvas NURBS.

1. Conecte Surface.ByLoft à saída de NurbsCurve.ByPoints. Agora, temos uma superfície modificada. É possível alterar o valor Z original da geometria. Converta e observe a atualização da geometria.

O Dynamo 2.0 apresenta o conceito de separar o tipo de dados de dicionários do tipo de dados de listas. Essa alteração pode representar algumas alterações significativas na forma como você cria e trabalha com os dados em seus fluxos de trabalho. Antes da versão 2.0, os dicionários e as listas eram combinados como um tipo de dados. Em resumo, as listas eram, na verdade, dicionários com chaves de número inteiro.

O que é um dicionário?

Um dicionário é um tipo de dados formado por um conjunto de pares de valores-chave onde cada chave é exclusiva em cada conjunto. Um dicionário não tem ordem e, basicamente, é possível “procurar por coisas” usando uma chave em vez de um valor de índice, como em uma lista. No Dynamo 2.0, as chaves somente podem ser sequências de caracteres.

O que é uma lista?

Uma lista é um tipo de dados formado por um conjunto de valores ordenados. No Dynamo, as listas usam números inteiros como valores de índice.

Por que essa mudança foi feita e por que é importante para mim?

A separação dos dicionários das listas apresenta os dicionários como um elemento de primeira classe que você pode usar para armazenar e pesquisar valores de maneira rápida e fácil, sem precisar lembrar um valor de índice ou manter uma estrutura de lista rigorosa em todo o fluxo de trabalho. Durante o teste dos usuários, vimos uma redução significativa no tamanho do gráfico quando os dicionários eram usados em vez de vários nós GetItemAtIndex.

Quais são as mudanças?

• Ocorreram alterações na sintaxe que alteram a forma como você inicializará e trabalhará com dicionários e listas em blocos de código.

  • Os dicionários usam a seguinte sintaxe {key:value}

  • As listas usam a seguinte sintaxe [value,value,value]

• Novos nós foram introduzidos na biblioteca para ajudar a criar, modificar e consultar dicionários.

• As listas criadas em blocos de código v1.x migrarão automaticamente durante o carregamento do script com a nova sintaxe de lista que usa colchetes [ ] em vez de chaves { } \

  ---

Por que isso é importante para mim? Para que você usaria isso?

Em ciência de computação, os dicionários, como as listas, são conjuntos de objetos. Embora as listas estejam em uma ordem específica, os dicionários são conjuntos não ordenados. Eles não dependem de números sequenciais (índices); em vez disso, usam chaves.

Na imagem abaixo, demonstramos um caso de uso potencial de um dicionário. Muitas vezes, os dicionários são usados para relacionar duas partes dos dados que podem não ter uma correlação direta. No nosso caso, estamos ligando a versão em espanhol de uma palavra à versão em inglês para uma pesquisa posterior.

1. Crie um dicionário para relacionar as duas partes dos dados.

2. Obtenha o valor com a chave fornecida.

Os dicionários representam uma coleção de dados relacionados com outros dados conhecidos como chave. Os dicionários expõem a capacidade de procurar, excluir e inserir dados em uma coleção.

Essencialmente, podemos pensar em um dicionário como uma forma realmente inteligente de buscar algo.

Embora a funcionalidade de dicionário já esteja disponível no Dynamo há algum tempo, o Dynamo 2.0 apresenta uma nova forma de gerenciar esse tipo de dados.

A cor é um excelente tipo de dados para criar imagens atraentes, bem como para a diferença de renderização na saída do Programa visual. Ao trabalhar com dados abstratos e números variados, às vezes é difícil ver o que está mudando e até que ponto. Este é um ótimo aplicativo para cores.

Criar cores

As cores no Dynamo são criadas usando entradas ARGB. Isso corresponde aos canais alfa, vermelho, verde e azul. O alfa representa a transparência da cor, enquanto os outros três canais são usados como cores primárias para gerar todo o espectro de cores em conjunto.

Consultar os valores de cor

As cores na tabela abaixo consultam as propriedades usadas para definir a cor: Alfa, Vermelho, Verde e Azul. Observe que o nó Color.Components nos fornece as quatro como resultados diferentes, o que torna este nó preferível para consultar as propriedades de uma cor.

As cores na tabela abaixo correspondem ao espaço de cores HSB. A divisão das cores em matiz, saturação e brilho é, sem dúvida, algo mais intuitivo para a maneira como interpretamos as cores: qual deve ser a cor? Quão colorido deve ser? E quão clara ou escura deve ser a cor? Este é o detalhamento de matiz, saturação e brilho, respectivamente.

Faixa de cores

A faixa de cores é similar ao nó Remapear faixa do exercício : remapeia uma lista de números em outro domínio. Mas, em vez de mapear para um domínio de números, o mapeamento é feito para um gradiente de cores com base nos números de entrada que variam de 0 a 1.

O nó atual funciona bem, mas pode ser um pouco estranho fazer com que tudo funcione da primeira vez. A melhor forma de se familiarizar com o gradiente de cores é testar o resultado de forma interativa. Vamos fazer um exercício rápido para rever como configurar um gradiente com cores de saída correspondentes aos números.

1. Definir três cores: usando um nó de bloco de código defina vermelho, verde e azul inserindo as combinações apropriadas de 0 e 255.

2. Criar lista: mescle as três cores em uma lista.

3. Definir índices: crie uma lista para definir as posições da alça de cada cor (desde 0 até 1). Observe o valor de 0,75 para verde. Isso situa a cor verde a 3/4 do caminho através do gradiente horizontal no controle deslizante da faixa de cores.

4. Bloco de código: insira valores (entre 0 e 1) para converter em cores.

Visualização da cor

O nó Display.ByGeometry fornece a capacidade de colorir a geometria na viewport do Dynamo. Isso é útil para separar diferentes tipos de geometria, demonstrando um conceito paramétrico ou definindo uma legenda de análise para simulação. As entradas são simples: geometria e cor. Para criar um gradiente como a imagem acima, a entrada de cor é conectada ao nó Faixa de cores.

Cor em superfícies

O nó Display.BySurfaceColors fornece a capacidade de mapear dados em uma superfície usando a cor. Essa funcionalidade apresenta algumas possibilidades interessantes para visualizar os dados obtidos por meio de análise discreta, como solar, energia e proximidade. A aplicação de cor a uma superfície no Dynamo é semelhante à aplicação de uma textura a um material em outros ambientes CAD. Vamos demonstrar como usar essa ferramenta no breve exercício abaixo.

Exercício

Hélice básica com cores

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 foca no controle de cores parametricamente em paralelo com a geometria. A geometria é uma hélice básica, que definimos abaixo usando o Bloco de código. Essa é uma maneira rápida e fácil de criar uma função paramétrica; e, como nosso foco está na cor (e não na geometria), usamos o bloco de código para criar a hélice de forma eficiente sem sobrecarregar a tela. Usaremos o bloco de código com mais frequência à medida que o manual passar a abordar um material mais avançado.

1. Bloco de código: define os dois blocos de código com as fórmulas acima. Esse é um método paramétrico rápido para criar uma espiral.

2. Point.ByCoordinates: conecta as três saídas do bloco de código às coordenadas do nó.

Agora, vemos uma matriz de pontos criando uma hélice. A próxima etapa é criar uma curva através dos pontos de forma que possamos visualizar a hélice.

1. PolyCurve.ByPoints: conecta a saída Point.ByCoordinates à entrada pontos do nó. Obtemos uma curva helicoidal.

2. Curve.PointAtParameter: conecta a saída PolyCurve.ByPoints à entrada curva. O propósito dessa etapa é criar um ponto paramétrico atrativo que desliza ao longo da curva. Como a curva está avaliando um ponto no parâmetro, precisaremos inserir um valor de parâmetro entre 0 e 1.

3. Controle deslizante de número: após adicionar à tela, altere o valor mín para 0,0, o valor máx para 1,0 e o valor de etapa para 0,01. Conecte a saída do controle deslizante à entrada parâmetro para Curve.PointAtParameter. Agora, vemos um ponto ao longo do comprimento da hélice, representado por uma porcentagem do controle deslizante (0 no ponto inicial, 1 no ponto final).

Com o ponto de referência criado, agora comparamos a distância do ponto de referência com os pontos originais que definem a hélice. Esse valor de distância determinará a geometria e a cor.

1. Geometry.DistanceTo: conecta a saída Curve.PointAtParameter à entrada. Conecte Point.ByCoordinates à entrada da geometria.

2. Inspeção: o resultado mostra uma lista de distâncias entre cada ponto helicoidal e o ponto de referência ao longo da curva.

A próxima etapa é determinar os parâmetros com a lista de distâncias, entre os pontos helicoidais e o ponto de referência. Usamos esses valores de distância para definir os raios de uma série de esferas ao longo da curva. Para manter as esferas em um tamanho adequado, precisamos remapear os valores da distância.

1. Math.RemapRange: conecta a saída Geometry.DistanceTo à entrada dos números.

2. Bloco de código: conecta um bloco de código com um valor de 0,01 à entrada newMin e um bloco de código com um valor de 1 à entrada newMax.

3. Inspeção: conecta a saída Math.RemapRange a um nó e a saída Geometry.DistanceTo a outro nó. Compare os resultados.

Essa etapa remapeou a lista de distâncias para um intervalo menor. Podemos editar os valores newMin e newMax, conforme necessário. Os valores serão remapeados e terão a mesma relação de distribuição em todo o domínio.

1. Sphere.ByCenterPointRadius: conecta a saída Math.RemapRange à entrada raio e a saída original Point.ByCoordinates à entrada centerPoint.

Altere o valor do controle deslizante de número e observe o tamanho das esferas atualizadas. Agora, temos um modelo paramétrico

O tamanho das esferas demonstra a matriz paramétrica definida por um ponto de referência ao longo da curva. Vamos usar o mesmo conceito para o raio da esfera para determinar sua cor.

1. Faixa de cores: adiciona a parte superior da tela. Quando passamos o cursor sobre a entrada valor, notamos que os números solicitados estão entre 0 e 1. Precisamos remapear os números da saída Geometry.DistanceTo para que sejam compatíveis com esse domínio.

2. Sphere.ByCenterPointRadius: por enquanto, vamos desativar a visualização nesse nó (clique com o botão direito do mouse > Visualização).

1. Math.RemapRange: esse processo deverá ser familiar. Conecte a saída Geometry.DistanceTo à entrada de números.

2. Bloco de código: de forma semelhante a uma etapa anterior, crie um valor de 0 para a entrada newMin e um valor de 1 para a entrada newMax. Neste caso, observe que podemos definir duas saídas de um único bloco de código.

3. Faixa de cores: conecte a saída Math.RemapRange à entrada valor.

1. Color.ByARGB: esse é o processo para criar duas cores. Embora esse processo possa parecer estranho, é o mesmo que as cores RGB em outro software, estamos apenas usando a programação visual para fazer isso.

2. Bloco de código: crie dois valores de 0 e 255. Conecte as duas saídas às duas entradas Color.ByARGB de acordo com a imagem acima (ou crie as duas cores favoritas).

3. Faixa de cores: a entrada cores solicita uma lista de cores. É necessário criar essa lista com base nas duas cores criadas na etapa anterior.

4. List.Create: mescla as duas cores em uma lista. Conecte a saída à entrada cores para a Faixa de cores.

1. Display.ByGeometryColor: conecta Sphere.ByCenterPointRadius à entrada geometria e a Faixa de cores à entrada cor. Agora temos um gradiente suave no domínio da curva.

Se alterarmos o valor do Controle deslizante de número anterior na definição, as cores e os tamanhos serão atualizados. As cores e o tamanho do raio estão diretamente relacionados neste caso: agora temos uma ligação visual entre dois parâmetros.

Exercício de cor em superfícies

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.

Primeiro, é preciso criar (ou referenciar) uma superfície para usar como uma entrada para o nó Display.BySurfaceColors. Neste exemplo, estamos fazendo a transição entre uma curva seno e cosseno.

1. Esse grupo de nós está criando pontos ao longo do eixo Z e, em seguida, deslocando-os com base nas funções de seno e cosseno. As duas listas de pontos são, em seguida, usadas para gerar curvas NURBS.

2. Surface.ByLoft: gera uma superfície interpolada entre a lista de curvas NURBS.

1. Caminho do arquivo: selecione um arquivo de imagem de amostra com uso dos dados de pixel a jusante

2. File.FromPath para converter o caminho do arquivo em um arquivo e, em seguida, passar para Image.ReadFromFile para gerar uma imagem de amostra

3. Image.Pixels: insira uma imagem e forneça um valor de amostra para usar ao longo das dimensões x e y da imagem

4. Controle deslizante: fornece os valores para Image.Pixels

5. Display.BySurfaceColors: mapeia a matriz de valores de cores através da superfície ao longo de X e Y, respectivamente

Visualização aproximada da superfície de saída com resolução de 400 x 300 amostras