Las listas son la forma en que organizamos los datos. En el sistema operativo del equipo, tiene archivos y carpetas. En Dynamo, podemos considerarlos como elementos y listas respectivamente. Al igual que su sistema operativo, existen muchas formas de crear, modificar y consultar datos. En este capítulo, vamos a desglosar el modo en que se gestionan las listas en Dynamo.
Una lista es un conjunto de elementos o ítems. Pensemos en un racimo de plátanos, por ejemplo. Cada plátano es un elemento de la lista (o racimo). Es más fácil coger un racimo de plátanos que cada plátano individualmente y lo mismo se aplica a la agrupación de elementos por relaciones paramétricas en una estructura de datos.
Fotografía de Augustus Binu.
Cuando hacemos la compra, ponemos todos los artículos comprados en una bolsa. Esta bolsa también es una lista. Si vamos a hacer pan de plátano, necesitamos tres racimos de plátanos (vamos a hacer mucho pan de plátano). La bolsa representa una lista de racimos de plátanos y cada racimo representa una lista de plátanos. La bolsa es una lista de listas (bidimensional) y el racimo de plátanos es una lista (unidimensional).
En Dynamo, los datos de las listas se ponen en orden y el primer elemento de cada lista tiene un índice "0". A continuación, vamos a ver cómo se definen las listas en Dynamo y cómo se relacionan varias listas entre sí.
Algo que podría parecer extraño al principio es que el primer índice de una lista es siempre 0 en lugar de 1. Por lo tanto, cuando hablamos del primer elemento de una lista, en realidad nos referimos al elemento que corresponde al índice 0.
Por ejemplo, si tuviéramos que contar el número de dedos que tenemos en la mano derecha, es probable que contáramos del 1 al 5. Sin embargo, si tuviéramos que poner los dedos en una lista, Dynamo les asignaría los índices del 0 al 4. Aunque esto puede parecer un poco extraño para programadores principiantes, el índice de base cero es una práctica estándar en la mayoría de los sistemas de cálculo.
Tenga en cuenta que sigue habiendo cinco elementos en la lista; solo que la lista utiliza un sistema de recuento basado en cero. Y los elementos que se almacenan en la lista no solo pueden ser números. Pueden ser cualquier tipo de datos compatible con Dynamo, como puntos, curvas, superficies, familias, etc.
a. Índice
b. Punto
c. Elemento
A menudo, la forma más sencilla de echar un vistazo al tipo de datos almacenados en una lista es conectar un nodo Watch con la salida de otro nodo. Por defecto, el nodo Watch muestra automáticamente todos los índices en el lado izquierdo de la lista y los elementos de datos en el lado derecho.
Estos índices son elementos decisivos cuando se trabaja con listas.
Las entradas y las salidas, que pertenecen a las listas, varían en función del nodo de Dynamo que se utilice. Como ejemplo, vamos a utilizar una lista de cinco puntos y a conectar esta salida a dos nodos de Dynamo diferentes: PolyCurve.ByPoints y Circle.ByCenterPointRadius:
La entrada points de PolyCurve.ByPoints busca "Point[]". Esto representa una lista de puntos.
La salida de PolyCurve.ByPoints es una PolyCurve única creada a partir de una lista de cinco puntos.
La entrada centerPoint de Circle.ByCenterPointRadius solicita "Point".
La salida de Circle.ByCenterPointRadius es una lista de cinco círculos cuyos centros corresponden a la lista original de puntos.
Los datos de entrada de PolyCurve.ByPoints y Circle.ByCenterPointRadius son los mismos. Sin embargo, el nodo Polycurve.ByPoints nos proporciona una PolyCurve, mientras que el nodo Circle.ByCenterPointRadius nos proporciona cinco círculos con centros en cada punto. Esto resulta intuitivo: la PolyCurve se dibuja como una curva que conecta los cinco puntos, mientras que los círculos crean un círculo distinto en cada punto. Entonces, ¿qué ocurre con los datos?
Al colocar el cursor sobre la entrada points de Polycurve.ByPoints, vemos que la entrada busca "Point[]". Observe los corchetes que aparecen al final. Este elemento representa una lista de puntos y, para crear una PolyCurve, la entrada debe ser una lista para cada PolyCurve. Por lo tanto, este nodo condensará cada lista en una PolyCurve.
Por otra parte, la entrada centerPoint de Circle.ByCenterPointRadius solicita "Point". Este nodo busca un punto, como elemento, para definir el centro del círculo. Por este motivo, se obtienen cinco círculos a partir de los datos de entrada. Reconocer esta diferencia en las entradas de Dynamo ayuda a comprender mejor cómo funcionan los nodos al administrar los datos.
La correspondencia de datos es un problema sin una solución definitiva. Se produce cuando un nodo tiene acceso a entradas de distinto tamaño. El cambio del algoritmo de correspondencia de datos puede dar lugar a resultados muy diferentes.
Imagine un nodo que crea segmentos de línea entre puntos (Line.ByStartPointEndPoint). Tendrá dos parámetros de entrada y ambos proporcionarán coordenadas de punto:
La forma más sencilla es conectar las entradas una a una hasta que uno de los flujos se acabe. Esto se denomina algoritmo "Lista más corta". Este es el comportamiento por defecto de los nodos de Dynamo:
El algoritmo "Lista más larga" sigue conectando entradas, reutilizando elementos, hasta que todos los flujos se acaben:
Por último, el método "Producto vectorial" hace todas las conexiones posibles:
Como puede ver, existen diferentes métodos para dibujar líneas entre estos conjuntos de puntos. Las opciones de encaje se encuentran haciendo clic con el botón derecho en el centro de un nodo y eligiendo el menú "Encaje".
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
Para realizar una demostración de las operaciones de encaje desarrolladas a continuación, utilizaremos este archivo base para definir la lista más corta, la más larga y el producto vectorial.
Cambiaremos el encaje en Point.ByCoordinates, pero no cambiaremos nada más en el gráfico anterior.
Si se selecciona Lista más corta como opción de encaje (también la opción por defecto), se obtiene una línea diagonal básica compuesta por cinco puntos. Cinco puntos es la longitud de la lista menor, de modo que el encaje de la lista más corta se detiene cuando alcanza el final de una lista.
Al cambiar el encaje a la lista más larga, obtenemos una línea diagonal que se extiende verticalmente. Con el mismo método que el diagrama conceptual, el último elemento de la lista de cinco elementos se repetirá para alcanzar la longitud de la lista más larga.
Al cambiar el encaje a Producto vectorial, obtenemos todas las combinaciones entre cada lista, lo que nos proporciona una rejilla de puntos de 5 x 10. Esta es una estructura de datos equivalente al producto vectorial que se muestra en el diagrama de conceptos anterior, excepto que nuestros datos son ahora una lista de listas. Al conectar una PolyCurve, podemos ver que cada lista se ha definido por su valor X, lo que nos da una fila de líneas verticales.
Ahora que hemos establecido lo que es una lista, hablemos de las operaciones que podemos realizar en ella. Imagine una lista como un mazo de cartas. El mazo es la lista y cada carta representa un elemento.
Fotografía de Christian Gidlöf
¿Qué consultas se pueden realizar a partir de la lista? Esto permite acceder a las propiedades existentes.
¿Número de cartas del mazo? 52.
¿Número de palos? 4.
¿Material? Papel.
¿Longitud? 3,5" u 89 mm.
¿Anchura? 2,5" o 64 mm.
¿Qué acciones se pueden realizar en la lista? Estas acciones cambian la lista en función de una operación especificada.
Podemos barajar el mazo de cartas.
Podemos ordenar el mazo por valor.
Podemos ordenar el mazo por palo.
Podemos dividir el mazo.
Podemos dividir el mazo repartiendo manos individuales.
Podemos seleccionar una carta específica del mazo.
Todas las operaciones mencionadas anteriormente tienen nodos análogos de Dynamo para trabajar con listas de datos genéricos. En las lecciones siguientes, se muestran algunas de las operaciones fundamentales que podemos realizar en las listas.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
La imagen siguiente es el gráfico base en el que se dibujan líneas entre dos círculos para representar operaciones de lista básicas. Exploraremos cómo administrar los datos de una lista y mostraremos los resultados visuales a través de las acciones de lista que aparecen a continuación.
Comience con un bloque de código con un valor de
500;.Conéctelo a la entrada x de un nodo Point.ByCoordinates.
Conecte el nodo del paso anterior a la entrada origin de un nodo Plane.ByOriginNormal.
Con un nodo Circle.ByPlaneRadius, conecte el nodo del paso anterior en la entrada plane.
Mediante el bloque de código, designe un valor de
50;para el radio. Este es el primer círculo que crearemos.Con un nodo Geometry.Translate, desplace el círculo hacia arriba 100 unidades en la dirección Z.
Con un nodo Code Block, defina un rango de diez números entre 0 y 1 con esta línea de código:
0..1..#10;.Conecte el bloque de código del paso anterior a la entrada param de dos nodos Curve.PointAtParameter. Conecte Circle.ByPlaneRadius a la entrada "curve" del nodo superior y Geometry.Translate a la entrada curve del nodo situado debajo del mismo.
Con un nodo Line.ByStartPointEndPoint, conecte los dos nodos Curve.PointAtParameter.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
El nodo List.Count es sencillo: cuenta el número de valores de una lista y devuelve ese número. Este nodo presenta más detalles cuando se trabaja con listas de listas, pero eso lo veremos en las secciones siguientes.
El nodo **List.Count ****** devuelve el número de líneas del nodo Line.ByStartPointEndPoint. En este caso, el valor es 10, lo que coincide con el número de puntos creados a partir del nodo Code Block original.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
List.GetItemAtIndex es una forma fundamental de consultar un elemento de la lista.
En primer lugar, haga clic con el botón derecho en el nodo Line.ByStartPointEndPoint para desactivar su vista preliminar.
Con el nodo List.GetItemAtIndex, seleccionamos el índice "0" o el primer elemento de la lista de líneas.
Cambie el valor del control deslizante entre 0 y 9 para seleccionar un elemento diferente mediante List.GetItemAtIndex.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
List.Reverse invierte el orden de todos los elementos de una lista.
Para visualizar correctamente la lista de líneas invertida, cree más líneas. Para ello, cambie el nodo Code Block a
0..1..#50;.Duplique el nodo Line.ByStartPointEndPoint, inserte un nodo List.Reverse entre Curve.PointAtParameter y el segundo nodo Line.ByStartPointEndPoint.
Utilice los nodos Watch3D para obtener una vista preliminar de dos resultados diferentes. El primero muestra el resultado sin una lista invertida. Las líneas se conectan verticalmente con los puntos adyacentes. Sin embargo, la lista invertida conectará todos los puntos con la otra lista en el orden opuesto.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
List.ShiftIndices es una buena herramienta para crear torsiones o patrones helicoidales, así como cualquier otra manipulación de datos similar. Este nodo desplaza los elementos de una lista un determinado número de índices.
En el mismo proceso que la lista inversa, inserte un nodo List.ShiftIndices en Curve.PointAtParameter y Line.ByStartPointEndPointPoint.
Mediante un bloque de código, designe un valor de "1" para desplazar la lista un índice.
Observe que el cambio es sutil, pero todas las líneas del nodo Watch3D inferior se han desplazado un índice al conectarlas al otro conjunto de puntos.
Al cambiar el bloque de código a un valor superior, por ejemplo "30", observamos una diferencia significativa en las líneas diagonales. El desplazamiento funciona como el iris de una cámara en este caso, creando una torsión en la forma cilíndrica original.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
List.FilterByBooleanMask eliminará determinados elementos en función de una lista de operaciones booleanos o valores de "verdadero" o "falso".
Para crear una lista de valores de "verdadero" o "falso", necesitamos realizar un poco más de trabajo...
Mediante un bloque de código, defina una expresión con la sintaxis:
0..List.Count(list);. Conecte el nodo Curve.PointAtParameter a la entrada list. Veremos más detalles sobre esta configuración en el capítulo del bloque de código, pero la línea de código en este caso nos proporciona una lista que representa cada índice del nodo Curve.PointAtParameter.Mediante un nodo %** (módulo)**, conecte la salida del bloque de código en la entrada x y un valor de 4 en la salida y. Esto nos dará el resto al dividir la lista de índices entre 4. El módulo es un nodo muy útil para la creación de patrones. Todos los valores serán los restos posibles de 4: 0, 1, 2, 3.
En el nodo %** (módulo)**, sabemos que el valor 0 significa que el índice es divisible por 4 (0, 4, 8, etc.). Mediante un nodo ==, podemos probar la divisibilidad frente a un valor de "0".
El nodo Watch muestra solo esto; disponemos de un patrón verdadero/falso que dice: verdadero,falso,falso,falso,falso....
Mediante este patrón verdadero/falso, conéctelo a la entrada "mask" de dos nodos List.FilterByBooleanMask.
Conecte el nodo Curve.PointAtParameter en cada una de las entradas "list" de los nodos List.FilterByBooleanMask.
Las salidas de Filter.ByBooleanMask son "in" y "out". "In" representa los valores que tenían un valor de máscara de "Verdadero (True)" mientras que "out" representa los valores que tenían un valor de "Falso (False)". Al conectar las salidas "in" a las entradas startPoint y endPoint de un nodo Line.ByStartPointEndPoint, hemos creado una lista filtrada de líneas.
El nodo Watch3D indica que hay menos líneas que puntos. Hemos seleccionado solo el 25 % de los nodos filtrando solo los valores verdaderos.
Añadamos un nivel más a la jerarquía. Si utilizamos la baraja de cartas del ejemplo original y creamos un cuadro que contiene varias barajas, este representa ahora una lista de barajas y cada baraja representa una lista de cartas. Esta es una lista de listas. En esta sección, usaremos la siguiente analogía: el cuadro rojo mostrado a continuación contiene un rollo de monedas y cada rollo contiene una lista de peniques.
¿Qué consultas se pueden realizar a partir de la lista de listas? Esto permite acceder a las propiedades existentes.
¿Número de tipos de moneda? 2.
¿Valores de tipo de moneda? 0,01 y 0,25 USD.
¿Material de los cuartos de dólar? 75 % de cobre y 25 % de níquel.
¿Material de los peniques? 97,5 % de zinc y 2,5% de cobre.
¿Qué acciones se pueden realizar en la lista de listas? Esta acción cambia la lista de listas en función de la operación especificada.
Seleccione un montón específico de cuartos de dólar o peniques.
Seleccione un cuarto de dólar o un penique específicos.
Reorganice los montones de cuartos de dólar y peniques.
Junte los montones.
De nuevo, Dynamo tiene un nodo análogo para cada una de las operaciones anteriores. Como trabajamos con datos abstractos y no con objetos físicos, necesitamos un conjunto de reglas para controlar el desplazamiento hacia arriba y hacia abajo por la jerarquía de datos.
Al trabajar con listas de listas, los datos son complejos y se dividen en capas, pero esto ofrece la oportunidad de realizar operaciones paramétricas impresionantes. Vamos a desglosar los conceptos básicos y abordar algunas operaciones más en las lecciones mostradas a continuación.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
El concepto fundamental que se debe aprender en esta sección: Dynamo trata las listas como objetos en sí mismos. Esta jerarquía descendente se desarrolla teniendo en cuenta la programación orientada a objetos. En lugar de seleccionar subelementos con un comando como List.GetItemAtIndex, Dynamo seleccionará ese índice de la lista principal en la estructura de datos. Y ese elemento puede ser otra lista. Vamos a desglosar esto con una imagen de ejemplo:
Con el bloque de código, hemos definido dos intervalos:
0..2; 0..3;.Estos intervalos están conectados a un nodo Point.ByCoordinates con el encaje establecido en "Producto vectorial". De este modo, se crea una rejilla de puntos y también se devuelve una lista de listas como salida.
Observe que el nodo Watch proporciona tres listas con cuatro elementos en cada lista.
Cuando se utiliza List.GetItemAtIndex con un índice 0, Dynamo selecciona la primera lista y todo su contenido. Es posible que otros programas seleccionen el primer elemento de cada lista de la estructura de datos, pero Dynamo utiliza una jerarquía descendente al trabajar con los datos.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
Flatten elimina todos los niveles de datos de una estructura de datos. Esto resulta útil cuando las jerarquías de datos no son necesarias para la operación, pero puede resultar peligroso porque elimina información. En el siguiente ejemplo, se muestra el resultado de aplanar una lista de datos.
Inserte una línea de código para definir un intervalo en el bloque de código:
-250..-150..#4;.Al conectar el bloque de código a la entrada x e y de un nodo Point.ByCoordinates, se establece el encaje como "Producto vectorial" para obtener una rejilla de puntos.
En el nodo Watch, se muestra que tenemos una lista de listas.
Un nodo PolyCurve.ByPoints hará referencia a cada lista y creará la PolyCurve respectiva. En la vista preliminar de Dynamo, observe que tenemos cuatro PolyCurves que representan cada fila de la rejilla.
Al insertar un elemento Flatten antes del nodo de PolyCurve, hemos creado una única lista para todos los puntos. El nodo PolyCurve.ByPoints hace referencia a una lista para crear una curva y, como todos los puntos están en una lista, se obtiene una PolyCurve en zigzag que se ejecuta en toda la lista de puntos.
También existen opciones para aplanar niveles aislados de datos. Mediante el nodo List.Flatten, puede definir un número establecido de niveles de datos que aplanar desde la parte superior de la jerarquía. Esta es una herramienta muy útil si tiene problemas con estructuras de datos complejas que no son necesariamente pertinentes para el flujo de trabajo. Otra opción consiste en utilizar el nodo de aplanado como una función en List.Map. A continuación, examinaremos más detalladamente List.Map.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
En el modelado paramétrico, también hay ocasiones en las que se desea modificar la estructura de datos en una lista existente. Hay muchos nodos disponibles para ello y el elemento "Chop" es la versión más básica. Con "Chop", se puede dividir una lista en sublistas con un número establecido de elementos.
El comando "Chop" divide listas en función de una longitud de lista determinada. De alguna manera, el efecto de "Chop" es contrario al efecto de "Flatten": en lugar de eliminar una estructura de datos, se añaden nuevos niveles a ella. Es una herramienta útil para operaciones geométricas, como el ejemplo siguiente.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
List.Map/Combine aplica una función establecida a una lista de entradas, pero un nivel hacia abajo en la jerarquía. Las combinaciones son iguales a las asignaciones, excepto que las combinaciones pueden tener varias entradas correspondientes a la entrada de una determinada función.
Como introducción rápida, examinemos el nodo List.Count de una sección anterior.
El nodo List.Count realiza un recuento de todos los elementos de una lista. Utilizaremos esta opción para mostrar cómo funciona List.Map.
Inserte dos líneas de código en el bloque de código:
-50..50..#Nx; -50..50..#Ny;.Después de escribir este código, el bloque de código creará dos entradas para Nx y Ny.
Con dos controles deslizantes de enteros, defina los valores de Nx y Ny conectándolos al bloque de código.
Conecte cada línea del bloque de código a las entradas X e Y respectivas de un nodo Point.ByCoordinates. Haga clic con el botón derecho en el nodo, seleccione "Encaje" y, a continuación, elija "Producto vectorial". Esta acción crea una rejilla de puntos. Como hemos definido el intervalo de -50 a 50, se extiende la rejilla de Dynamo por defecto.
En el nodo Watch, se muestran los puntos creados. Observe la estructura de datos. Hemos creado una lista de listas. Cada lista representa una fila de puntos de la rejilla.
Enlace un nodo List.Count a la salida del nodo de visualización del paso anterior.
Conecte un nodo Watch a la salida de List.Count.
Observe que el nodo List.Count ofrece el valor 5. Este es igual a la variable "Nx", tal y como se ha definido en el bloque de código. ¿Por qué ocurre eso?
En primer lugar, el nodo Point.ByCoordinates utiliza la entrada "x" como entrada principal para crear listas. Si Nx es 5 y Ny es 3, se obtiene una lista de cinco listas, cada una con tres elementos.
Como Dynamo trata las listas como objetos en sí mismos, se aplica un nodo List.Count a la lista principal de la jerarquía. El resultado es el valor 5 o el número de listas de la lista principal.
Mediante un nodo List.Map, nos desplazaremos un nivel hacia abajo en la jerarquía y ejecutaremos una "función" en este nivel.
Observe que el nodo List.Count no tiene ninguna entrada. Se utiliza como una función, por lo que el nodo List.Count se aplicará a cada lista individual un nivel hacia abajo en la jerarquía. La entrada en blanco de List.Count corresponde a la entrada de lista de List.Map.
Los resultados de List.Count ahora proporcionan una lista de cinco elementos, cada uno con el valor 3. Esto representa la longitud de cada sublista.
En este ejercicio, utilizaremos List.Combine para mostrar cómo se puede utilizar para aplicar una función en listas de objetos independientes.
Configure primero dos listas de puntos.
Utilice el nodo Sequence para generar 10 valores, cada uno con un incremento de 10 pasos.
Conecte el resultado a la entrada x de un nodo Point.ByCoordinates. De este modo, se creará una lista de puntos en Dynamo.
Añada un segundo nodo Point.ByCoordinates al espacio de trabajo; utilice la misma salida de Sequence como entrada x, pero utilice un control deslizante de entero como entrada y, y establezca su valor en 31 (puede ser cualquier valor siempre que no se solape con el primer conjunto de puntos) para que los dos conjuntos de puntos no se solapen entre sí.
A continuación, utilizaremos List.Combine para aplicar una función a los objetos de dos listas independientes. En este caso, será una función de línea de dibujo sencilla.
Añada List.Combine al espacio de trabajo y conecte los dos conjuntos de puntos como entrada list0 y list1.
Utilice Line.ByStartPointEndPoint como función de entrada para List.Combine.
Una vez completado, los dos conjuntos de puntos se comprimen o se emparejan mediante una función Line.ByStartPointEndPoint y se devuelven 10 líneas en Dynamo.
Consulte el ejercicio de listas de n dimensiones para ver otro ejemplo de uso de List.Combine.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
Como alternativa a List.Map, la función List@Level permite seleccionar directamente el nivel de lista con el que se desea trabajar justo en el puerto de entrada del nodo. Esta función se puede aplicar a cualquier entrada de un nodo y le permitirá acceder a los niveles de las listas de forma más rápida y sencilla que con otros métodos. Solo tiene que indicar al nodo el nivel de la lista que desea utilizar como entrada y permitir que el nodo realice el resto.
En este ejercicio, utilizaremos la función List@Level para aislar un nivel específico de datos.
Comenzaremos con una rejilla 3D de puntos sencilla.
Como la rejilla se ha creado con un intervalo para X, Y y Z, sabemos que los datos están estructurados con tres capas: una lista X, una lista Y y una lista Z.
Estas capas existen en niveles diferentes. Los niveles se indican en la parte inferior de la burbuja de vista preliminar. Las columnas de niveles de la lista corresponden a los datos de la lista anterior para ayudar a identificar el nivel en el que se va a trabajar.
Los niveles de la lista se organizan en orden inverso, por lo que los datos de nivel inferior siempre se encuentran en "L1". Esto ayudará a garantizar que los gráficos funcionen según lo planeado, incluso aunque se realicen cambios en niveles superiores.
Para utilizar la función List@Level, haga clic en ">". En este menú, verá dos casillas de verificación.
Utilizar niveles: permite utilizar la función List@Level. Después de hacer clic en esta opción, podrá hacer clic por los niveles de lista de entrada que desee que utilice el nodo, además de seleccionarlos. Con este menú, puede probar rápidamente diferentes opciones de nivel haciendo clic arriba o abajo.
Mantener la estructura de listas: si se ha activado, dispondrá de la opción para mantener la estructura de niveles de esa entrada. En ocasiones, es posible que haya organizado deliberadamente los datos en sublistas. Al seleccionar esta opción, puede mantener la organización de listas intacta sin perder información.
Con nuestra sencilla rejilla 3D, podemos acceder a la estructura de listas y visualizarla mediante la activación o la desactivación de los niveles de la lista. Cada combinación de nivel de lista e índice devolverá un conjunto de puntos diferente de nuestro conjunto 3D original.
"@L2" en DesignScript nos permite seleccionar únicamente la lista en el nivel 2. La lista del nivel 2 con el índice 0 incluye solo el primer conjunto de puntos Y y devuelve solo la rejilla XZ.
Si cambiamos el filtro Nivel a "L1", podremos ver todos los elementos del primer nivel de lista. La lista del nivel 1 con el índice 0 incluye todos los puntos 3D en una lista plana.
Si intentamos realizar lo mismo para "L3", solo veremos los puntos del tercer nivel de lista. La lista del nivel 3 con el índice 0 incluye solo el primer conjunto de puntos Z y devuelve solo la rejilla XY.
Si intentamos realizar lo mismo para "L4", solo veremos los puntos del tercer nivel de lista. La lista del nivel 4 con el índice 0 incluye solo el primer conjunto de puntos X y devuelve solo la rejilla YZ.
Aunque este ejemplo específico también se puede crear con List.Map, List@Level simplifica considerablemente la interacción, lo que facilita el acceso a los datos del nodo. Consulte la siguiente comparación entre los métodos List.Map y List@Level:
Aunque ambos métodos nos brindarán acceso a los mismos puntos, el método List@Level permite alternar fácilmente entre capas de datos dentro de un único nodo
Para acceder a una rejilla de puntos con List.Map, necesitaremos un nodo List.GetItemAtIndex, junto con List.Map. Para cada nivel de lista que descendamos, necesitaremos utilizar un nodo List.Map adicional. Según la complejidad de las listas, esto podría requerir la adición de una gran cantidad de nodos List.Map al gráfico para acceder al nivel de información adecuado.
En este ejemplo, un nodo List.GetItemAtIndex con un nodo List.Map devuelve el mismo conjunto de puntos con la misma estructura de listas que List.GetItemAtIndex con "@L3" seleccionado.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
Transpose es una función fundamental al utilizar listas de listas. Al igual que en los programas de hojas de cálculo, una transposición intercambia las columnas y las filas de una estructura de datos. Mostraremos esto con una matriz básica a continuación y, en la siguiente sección, demostraremos cómo se puede utilizar una transposición para crear relaciones geométricas.
Suprimiremos los nodos List.Count del ejercicio anterior y pasaremos a alguna geometría para ver cómo se estructuraron los datos.
Conecte PolyCurve.ByPoints a la salida del nodo de inspección desde Point.ByCoordinates.
En la salida, se muestran cinco PolyCurves. Podemos ver las curvas en la vista preliminar de Dynamo. El nodo de Dynamo busca una lista de puntos (o, en este caso, una lista de listas de puntos) y crea una única PolyCurve a partir de ellas. Básicamente, cada lista se ha convertido en una curva en la estructura de datos.
Un nodo List.Transpose intercambiará todos los elementos con todas las listas de una lista de listas. Esto suena complicado, pero es la misma lógica que la transposición en Microsoft Excel: intercambiar las columnas y las filas en una estructura de datos.
Observe el resultado abstracto: la transposición ha cambiado la estructura de listas de cinco listas con tres elementos cada una a tres listas con cinco elementos cada una.
Observe el resultado geométrico: al utilizar PolyCurve.ByPoints, se obtienen tres PolyCurves en la dirección perpendicular a las curvas originales.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
En este ejercicio, se utiliza parte de la lógica establecida en el ejercicio anterior para editar una superficie. Nuestro objetivo es intuitivo, pero la navegación por la estructura de datos es más participativa. Deseamos articular una superficie mediante el desplazamiento de un punto de control.
Comience con la cadena de nodos anterior. Vamos a crear una superficie básica que abarque la rejilla de Dynamo por defecto.
Mediante el bloque de código, inserte estas dos líneas de código y conéctelas a las entradas u y v de Surface.PointAtParameter respectivamente:
-50..50..#3;-50..50..#5;.Asegúrese de establecer el encaje de Surface.PointAtParameter en "Producto vectorial".
En el nodo Watch, se muestra que tenemos una lista de tres listas con cinco elementos cada una.
En este paso, deseamos consultar el punto central de la rejilla que hemos creado. Para ello, seleccionaremos el punto medio de la lista central. Tiene sentido, ¿verdad?
Para confirmar que este es el punto adecuado, también podemos hacer clic por los elementos del nodo de visualización para confirmar que se trata del objetivo correcto.
Mediante el bloque de código, escribiremos una línea de código básica para consultar una lista de listas, como se indica a continuación:
points[1][2];.Con Geometry.Translate, desplazaremos el punto seleccionado hacia arriba en la dirección Z en 20 unidades.
Vamos a seleccionar la fila central de puntos con un nodo List.GetItemAtIndex. Nota: Al igual que en un paso anterior, también podemos consultar la lista con un bloque de código mediante una línea de
points[1];.
Hasta ahora, hemos consultado correctamente el punto central y lo hemos desplazado hacia arriba. Ahora deseamos insertar de nuevo este punto desplazado en la estructura de datos original.
Deseamos reemplazar primero el elemento de la lista que hemos aislado en un paso anterior.
Con List.ReplaceItemAtIndex, sustituiremos el elemento central mediante el uso de un índice "2" con el elemento de reemplazo conectado al punto desplazado (Geometry.Translate).
En la salida, se muestra que hemos introducido el punto desplazado en el elemento central de la lista.
Ahora que hemos modificado la lista, debemos volver a insertarla en la estructura de datos original: la lista de listas.
Siguiendo la misma lógica, utilice List.ReplaceItemAtIndex para reemplazar la lista central por la lista modificada.
Observe que los bloques de código que definen el índice de estos dos nodos son 1 y 2, que coinciden con la consulta original del bloque de código (points[1][2]).
Al seleccionar la lista en el índice 1, veremos la estructura de datos resaltada en la vista preliminar de Dynamo. Hemos fusionado correctamente el punto desplazado con la estructura de datos original.
Hay muchas formas de crear una superficie a partir de este conjunto de puntos. En este caso, vamos a crear una superficie mediante la solevación conjunta de curvas.
Cree un nodo NurbsCurve.ByPoints y conecte la nueva estructura de datos para crear tres curvas NURBS.
Conecte Surface.ByLoft a la salida desde NurbsCurve.ByPoints. Ahora tenemos una superficie modificada. Podemos cambiar el valor Z original de la geometría. Realice el traslado y vea cómo se actualiza la geometría.
Fotografía de .
Nota: Este ejercicio se ha creado con una versión anterior de Dynamo. Gran parte de la funcionalidad de List.Map se ha resuelto con la adición de la función List@Level . Para obtener más información, consulte a continuación.
Nota: Este ejercicio se ha creado con una versión anterior de Dynamo. Gran parte de la funcionalidad de List.Combine se ha resuelto con la adición de la función List@Level. Para obtener más información, consulte a continuación.
El modo de bloque de código abreviado utiliza "[]" para definir una lista. Esta es una forma mucho más rápida y fluida de crear una lista que con el nodo List.Create. El bloque de código se aborda con más detalle en . Consulte la imagen mostrada a continuación para observar cómo se puede definir una lista con varias expresiones mediante el bloque de código.
La abreviatura de bloque de código utiliza "[]" como método rápido y sencillo para seleccionar elementos específicos deseados en una estructura de datos compleja. Los bloques de código se describen con más detalle en el capítulo . Consulte la imagen mostrada a continuación para observar cómo se puede consultar una lista con varios tipos de datos con un bloque de código.
Adentrándonos aún más en el laberinto, vamos a agregar más niveles a la jerarquía. La estructura de datos puede ampliarse mucho más allá de una lista de listas bidimensional. Dado que las listas son elementos en sí mismos en Dynamo, podemos crear datos con tantas dimensiones como sea posible.
La analogía con la que trabajaremos aquí son las muñecas rusas. Cada lista se puede considerar como un contenedor que contiene varios elementos. Cada lista tiene sus propias propiedades y también se considera su propio objeto.
Un conjunto de muñecas rusas (fotografía de Zeta) es una analogía de las listas de n dimensiones. Cada capa representa una lista y cada lista contiene elementos. En el caso de Dynamo, cada contenedor puede tener varios contenedores dentro (que representan los elementos de cada lista).
Las listas de n dimensiones son difíciles de explicar visualmente, pero hemos configurado algunos ejercicios en este capítulo que se centran en trabajar con listas que van más allá de las dos dimensiones.
La asignación es, probablemente, la parte más compleja de la administración de datos en Dynamo y es especialmente relevante al trabajar con jerarquías de listas complejas. Con la serie de ejercicios incluidos a continuación, mostraremos cuándo utilizar la asignación y las combinaciones a medida que los datos se convierten en datos multidimensionales.
Las introducciones preliminares a List.Map y List.Combine se pueden encontrar en la sección anterior. En el último ejercicio de los que se incluyen a continuación, usaremos estos nodos en una estructura de datos compleja.
Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.
En el Apéndice, se incluye una lista completa de los archivos de ejemplo.
Este es el primero de una serie de tres ejercicios que se centra en la articulación de la geometría importada. Cada parte de esta serie de ejercicios aumentará en la complejidad de la estructura de datos.
Comencemos con el archivo .sat de la carpeta de archivos del ejercicio. Se puede acceder a este archivo mediante el nodo File Path.
Con Geometry.ImportFromSAT, la geometría se importa a nuestra vista preliminar de Dynamo como dos superficies.
En este sencillo ejercicio, vamos a trabajar con una de las superficies.
Seleccionaremos el índice de 1 para capturar la superficie superior. Esta acción se realiza con el nodo List.GetItemAtIndex.
Desactive la vista preliminar de geometría de la vista preliminar de Geometry.ImportFromSAT.
El siguiente paso es dividir la superficie en una rejilla de puntos.
1. Mediante el bloque de código, inserte estas dos líneas de código:
0..1..#10;0..1..#5;.2. Con Surface.PointAtParameter, conecte los dos valores del bloque de código a u y v. Cambie el encaje de este nodo a "Producto vectorial".
3. La salida muestra la estructura de datos, que también está visible en la vista preliminar de Dynamo.
A continuación, utilice los puntos del último paso para generar 10 curvas a lo largo de la superficie.
Para obtener información sobre cómo se organiza la estructura de datos, conectemos un nodo NurbsCurve.ByPoints a la salida de Surface.PointAtParameter.
Por ahora, puede desactivar la vista preliminar del nodo List.GetItemAtIndex para obtener un resultado más claro.
Un nodo List.Transpose básico cambiará las columnas y las filas de una lista de listas.
Al conectar la salida de List.Transpose a NurbsCurve.ByPoints, se obtienen cinco curvas que discurren horizontalmente a través de la superficie.
Puede desactivar la vista preliminar del nodo NurbsCurve.ByPoints en el paso anterior para obtener el mismo resultado en la imagen.
Aumentemos la complejidad. Supongamos que deseamos realizar una operación en las curvas creadas en el ejercicio anterior. Tal vez nos gustaría relacionar estas curvas con otra superficie y solevar entre ellas. Esto requiere más atención en la estructura de datos, pero la lógica subyacente es la misma.
Comience con un paso del ejercicio anterior, aislando la superficie superior de la geometría importada con el nodo List.GetItemAtIndex.
Con Surface.Offset, desfase la superficie con un valor de 10.
Del mismo modo que en el ejercicio anterior, defina un bloque de código con estas dos líneas de código:
0..1..#10;0..1..#5;.Conecte estas salidas a dos nodos Surface.PointAtParameter, cada uno con el encaje establecido en "Producto vectorial". Uno de estos nodos está conectado a la superficie original, mientras que el otro está conectado a la superficie desfasada.
Desactive la vista preliminar de estas superficies.
Como en el ejercicio anterior, conecte la salida a dos nodos NurbsCurve.ByPoints. En el resultado, se muestran las curvas correspondientes a dos superficies.
Con List.Create, podemos combinar los dos conjuntos de curvas en una lista de listas.
Observe en la salida que tenemos dos listas con 10 elementos cada una que representan cada conjunto de conexiones de curvas NURBS.
Al ejecutar Surface.ByLoft, podemos visualizar con claridad esta estructura de datos. El nodo soleva todas las curvas de cada sublista.
Desactive la vista preliminar del nodo Surface.ByLoft en el paso anterior.
Al utilizar List.Transpose, recuerde que estamos volteando todas las columnas y filas. Este nodo transferirá dos listas de diez curvas a diez listas de dos curvas. Ahora cada curva NURBS está relacionada con la curva contigua de la otra superficie.
Con Surface.ByLoft, llegamos a una estructura con nervios.
A continuación, mostraremos un proceso alternativo para lograr este resultado.
Antes de empezar, desactive la vista preliminar de Surface.ByLoft en el paso anterior para evitar confusiones.
Una alternativa a List.Transpose es utilizar List.Combine. Esta acción pondrá en funcionamiento un "combinador" en cada sublista.
En este caso, utilizaremos List.Create como "combinador", que creará una lista de cada elemento de las sublistas.
Con el nodo Surface.ByLoft, se obtienen las mismas superficies que en el paso anterior. La transposición es más fácil de utilizar en este caso, pero cuando la estructura de datos se vuelve más compleja, List.Combine es más fiable.
Retrocediendo unos pasos, si deseamos cambiar la orientación de las curvas en la estructura con nervios, debemos utilizar un nodo List.Transpose antes de conectar con NurbsCurve.ByPoints. Esto invertirá las columnas y las filas, lo que nos dará cinco nervios horizontales.
Ahora, vamos a ir un paso más allá. En este ejercicio, trabajaremos con ambas superficies importadas y crearemos una jerarquía de datos compleja. Aun así, nuestro objetivo es completar la misma operación con la misma lógica subyacente.
Comience con el archivo importado del ejercicio anterior.
Como en el ejercicio anterior, utilice el nodo Surface.Offset para desfasar por un valor de 10.
Observe en la salida que hemos creado dos superficies con el nodo de desfase.
Del mismo modo que en el ejercicio anterior, defina un bloque de código con estas dos líneas de código:
0..1..#20;0..1..#20;.Conecte estas salidas a dos nodos Surface.PointAtParameter, cada uno con el encaje establecido en "Producto vectorial". Uno de estos nodos está conectado a las superficies originales, mientras que el otro está conectado a las superficies desfasadas.
Como en el ejercicio anterior, conecte la salida a dos nodos NurbsCurve.ByPoints.
En la salida de NurbsCurve.ByPoints, observe que se trata de una lista de dos listas, que es más compleja que la del ejercicio anterior. Los datos se clasifican según la superficie subyacente, por lo que hemos añadido otro nivel a los datos estructurados.
Observe que los datos se vuelven más complejos en el nodo Surface.PointAtParameter. En este caso, tenemos una lista compuesta por listas de listas.
Antes de continuar, desactive la vista preliminar de las superficies existentes.
Con el nodo List.Create, se fusionan las curvas NURBS en una estructura de datos, lo que crea una lista de listas de listas.
Al conectar un nodo Surface.ByLoft, se obtiene una versión de las superficies originales, ya que cada una de ellas permanece en su propia lista tal como se crearon a partir de la estructura de datos original.
En el ejercicio anterior, pudimos utilizar List.Transpose para crear una estructura con nervios. Esto no funcionaría aquí. La transposición se debe utilizar en una lista bidimensional y, puesto que tenemos una lista tridimensional, una operación de "voltear columnas y filas" no funcionaría de manera tan sencilla. Recuerde que las listas son objetos, de modo que List.Transpose voltearía las listas sin sublistas, pero no voltearía las curvas NURBS ubicadas una lista más abajo en la jerarquía.
List.Combine funcionará mejor aquí. Debemos usar los nodos List.Map y List.Combine cuando trabajamos con estructuras de datos más complejas.
Al utilizar List.Create como "combinador", creamos una estructura de datos que funcionará mejor para nosotros.
La estructura de datos aún debe transponerse un paso hacia abajo en la jerarquía. Para ello, utilizaremos List.Map. Funciona como List.Combine, salvo que utiliza solo una lista de entrada, en lugar de dos o más.
La función que aplicaremos a List.Map es List.Transpose, que volteará las columnas y las filas de las sublistas de nuestra lista principal.
Por último, podemos solevar las curvas NURBS junto con una jerarquía de datos adecuada, lo que nos proporciona una estructura con nervios.
Añadamos profundidad a la geometría mediante un nodo Surface.Thicken con los parámetros de entrada, como se muestra.
Será recomendable una superficie que respalde también esta estructura, por lo que añada otro nodo Surface.ByLoft y utilice la primera salida de NurbsCurve.ByPoints de un paso anterior como entrada.
A medida que se sobrecargue la vista preliminar, desactive la vista preliminar de estos nodos. Para ello, haga clic con el botón derecho en cada uno de ellos y desactive la opción "vista preliminar" para ver mejor el resultado.
Y si engrosamos las superficies seleccionadas, la articulación está completa.
No es la mecedora más cómoda del mercado, pero hay muchos datos en ella.
En el último paso, vamos a invertir la dirección de los miembros estriados. Como ya usamos la transposición en el ejercicio anterior, haremos algo similar aquí.
Tenemos un nivel más en la jerarquía, por lo que debemos utilizar List.Map con la función List.Tranpose para cambiar la dirección de las curvas NURBS.
Es posible que deseemos aumentar el número de huellas. Para ello, podemos cambiar el bloque de código al siguiente:
0..1..#20;0..1..#30;.
La primera versión de la mecedora era elegante, así que nuestro segundo modelo ofrece una versión todoterreno del asiento reclinable.
