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.
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.
¿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.
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.
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.
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.
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
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
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".
Imagine que tiene un racimo de uvas. Si quisiera hacer zumo de uva, no las exprimirĂa una a una, sino que las pasarĂa todas por el exprimidor a la vez. La replicaciĂłn en Dynamo funciona de forma similar; en lugar de aplicar una operaciĂłn a un elemento cada vez, Dynamo puede aplicarla a toda una lista de una sola vez.
Los nodos de Dynamo reconocen automáticamente cuándo están trabajando con listas y aplican sus operaciones a varios elementos. Esto significa que no es necesario recorrer manualmente los elementos, simplemente ocurre. Pero, ¿cómo decide Dynamo cómo procesar las listas cuando hay más de una?
De una de las siguientes formas:
Digamos que está en la cocina haciendo zumos de frutas. Tiene una lista de frutas ({apple, orange, pear}) y una cantidad fija de agua para cada zumo (1 cup). Desea hacer zumo con cada fruta utilizando la misma cantidad de agua. En este caso, entra en juego la replicación cartesiana.
En Dynamo, esto significa que está introduciendo la lista de frutas en la entrada de frutas del nodo Juice.Maker, mientras que la entrada de agua se mantiene constante en 1 taza. A continuación, el nodo procesa cada fruta individualmente, combinándola con la cantidad fija de agua. El resultado es el siguiente:
apple juice with 1 cup of water orange juice with 1 cup of water pear juice with 1 cup of water
Cada fruta se combina con la misma cantidad de agua.
La replicaciĂłn Zip funciona de forma algo diferente. Si tuviera dos listas, una para frutas ({apple, orange, pear}) y otra para cantidades de azĂşcar ({2 tbsp, 3 tbsp, 1 tbsp}), la replicaciĂłn Zip combinarĂa los elementos correspondientes de cada lista. Por ejemplo:
apple juice with 2 tablespoons of sugar orange juice with 3 tablespoons of sugar pear juice with 1 tablespoon of sugar
Cada fruta se combina con su correspondiente cantidad de azĂşcar.
Para obtener más información sobre cómo funciona, consulte las .
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.
ÂżAnchura? 2,5" o 64 mm.
Podemos dividir el mazo repartiendo manos individuales.
Podemos seleccionar una carta especĂfica del mazo.
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.
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.
La salida de Circle.ByCenterPointRadius es una lista de cinco cĂrculos cuyos centros corresponden a la lista original de puntos.
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.
FotografĂa de Dori.
¿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.
¿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.
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.
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.
!
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.
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.
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.
!
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.
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 .
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
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.
!
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.
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.
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.
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.
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.
!
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 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];.
!
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).
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]).
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.
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.
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.
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.
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.
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.
En el nodo Watch, se muestra que tenemos una lista de tres listas con cinco elementos cada una.
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
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
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.
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.
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.Transpose 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.
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.
