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.
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.
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.
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:
| Ícone | Nome (Sintaxe) | Entradas | Saídas |
|---|---|---|---|
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.
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.
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.
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.
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.
Dados simples
Dados e ações (nó A) executados com êxito
A ação (nó A) sem entradas de dados retorna uma função genérica
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.
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).
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.
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).
Aplicando o mesmo processo à segunda lista, obtemos um valor de 0, o primeiro item da lista.
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.
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.
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.
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.).
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.
| Ícone | Nome/sintaxe | Entradas | Saídas |
|---|---|---|---|
Object.IsNull
obj
bool
Se (If)
teste, true, false
resultado
Fórmula (IF(x,y,z))
x, y, z
resultado
Bloco de código ((x?y:z);)
X, Y, Z
resultado
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.
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.
| Ícone | Nome (Sintaxe) | Entradas | Saídas |
|---|---|---|---|
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.
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.
Agora a maioria dos nós da etapa anterior funcionará bem, mas isso requer muito trabalho. Para criar um fluxo de trabalho mais eficiente, observe o DesignScript para definir uma sequência de caracteres de expressões do Dynamo em um nó. Nesta próxima série de etapas, vamos analisar o uso da equação paramétrica para desenhar a espiral de Fibonacci.
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.
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.
Agora que fizemos uma casca circular nautiloide, vamos passar para os eixos paramétricos. Vamos usar uma rotação básica na espiral de Fibonacci para criar um eixo de Fibonacci, e o resultado é modelado de acordo com o crescimento de sementes de girassol.
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.
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.
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.
| Ícone | Nome (Sintaxe) | Entradas | Saídas |
|---|
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.
| Ícone | Nome (Sintaxe) | Entradas | Saídas |
|---|
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.
| Ícone | Nome (Sintaxe) | Entradas | Saídas |
|---|
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.
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.
Criar lista: mescle as três cores em uma lista.
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.
Bloco de código: insira valores (entre 0 e 1) para converter em cores.
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.
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.
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.
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.
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.
PolyCurve.ByPoints: conecta a saída Point.ByCoordinates à entrada pontos do nó. Obtemos uma curva helicoidal.
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.
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.
Geometry.DistanceTo: conecta a saída Curve.PointAtParameter à entrada. Conecte Point.ByCoordinates à entrada da geometria.
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.
Math.RemapRange: conecta a saída Geometry.DistanceTo à entrada dos números.
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.
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.
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.
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.
Sphere.ByCenterPointRadius: por enquanto, vamos desativar a visualização nesse nó (clique com o botão direito do mouse > Visualização).
Math.RemapRange: esse processo deverá ser familiar. Conecte a saída Geometry.DistanceTo à entrada de números.
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.
Faixa de cores: conecte a saída Math.RemapRange à entrada valor.
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.
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).
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.
List.Create: mescla as duas cores em uma lista. Conecte a saída à entrada cores para a Faixa de cores.
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.
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.
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.
Surface.ByLoft: gera uma superfície interpolada entre a lista de curvas NURBS.
Caminho do arquivo: selecione um arquivo de imagem de amostra com uso dos dados de pixel a jusante
File.FromPath para converter o caminho do arquivo em um arquivo e, em seguida, passar para Image.ReadFromFile para gerar uma imagem de amostra
Image.Pixels: insira uma imagem e forneça um valor de amostra para usar ao longo das dimensões x e y da imagem
Controle deslizante: fornece os valores para Image.Pixels
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
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.
É 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.
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.
É 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:
O separador “;” divide cada vértice do retângulo. Isso cria uma lista com três itens para cada vértice.
Pressionando “+” no meio do nó, criamos um novo separador.
Adicione uma sequência de caracteres “,” à tela e conecte-se à nova entrada do separador.
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
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.
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:
Adicione ou subtraia sequências de caracteres da concatenação clicando nos botões +/- no centro do nó.
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:
A entrada do separador permite criar uma sequência de caracteres que divide as sequências de caracteres unidas.
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.
A sequência de caracteres base é colada em um nó String.
Outro nó String é usado para indicar o separador. Neste caso, usamos uma vírgula.
Um nó String.Split é adicionado à tela e conectado às duas sequências de caracteres.
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.
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.
Na entrada searchFor, definimos uma subsequência de caracteres que estamos procurando na estrofe. Vamos usar um nó String com o texto “E milhas”.
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.
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”.
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:
Usando dois nós List.GetItemAtIndex, podemos isolar os itens usando os valores de 0 e 1 como entrada do índice.
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:
Após adicionar o nó String.Join, notamos que precisamos de um separador.
Para criar o separador, adicionamos um nó String à tela e digitamos uma vírgula.
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.
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: . 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.
Cor ARGB (Color.ByARGB) | A,R,G,B | cor |
Alfa (Color.Alpha) | cor | A |
Vermelho (Color.Red) | cor | R |
Verde (Color.Green) | cor | G |
Azul (Color.Blue) | cor | B |
Componentes (Color.Components) | cor | A, R, G, B |
Matiz (Color.Hue) | cor | Matiz |
Saturação (Color.Saturation) | cor | Saturação |
Brilho (Color.Brightness) | cor | Brilho |
Adicionar (+)
var[]...[], var[]...[]
var[]...[]
Subtrair (-)
var[]...[], var[]...[]
var[]...[]
Multiplicar (*)
var[]...[], var[]...[]
var[]...[]
Dividir (/)
var[]...[], var[]...[]
var[]...[]
