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.
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.
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.
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.
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.
Vamos selecionar o índice de 1 para selecionar a superfície superior. Isso é feito com o nó List.GetItemAtIndex.
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.
Para obter uma visão de como a estrutura de dados está organizada, vamos conectar NurbsCurve.ByPoints à saída de Surface.PointAtParameter.
Você pode desativar a visualização do nó List.GetItemAtIndex por enquanto para obter um resultado mais claro.
Um List.Transpose básico inverterá as colunas e as linhas de uma lista de listas.
Conectando a saída de List.Transpose a NurbsCurve.ByPoints, agora obtemos cinco curvas sendo executadas horizontalmente na superfície.
Você pode desativar a visualização do nó NurbsCurve.ByPoints na etapa anterior para obter o mesmo resultado na imagem.
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.
Comece com uma etapa do exercício anterior, isolando a superfície superior da geometria importada com o nó List.GetItemAtIndex.
Usando Surface.Offset, desloque a superfície por um valor de 10.
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;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.
Desative a visualização dessas superfícies.
Como no exercício anterior, conecte as saídas aos dois nós NurbsCurve.ByPoints. O resultado mostra curvas correspondentes às duas superfícies.
Usando List.Create, é possível combinar os dois conjuntos de curvas em uma lista de listas.
Observe que, na saída, temos duas listas com dez itens em cada uma, representando cada conjunto de conexão de curvas Nurbs.
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.
Desative a visualização do nó Surface.ByLoft na etapa anterior.
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.
Usando Surface.ByLoft, chegamos a uma estrutura nervurada.
Em seguida, demonstraremos um processo alternativo para alcançar esse resultado
Antes de começarmos, desative a visualização de Surface.ByLoft na etapa anterior para evitar confusão.
Uma alternativa para List.Transpose é usar List.Combine. Isso executará um “combinador” em cada sublista.
Neste caso, estamos usando List.Create como o “combinador”, o que criará uma lista de cada item nas sublistas.
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.
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.
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.
Como no exercício anterior, use o nó Surface.Offset para deslocar por um valor de 10.
Observe, na saída, que criamos duas superfícies com o nó de deslocamento.
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;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.
Como no exercício anterior, conecte as saídas aos dois nós NurbsCurve.ByPoints.
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.
Observe que as coisas se tornam mais complexas no nó Surface.PointAtParameter. Neste caso, temos uma lista de listas de listas.
Antes de prosseguir, desative a visualização das superfícies existentes.
Usando o nó List.Create, mesclamos as curvas Nurbs em uma estrutura de dados, criando uma lista de listas de listas.
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.
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.
List.Combine funcionará melhor neste caso. Devemos usar os nós List.Map e List.Combine quando chegarmos a estruturas de dados mais complexas.
Usando List.Create como o “combinador”, criamos uma estrutura de dados que funcionará melhor.
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.
A função que será aplicada a List.Map é List.Transpose, que inverterá as colunas e as linhas das sublistas em nossa lista principal.
Finalmente, podemos fazer a transição entre as curvas Nurbs junto com uma hierarquia de dados adequada, gerando uma estrutura nervurada.
Vamos adicionar alguma profundidade à geometria com um nó Surface.Thicken, com as configurações de entrada conforme mostrado.
É 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.
À 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.
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.
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.
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.
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.
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.
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:
A entrada pontos para PolyCurve.ByPoints está procurando “Point[]”. Isso representa uma lista de pontos
A saída para PolyCurve.ByPoints é uma policurva única criada com base em uma lista de cinco pontos.
A entrada centerPoint para Circle.ByCenterPointRadius solicita “Ponto”.
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.
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:
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:
O algoritmo “Lista mais longa” continua conectando entradas, reusando elementos, até que todos os fluxos se esgotem:
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”.
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.
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.
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.
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.
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.
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.
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.
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.
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:
Com o Bloco de código, definimos dois intervalos:
0..2; 0..3;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.
Observe que o nó Inspeção fornece três listas com quatro itens cada.
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.
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.
Insira uma linha de código para definir um intervalo em Bloco de código:
-250..-150..#4;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.
O nó Inspeção mostra que temos uma lista de listas.
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.
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.
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.
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.
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.
Com dois controles deslizantes de número inteiro, defina os valores Nx e Ny conectando-os ao Bloco de código.
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.
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.
Anexe um nó List.Count à saída do nó de inspeção da etapa anterior.
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.
Usando um nó List.Map, descemos um degrau na hierarquia e executamos uma “função” neste nível.
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.
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.
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.
Use o nó Sequência para gerar 10 valores, cada um com um incremento de 10 etapas.
Conecte o resultado à entrada x de um nó Point.ByCoordinates. Isso criará uma lista de pontos no Dynamo.
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.
Adicione List.Combine ao espaço de trabalho e conecte os dois conjuntos de pontos como suas entradas list0 e list1.
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.
Consulte o exercício em Listas n-dimensionais para ver outro exemplo de uso de List.Combine.
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.
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.
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.
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.
Para usar a função List@Level, clique em “>”. Nesse menu, existem duas caixas de seleção.
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.
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.
“@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.
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.
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.
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:
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ó.
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.
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.
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.
Conecte PolyCurve.ByPoints à saída do nó de inspeção de Point.ByCoordinates.
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.
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.
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.
Observe o resultado geométrico: usando PolyCurve.ByPoints, obtemos 3 policurvas na direção perpendicular às curvas originais.
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.
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;Certifique-se de configurar a Amarra de Surface.PointAtParameter como “Produto transversal”.
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?
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.
Usando o Bloco de código, vamos escrever uma linha básica de código para consultar uma lista de listas:
points[1][2];Usando Geometry.Translate, vamos mover o ponto selecionado para cima na direção Z por 20 unidades.
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.
Primeiro, queremos substituir o item da lista que isolamos em uma etapa anterior.
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).
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.
Seguindo a mesma lógica, use List.ReplaceItemAtIndex para substituir a lista do centro pela nossa lista modificada.
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]).
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.
Crie um nó NurbsCurve.ByPoints e conecte a nova estrutura de dados para criar três curvas NURBS.
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.
Foto de .
Observação: Este exercício foi criado com uma versão anterior do Dynamo. A maior parte da funcionalidade de List.Map foi resolvida com a adição do recurso List@Level . Para obter mais informações, consulte abaixo.
Observação: Este exercício foi criado com uma versão anterior do Dynamo. A maior parte da funcionalidade de List.Combine foi resolvida com a adição do recurso List@Level . Para obter mais informações, consulte abaixo.
A abreviação do bloco de código usa “[]” para definir uma lista. Essa é uma maneira muito mais rápida e fluida de criar uma lista do que com o nó List.Create. O Bloco de código é discutido com mais detalhes em . Observe na imagem abaixo como uma lista com várias expressões pode ser definida com o bloco de código.
A abreviação do Bloco de código usa “[]” como uma forma rápida e fácil de selecionar itens específicos que você deseja de uma estrutura de dados complexa. Os Blocos de código são discutidos com mais detalhes no . Observe na imagem abaixo como uma lista com vários tipos de dados pode ser consultada com o bloco de código.
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.
Foto de Christian Gidlöf
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.
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.
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.
Comece com um Bloco de código com um valor de
500;Conecte-se à entrada x de um nó Point.ByCoordinates.
Conecte o nó da etapa anterior à entrada de origem de um nó Plane.ByOriginNormal.
Usando um nó Circle.ByPlaneRadius, conecte o nó da etapa anterior à entrada do plano.
Usando o Bloco de código, designe um valor de
50;para o raio. Esse é o primeiro círculo que criaremos.Com um nó Geometry.Translate, movimente o círculo 100 unidades para cima na direção Z.
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;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.
Usando Line.ByStartPointEndPoint, conecte os dois nós Curve.PointAtParameter.
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.
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.
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.
Primeiro, clique com o botão direito do mouse no nó Line.ByStartPointEndPoint para desativar sua visualização.
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.
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.
Para visualizar corretamente a lista invertida de linhas, crie mais linhas alterando o Bloco de código para
0..1..#50;Duplique o nó Line.ByStartPointEndPoint, insira um nó List.Reverse entre Curve.PointAtParameter e o segundo Line.ByStartPointEndPoint
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.
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.
No mesmo processo que a lista inversa, insira um List.ShiftIndices no Curve.PointAtParameter e Line.ByStartPointEndPoint.
Usando um Bloco de código, foi designado o valor de “1” para mudar a lista em um índice.
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.
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...
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.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.
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”.
O nó Watch revela apenas isso: temos um padrão true/false com a indicação: true,false,false,false....
Usando esse padrão true/false, conecte-se à entrada de máscara dos dois nós List.FilterByBooleanMask.
Conecte o nó Curve.PointAtParameter a cada entrada da lista do List.FilterByBooleanMask.
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.
O nó Watch3D revela que temos menos linhas do que pontos. Selecionamos somente 25% dos nós filtrando somente os valores true.
