En esta sección, presentamos los nodos básicos disponibles en la biblioteca de Dynamo que le ayudarán a crear su propio programa visual como un profesional.

• Geometría para el diseño computacional: ¿cómo puedo trabajar con elementos geométricos en Dynamo? Explore varias formas de crear geometrías simples o complejas a partir de primitivas.

• Los bloques de construcción de los programas: ¿qué son los "datos" y qué tipos fundamentales puedo utilizar en mis programas? Además, aprenda a incorporar operaciones matemáticas y lógicas en el flujo de trabajo de diseño.

• Diseño con listas: ¿cómo administro y coordino las estructuras de datos? Obtenga más información sobre el concepto de lista y utilícelo para administrar de forma eficaz los datos de diseño.

• Diccionarios de Dynamo: ¿qué son los diccionarios? Aprenda a utilizar diccionarios para buscar datos y valores específicos de resultados existentes.

Vector, plano y sistema de coordenadas en Dynamo

Vector

El vector es una representación de magnitud y dirección, que se puede mostrar como una flecha que se acelera hacia una dirección concreta a una velocidad determinada. Este es un componente clave de los modelos de Dynamo. Tenga en cuenta que, como se encuentran en la categoría abstracta de "ayudas", cuando creamos un vector, no aparecerá nada en la vista preliminar en segundo plano.

1. Podemos utilizar una línea como sustituto de una vista preliminar del vector.

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.

Plano

Un plano es una superficie bidimensional que puede tener el aspecto de una superficie plana que se extiende de forma indefinida. Cada plano tiene un origen y una dirección X, Y y Z (arriba).

1. Aunque son abstractos, los planos tienen una posición de origen, por lo que podemos localizarlos en el espacio.

2. En Dynamo, los planos se renderizan en la vista preliminar en segundo plano.

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.

Sistema de coordenadas

Un sistema de coordenadas permite determinar la ubicación de puntos u otros elementos geométricos. En la imagen siguiente, se explica el aspecto que tiene en Dynamo y lo que representa cada color.

1. Aunque son abstractos, los sistemas de coordenadas también tienen una posición de origen para poder localizarlos en el espacio.

2. En Dynamo, los sistemas de coordenadas se renderizan en la vista preliminar en segundo plano como un punto (origen) y líneas que definen los ejes (X es rojo, Y es verde y Z es azul según la convenció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.

Información más detallada sobre...

Los vectores, los planos y los sistemas de coordenadas constituyen el grupo principal de los tipos de geometría abstracta. Nos ayudan a definir la ubicación, la orientación y el contexto espacial de otra geometría que describe formas. Si, por ejemplo, digo que estoy en la ciudad de Nueva York en la calle 42 con Broadway (sistema de coordenadas), de pie en el nivel de la calle (plano), mirando al norte (vector), acabo de usar estas "ayudas" para definir dónde estoy. Lo mismo sucede con la carcasa de un teléfono o un rascacielos; necesitamos este contexto para desarrollar el modelo.

Vector

Un vector es una cantidad geométrica que describe la dirección y la magnitud. Los vectores son abstractos, es decir, representan una cantidad, no un elemento geométrico. Los vectores se pueden confundir fácilmente con los puntos porque ambos están compuestos de una lista de valores. Aunque existe una diferencia clave: los puntos describen una posición en un sistema de coordenadas específico, mientras que los vectores describen una diferencia relativa en la posición, lo que equivale a la "dirección".

Si la idea de la diferencia relativa es confusa, piense en el Vector AB como "Estoy de pie en el punto A, mirando hacia el punto B". La dirección, de aquí (A) a allí (B), es el vector.

Este es un desglose de los vectores en sus diferentes partes mediante la misma notación AB:

1. El punto inicial del vector se denomina base.

2. El **punto final **del vector se denomina punta o sentido.

3. El vector AB no es igual al vector BA, que señalaría la dirección opuesta.

Si desea ver un momento cómico en relación con los vectores (y su definición abstracta), eche un vistazo al clásico de la comedia "Aterriza como puedas" y escuche la siguiente línea de diálogo burlona bastante citada:

Bien, bien. ¿Cuál es nuestro vector, Víctor?

Plano

Los planos son "ayudas" abstractas bidimensionales. En concreto, los planos son conceptualmente un "llano" que se extiende infinitamente en dos direcciones. Por lo general, se renderizan como un rectángulo más pequeño próximo a su origen.

Es posible que piense: "¡Un momento! ¿Origen? Eso suena a un sistema de coordenadas... como el que utilizo para modelar en el software de CAD".

Y tiene razón. La mayoría del software de modelado aprovecha los planos de construcción o "niveles" para definir un contexto local bidimensional en el que dibujar. Es posible que XY, XZ, YZ, o Norte, Sudeste o Nivel le resulten términos más familiares. Todos son planos que definen un contexto "llano" infinito. Los planos no tienen profundidad, pero nos ayudan también a describir la dirección:

Sistema de coordenadas

Si estamos familiarizados con los planos, estamos a un paso de comprender los sistemas de coordenadas. Un plano tiene las mismas partes que un sistema de coordenadas, siempre que se trate de un sistema de coordenadas euclidiano o XYZ estándar.

Sin embargo, hay otros sistemas de coordenadas alternativos como, por ejemplo, cilíndricos o esféricos. Como veremos en las secciones posteriores, los sistemas de coordenadas también se pueden aplicar a otros tipos de geometría para definir una posición en esa geometría.

Añadir sistemas de coordenadas alternativos: cilíndricos y esféricos.

Curvas en Dynamo

¿Qué es una curva?

Las curvas son el primer tipo de datos geométricos abordado que presenta un conjunto más familiar de propiedades descriptivas de forma... ¿Qué grado de curvatura o rectitud? ¿Cómo de larga o corta? Recuerde que los puntos siguen siendo nuestros bloques de construcción para definir cualquier elemento, desde una línea a una spline y todos los tipos de curva intermedios.

1. Línea

2. Polilínea

3. Arco

4. Círculo

5. Elipse

6. Curva NURBS

7. PolyCurve

Línea

Curva NURBS

NURBS es un modelo que se utiliza para representar curvas y superficies con precisión. Una curva de seno en Dynamo mediante dos métodos diferentes para crear curvas NURBS a fin de comparar los resultados.

1. NurbsCurve.ByControlPoints utiliza la lista de puntos como puntos de control.

2. NurbsCurve.ByPoints dibuja una curva a través de la lista de puntos.

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.

Información más detallada sobre...

Curvas

El término curva suele ser un comodín para todo tipo de formas curvas (incluso aunque adopten un aspecto recto). La curva en su sentido primordial es la categorización principal de todos estos tipos de forma: líneas, círculos, splines, etc. Desde una perspectiva más técnica, una curva describe cada punto posible que se puede encontrar introduciendo "t" en un conjunto de funciones, que pueden ir desde la sencilla función (x = -1.26*t, y = t) hasta funciones que implican cálculo. Independientemente del tipo de curva con el que trabajemos, este parámetro denominado "t" es una propiedad que se puede evaluar. Además, independientemente del aspecto de la forma, todas las curvas tienen también un punto inicial y un punto final, que se alinean de forma coincidente con los valores t mínimo y máximo utilizados para crear la curva. Esto también nos ayuda a comprender su direccionalidad.

Es importante tener en cuenta que Dynamo presupone que el dominio de los valores "t" de una curva se entiende como de 0.0 a 1.0.

Todas las curvas también poseen una serie de propiedades o características que se pueden utilizar para describirlas o analizarlas. Cuando la distancia entre los puntos inicial y final es cero, la curva es "cerrada". Además, cada curva tiene varios puntos de control; si todos estos puntos se encuentran en el mismo plano, la curva es "plana". Algunas propiedades se aplican a la curva como un todo, mientras que otras solo se aplican a puntos específicos a lo largo de la curva. Por ejemplo, la planaridad es una propiedad global, mientras que un vector tangente en un valor t especificado es una propiedad local.

Líneas

Las líneas son la forma más sencilla de las curvas. Puede que no parezcan curvadas, pero en realidad son curvas, solo que no tienen ninguna curvatura. Existen varias formas diferentes de crear líneas; la más intuitiva desde el punto A al punto B. La forma de la línea AB se dibujará entre los puntos, pero matemáticamente se extiende infinitamente en ambas direcciones.

Cuando conectamos dos líneas, tenemos una polilínea. Aquí tenemos una representación directa de lo que es un punto de control. Si se edita cualquiera de estas ubicaciones de punto, cambiará la forma de la polilínea. Si la polilínea está cerrada, se trata de un polígono. Si todas las longitudes de arista del polígono son iguales, se describe como normal.

Arcos, círculos, arcos elípticos y elipses

A medida que se añade más complejidad a las funciones paramétricas que definen una forma, podemos ir un poco más allá de la línea y crear un arco, un círculo, un arco elíptico o una elipse mediante la descripción de uno o dos radios. Las diferencias entre la versión de arco y el círculo o la elipse se encuentran en si la forma está cerrada o no.

NURBS + PolyCurves

NURBS (Non-uniform Rational Basis Splines, splines de base racionales no uniformes) son representaciones matemáticas que pueden modelar con precisión cualquier forma, desde líneas, círculos, arcos o rectángulos bidimensionales sencillos a la curva orgánica tridimensional de forma libre más compleja. Gracias a su flexibilidad (hay relativamente pocos puntos de control, aunque la interpolación suave se basa en parámetros de grado) y su precisión (vinculada a complejas operaciones matemáticas), los modelos NURBS se pueden utilizar en cualquier proceso, desde la ilustración y la animación hasta la fabricación.

Grado: el grado de la curva determina el rango de influencia que los puntos de control tienen en una curva; cuanto mayor sea el grado, mayor será el rango. El grado es un número entero positivo. Este número suele ser 1, 2, 3 o 5, pero puede ser cualquier número entero positivo. Las líneas y las polilíneas NURBS suelen ser de grado 1 y la mayoría de las curvas de forma libre son de grado 3 o 5.

Puntos de control: los puntos de control son una lista de puntos de al menos grado+1. Una de las formas más fáciles de cambiar la forma de una curva NURBS es desplazar sus puntos de control.

Grosor: los puntos de control tienen un número asociado denominado grosor. Los grosores son normalmente números positivos. Cuando todos los puntos de control de una curva tienen el mismo grosor (normalmente, 1), la curva se denomina no racional; de lo contrario, la curva se denomina racional. La mayoría de las curvas NURBS son no racionales.

Nudos: los nudos son una lista de números (grado+N-1), donde N es el número de puntos de control. Los nudos se utilizan junto con los grosores para controlar la influencia de los puntos de control en la curva resultante. Por ejemplo, los nudos se pueden utilizar para crear puntos de torsión en determinados puntos de la curva.

1. Grado = 1

2. Grado = 2

3. Grado = 3

Una vez que estemos listos para profundizar en el desarrollo de programas visuales, necesitaremos una mejor comprensión de los componentes de construcción que utilizaremos. En este capítulo, se presentan conceptos fundamentales sobre los datos: el contenido que recorre los cables de nuestro programa de Dynamo.

Mallas en Dynamo

¿Qué es una malla?

En el campo del modelado computacional, las mallas son una de las formas más generalizadas de representación de la geometría 3D. Por lo general, la geometría de malla se compone de una colección de cuadriláteros o triángulos; puede ser una alternativa ligera y flexible al trabajo con NURBS. Las mallas se utilizan en todo, desde la renderización y las visualizaciones hasta la fabricación digital y la impresión en 3D.

Elementos de malla

Dynamo define mallas mediante una estructura de datos de cara-vértice. En su nivel más básico, esta estructura es simplemente un conjunto de puntos que se agrupan en polígonos. Los puntos de una malla se denominan vértices, mientras que los polígonos similares a superficies se denominan caras.

Para crear una malla, se necesita una lista de vértices y un sistema de agrupación de esos vértices en caras denominado grupo de índice.

1. Lista de vértices

2. Lista de grupos de índice para definir caras

Kit de herramientas de malla

Las funciones de malla de Dynamo se pueden ampliar mediante la instalación del paquete de Kit de herramientas de malla. El Kit de herramientas de malla de Dynamo proporciona herramientas para importar mallas desde formatos de archivo externos, crear una malla a partir de objetos de geometría de Dynamo y generar manualmente mallas mediante sus vértices e índices.

La biblioteca también proporciona herramientas para modificar y reparar mallas, o extraer cortes horizontales para su uso en la fabricación.

Consulte los casos reales del Kit de herramientas de malla para obtener un ejemplo de cómo utilizar este paquete.

Información más detallada sobre...

Malla

Una malla es un conjunto de cuadriláteros y triángulos que representa una superficie o una geometría sólida. Al igual que los sólidos, la estructura de un objeto de malla incluye vértices, aristas y caras. Existen propiedades adicionales que hacen que las mallas sean únicas como, por ejemplo, las normales.

1. Vértices de malla.

2. Aristas de malla. * Las aristas con una única cara adyacente se denominan "desnudas". El resto de aristas están "vestidas".

3. Caras de malla.

Vértices + normales de vértice

Los vértices de una malla son simplemente una lista de puntos. El índice de los vértices es muy importante al crear una malla u obtener información sobre la estructura de una malla. Para cada vértice, también existe una normal de vértice (vector) correspondiente que describe la dirección media de las caras enlazadas y ayuda a comprender la orientación de "entrada" y "salida" de la malla.

1. Vértices

2. Normales de vértice

Caras

Una cara es una lista ordenada de tres o cuatro vértices. Por lo tanto, la representación de la "superficie" de una cara de malla se deduce en función de la posición de los vértices que se están indexando. Ya tenemos la lista de vértices que componen la malla, por lo que, en lugar de proporcionar puntos individuales para definir la malla, solo tenemos que usar el índice de los vértices. Esto también nos permite utilizar el mismo vértice en más de una cara.

1. Una cara cuadrática compuesta por los índices 0, 1, 2 y 3.

2. Una cara triangular creada con los índices 1, 4 y 2. Tenga en cuenta que se puede cambiar el orden de los grupos de índice; siempre que la secuencia se ordene en el sentido contrario a las agujas del reloj, la cara se definirá correctamente.

Mallas frente a superficies NURBS

¿En qué se diferencia la geometría de malla de la geometría NURBS? ¿Cuándo es recomendable utilizar una en lugar de la otra?

Parametrización

En un capítulo anterior, vimos que las superficies NURBS se definen mediante una serie de curvas NURBS que se dirigen en dos direcciones. Estas direcciones se etiquetan como U y V, y permiten que una superficie NURB se parametrice de acuerdo con un dominio de superficie bidimensional. Las curvas propiamente dichas se almacenan como ecuaciones en el ordenador, lo que permite calcular las superficies resultantes con un grado de precisión arbitrariamente pequeño. Sin embargo, puede ser difícil combinar varias superficies NURBS. La unión de dos superficies NURBS genera una PolySurface, donde las distintas secciones de la geometría tendrán diferentes parámetros UV y definiciones de curva.

1. Superficie

2. Curva isoparamétrica (línea isoparamétrica)

3. Punto de control de superficie

4. Polígono de control de superficie

5. Punto isométrico

6. Marco de superficie

7. Malla

8. Arista desnuda

9. Red de malla

10. Aristas de malla

11. Normal de vértice

12. Cara de malla/normal de cara de malla

Por otra parte, las mallas están formadas por un número específico de caras y vértices definidos exactamente. La red de vértices no se puede definir normalmente mediante coordenadas UV sencillas, y como las caras son independientes, la cantidad de precisión se incorpora en la malla y solo se puede cambiar mediante el ajuste preciso de la malla y la adición de más caras. La falta de descripciones matemáticas permite que las mallas gestionen con mayor flexibilidad geometrías complejas dentro de una única malla.

Influencia local frente a global

Otra diferencia importante es la extensión en la que un cambio local en la geometría de malla o NURBS afecta a toda la forma. El desplazamiento de un vértice de una malla solo afecta a las caras adyacentes a ese vértice. En las superficies NURBS, la extensión de la influencia es más complicada y depende del grado de la superficie, así como de los grosores y los nudos de los puntos de control. Sin embargo, por lo general, al desplazar un único punto de control en una superficie NURBS, se produce un cambio más suave y extensivo en la geometría.

1. Superficie NURBS: el desplazamiento de un punto de control tiene una influencia que se extiende a lo largo de la forma.

2. Geometría de malla: el desplazamiento de un vértice solo influye en los elementos adyacentes.

Una analogía que puede resultar útil es comparar una imagen vectorial (compuesta de líneas y curvas) con una imagen ráster (compuesta de píxeles individuales). Si amplía la vista de una imagen vectorial, las curvas permanecen nítidas y claras, mientras que si se amplía la vista de una imagen ráster, los píxeles individuales aumentan de tamaño. En esta analogía, las superficies NURBS se pueden comparar con una imagen vectorial porque existe una relación matemática fluida, mientras que una malla se comporta de forma similar a una imagen ráster con una resolución establecida.

Los datos son el contenido de nuestros programas. Viajan a través de cables proporcionando entradas a los nodos, donde se procesan y se transforman en una nueva forma de datos de salida. Revisemos la definición de los datos, cómo se estructuran y cómo utilizarlos en Dynamo.

¿Qué son los datos?

Los datos son un conjunto de valores de variables cualitativas o cuantitativas. La forma de datos más sencilla son números como, por ejemplo, 0, 3.14 o 17. Sin embargo, los datos también puede ser de diferentes tipos: una variable que representa números cambiantes (height); caracteres (myName); geometría (Circle), o una lista de elementos de datos (1,2,3,5,8,13,...).

En Dynamo, añadimos o introducimos datos en los puertos de entrada de los nodos; podemos tener datos sin acciones, pero nos hacen falta datos para procesar las acciones que representan nuestros nodos. Cuando se añade un nodo al espacio de trabajo, si no se le proporciona ninguna entrada, el resultado será una función y no el resultado de la acción en sí.

1. Datos simples.

2. Datos y una acción (un nodo); se ejecuta correctamente.

3. Una acción (un nodo) sin entradas de datos; devuelve una función genérica.

Nulo: ausencia de datos

Cuidado con los valores nulos. El tipo 'null' representa la ausencia de datos. Aunque se trata de un concepto abstracto, es probable que esto ocurra mientras trabaja con programación visual. Si una acción no crea un resultado válido, el nodo devolverá un valor "null".

Comprobar si existen valores "null" y eliminarlos de la estructura de datos es una parte crucial para crear programas sólidos.

Estructuras de datos

Cuando somos programadores visuales, podemos generar una gran cantidad de datos rápidamente y requerir un medio de administración de su jerarquía. Esta es la función de las estructuras de datos, los esquemas organizativos en los que almacenamos los datos. Las características específicas de las estructuras de datos y su uso varían de un lenguaje de programación a otro.

En Dynamo, se añade jerarquía a los datos a través de las listas. Exploraremos esto en profundidad en capítulos posteriores, pero empecemos con algo sencillo.

Una lista representa una colección de elementos colocados en una estructura de datos:

• Tengo cinco dedos (elementos) en la mano (lista).

• Hay diez casas (elementos) en mi calle (lista).

1. Un nodo Number Sequence define una lista de números mediante entradas start, amount y step. Con estos nodos, hemos creado dos listas independientes de diez números, una que abarca de 100 a 109 y otra de 0 a 9.

2. El nodo List.GetItemAtIndex selecciona un elemento de una lista en un índice determinado. Al seleccionar 0, se obtiene el primer elemento de la lista (100 en este caso).

3. Al aplicar el mismo proceso a la segunda lista, obtenemos un valor de 0, el primer elemento de la lista.

4. Ahora combinamos las dos listas en una mediante el nodo List.Create. Observe que el nodo crea una lista de listas. Esto cambia la estructura de los datos.

5. Al volver a utilizar List.GetItemAtIndex, con el índice establecido en 0, se obtiene la primera lista de la lista de listas. Esto es lo que significa tratar una lista como un elemento, lo cual es ligeramente diferente de otros lenguajes de secuencias de comandos. En capítulos posteriores, nos adentraremos más en la manipulación de listas y la estructura de datos.

El concepto clave para comprender la jerarquía de datos en Dynamo es que en relación con la estructura de datos, las listas se consideran elementos. En otras palabras, Dynamo funciona con un proceso descendente para comprender las estructuras de datos. Implicaciones Veámoslo con un ejemplo.

Ejercicio: uso de datos para crear una cadena de cilindros

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 primer ejemplo, vamos a ensamblar un cilindro vaciado que recorre la jerarquía de geometría tratada en esta sección.

Parte I: configurar el gráfico de un cilindro con algunos parámetros modificables

1. Añada Point.ByCoordinates: después de añadir el nodo al lienzo, se muestra un punto en el origen de la rejilla de vista preliminar de Dynamo. Los valores por defecto de las entradas x, y y z son 0,0, lo que nos da un punto en esta ubicación.

2. Plane.ByOriginNormal: el siguiente paso en la jerarquía de geometría es un plano. Existen varias formas de construir un plano; utilizaremos un origen y una normal para la entrada. El origen es el nodo de punto creado en el paso anterior.

Vector.ZAxis: es un vector unificado en la dirección Z. Observe que no hay entradas, solo un vector con un valor [0,0,1]. Se utiliza como la entrada normal para el nodo Plane.ByOriginNormal. Esto nos proporciona un plano rectangular en la vista preliminar de Dynamo.

3. Circle.ByPlaneRadius: ascendiendo en la jerarquía, ahora creamos una curva a partir del plano del paso anterior. Después de conectar el nodo, se obtiene un círculo en el origen. El radio por defecto del nodo es el valor de 1.

4. Curve.Extrude: ahora vamos a hacer que este elemento crezca dándole profundidad y añadiendo la tercera dimensión. Este nodo crea una superficie a partir de una curva mediante su extrusión. La distancia por defecto en el nodo es 1 y debería aparecer un cilindro en la ventana gráfica.

5. Surface.Thicken: este nodo nos proporciona un sólido cerrado mediante el desfase de la superficie con la distancia especificada y el cierre de la forma. El valor de grosor por defecto es 1 y vemos un cilindro vaciado en la ventana gráfica en línea con estos valores.

6. Number Slider: en lugar de utilizar los valores por defecto para todas estas entradas, vamos a añadir algún control paramétrico al modelo.

Edición del dominio: después de añadir el control deslizante de número al lienzo, haga clic en el signo de intercalación situado en la parte superior izquierda para ver las opciones de dominio.

Min/Max/Step: cambie los valores min, max y step a 0, 2 y 0,01 respectivamente. Esto lo hacemos para controlar el tamaño de la geometría global.

7. Nodos Number Slider: en todas las entradas por defecto, copiemos y peguemos este control deslizante de número (seleccione el control deslizante, pulse Ctrl+C y, a continuación, Ctrl+V) varias veces hasta que todas las entradas con valores por defecto tengan un control deslizante. Algunos de los valores del control deslizante tendrán que ser mayores que cero para que la definición funcione (es decir, para que una superficie se engrose, se necesita una profundidad de extrusión).

8. Hemos creado un cilindro paramétrico vaciado con estos controles deslizantes. Pruebe a modificar algunos de estos parámetros y ver cómo la geometría se actualiza de forma dinámica en la ventana gráfica de Dynamo.

Nodos Number Slider: al avanzar en este ejemplo, hemos añadido muchos controles deslizantes al lienzo y debemos limpiar la interfaz de la herramienta que acabamos de crear. Haga clic con el botón derecho en un control deslizante, seleccione "Cambiar nombre" y cambie cada control deslizante al nombre apropiado para su parámetro (Grosor, Radio, Altura, etc.).

Parte II: llenar la matriz de cilindros de la parte I

9. En este punto, hemos creado un fantástico elemento de cilindro engrosado. Se trata de un objeto actualmente; veamos cómo crear una matriz de cilindros que permanezca enlazada de forma dinámica. Para ello, vamos a crear una lista de cilindros en lugar de trabajar con un único elemento.

Adición (+): nuestro objetivo es añadir una fila de cilindros junto al cilindro que hemos creado. Si se desea añadir un cilindro adyacente al actual, se deben tener en cuenta el radio del cilindro y el grosor del vaciado. Para obtener este número, se añaden los dos valores de los controles deslizantes.

10. Este paso es más complejo, por lo que pasaremos por él más lentamente. El objetivo es crear una lista de números que defina las ubicaciones de cada cilindro en una fila.

a. Multiplicación: deseamos multiplicar primero el valor del paso anterior por 2. El valor del paso anterior representa un radio y queremos mover el cilindro por el diámetro completo.

b. Number Sequence: creamos una matriz de números con este nodo. La primera entrada es el nodo de multiplicación del paso anterior en el valor step. El valor start se puede establecer en 0,0 mediante un nodo Number.

c. Control deslizante de enteros: para el valor amount, conectamos un control deslizante de entero. Esto definirá cuántos cilindros se crean.

d. Salida: esta lista muestra la distancia desplazada para cada cilindro de la matriz y la manejan paramétricamente los controles deslizantes originales.

11. Este paso es bastante sencillo: conecte la secuencia definida en el paso anterior a la entrada x del Point.ByCoordinates original. De este modo, se sustituye el control deslizante pointX, que se puede suprimir Ahora vemos una matriz de cilindros en la ventana gráfica (asegúrese de que el control deslizante de enteros sea mayor que 0).

12. La cadena de cilindros sigue enlazada dinámicamente a todos los controles deslizantes. Mueva cada uno de los controles deslizantes para ver cómo se actualiza la definición.

Geometría en Dynamo Sandbox

La geometría es el idioma del diseño. Cuando un lenguaje o un entorno de programación tienen un núcleo de geometría, podemos descubrir las posibilidades del diseño de modelos precisos y sólidos, la automatización de las rutinas de diseño y la creación de iteraciones de diseño con algoritmos.

Conocer los tipos de geometría y cómo se relacionan nos permitirá desplazarnos por la colección de nodos de geometría disponibles en la biblioteca. Los nodos de geometría se organizan alfabéticamente en lugar de jerárquicamente; aquí se muestran de forma similar a su presentación en la interfaz de Dynamo.

Además, la creación de modelos en Dynamo y la conexión de la vista preliminar de lo que aparece en la vista preliminar en segundo plano al flujo de datos del gráfico deberían ser procesos más intuitivos con el tiempo.

1. Observe el supuesto sistema de coordenadas renderizado por la rejilla y los ejes coloreados.

2. Los nodos seleccionados renderizarán la geometría correspondiente (si el nodo crea la geometría) en segundo plano con el color resaltado.

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 de geometría

La geometría se define tradicionalmente como el estudio de la forma, el tamaño y la posición relativa de las figuras y las propiedades del espacio. Este campo tiene una historia muy rica que se remonta a miles de años. Con la llegada y la popularización de la informática, disponemos de una poderosa herramienta para definir, explorar y generar geometría. Ahora es muy fácil calcular el resultado de interacciones geométricas complejas y lo hacemos de forma casi transparente.

Si tiene curiosidad por comprobar lo diversa y compleja que puede ser la geometría mediante la potencia de su ordenador, realice una búsqueda rápida en la web del conejito de Stanford (o "Stanford Bunny"), un modelo canónico que se utiliza para probar algoritmos.

Comprender la geometría en el contexto de los algoritmos, la informática y la complejidad puede parecer una tarea abrumadora. Sin embargo, existen algunos principios clave y relativamente sencillos que podemos establecer como base para empezar a crear aplicaciones más avanzadas:

1. La geometría se compone de datos: para el ordenador y Dynamo, un conejito no se diferencia mucho de un número.

2. La geometría se basa en la abstracción: sobre todo, los elementos geométricos se describen mediante números, relaciones y fórmulas dentro de un sistema de coordenadas espacial específico.

3. La geometría tiene una jerarquía: los puntos se combinan para crear líneas, las líneas se unen para crear superficies, etc.

4. La geometría describe simultáneamente la parte y el todo: cuando tenemos una curva, se tiene en cuenta tanto la forma como todos los posibles puntos a lo largo de ella.

En la práctica, estos principios nos indican que debemos tener en cuenta con qué tipo de geometría estamos trabajando (qué tipo de geometría, cómo se creó, etc.) para poder crear, descomponer y recomponer de forma fluida diferentes geometrías a medida que desarrollamos modelos más complejos.

Recorrido por la jerarquía

Dediquemos un momento a observar la relación entre las descripciones abstractas y jerárquicas de la geometría. Como estos dos conceptos están relacionados, pero esto no es siempre evidente al principio, podemos encontrarnos rápidamente con un bloqueo conceptual una vez que empezamos a desarrollar flujos de trabajo o modelos más profundos. Para empezar, vamos a usar la dimensionalidad como un sencillo descriptor del "material" que modelamos. El número de dimensiones necesarias para describir una forma nos muestra cómo organizar la forma en que la geometría se organiza jerárquicamente.

1. Un punto (definido por coordenadas) no tiene ninguna dimensión asociada; son solo números que describen cada coordenada.

2. Una línea (definida por dos puntos) tiene ahora una dimensión; podemos "recorrer" la línea hacia delante (dirección positiva) o hacia atrás (dirección negativa).

3. Un plano (definido por dos líneas) tiene dos dimensiones: es posible desplazarse más a la izquierda o más a la derecha.

4. Un cubo (definido por dos planos) tiene tres dimensiones: se puede definir una posición hacia arriba o hacia abajo.

La dimensionalidad es un método práctico para empezar a organizar en categorías la geometría, pero no es necesariamente el mejor. Después de todo, no modelamos solo puntos, líneas, planos y cuadros, ¿qué ocurre si deseo utilizar un elemento curvado? Además, existe toda una categoría adicional de tipos geométricos que son totalmente abstractos; por ejemplo, definen propiedades como la orientación, el volumen o las relaciones entre las partes. No podemos realmente agarrar un vector, así que, ¿cómo lo definimos en relación con lo que vemos en el espacio? Una categorización más detallada de la jerarquía geométrica debería incluir la diferencia entre los tipos abstractos o "ayudas", que podemos agrupar por lo que ayudan a hacer, y los tipos que ayudan a describir la forma de los elementos del modelo.

Uso de la geometría para ir al siguiente nivel

La creación de modelos en Dynamo no se limita a lo que se puede generar con nodos. A continuación, se indican algunas formas clave para llevar el proceso al siguiente nivel con la geometría:

1. Dynamo permite importar archivos: pruebe a utilizar un archivo CSV para nubes de puntos o SAT para incorporar superficies.

2. Al trabajar con Revit, podemos hacer referencia a los elementos de Revit que se utilizarán en Dynamo.

3. Dynamo Package Manager ofrece funciones adicionales para operaciones y tipos de geometría ampliados; consulte el paquete de Kit de herramientas de malla.

Puntos en Dynamo

¿Qué es un punto?

Un punto se define por uno o más valores denominados coordenadas. El número de valores de coordenadas necesarios para definir el punto depende del sistema de coordenadas o del contexto en el que se encuentra.

Punto 2D y 3D

El tipo de punto más común en Dynamo se encuentra en el sistema de coordenadas universales tridimensional y tiene tres coordenadas [X,Y,Z] (punto 3D en Dynamo).

Un punto 2D de Dynamo tiene dos coordenadas [X,Y].

Punto en curvas y superficies

Los parámetros de las curvas y las superficies son continuos y se extienden más allá del borde de la geometría especificada. Como las formas que definen el espacio paramétrico se encuentran en un sistema de coordenadas universales tridimensional, siempre se puede convertir una coordenada paramétrica en una coordenada "universal". Por ejemplo, el punto [0,2, 0,5] de la superficie es el mismo que el punto [1,8, 2,0, 4,1] de las coordenadas universales.

1. Punto en presuntas coordenadas XYZ globales

2. Punto relativo a un sistema de coordenadas especificado (cilíndrico)

3. Punto como coordenada UV en una superficie

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.

Información más detallada sobre...

Si la geometría es el idioma de un modelo, los puntos son el alfabeto. Los puntos son la base sobre la que se crea el resto de la geometría; se necesitan al menos dos puntos para crear una curva. tres puntos para crear un polígono o una cara de malla, etc. La definición de la posición, el orden y la relación entre los puntos (pruebe con una función de seno) nos permite definir geometrías de orden superior, como elementos que reconocemos como círculos o curvas.

1. Un círculo que utiliza las funciones x=r*cos(t) y y=r*sin(t)

2. Una curva seno que utiliza las funciones x=(t) y y=r*sin(t)

Punto como coordenadas

Los puntos también pueden existir en un sistema de coordenadas bidimensional. La convención tiene diferentes notaciones de letras en función del tipo de espacio con el que se trabaje: es posible que se utilice [X,Y] en un plano o [U,V] en una superficie.

1. Un punto en el sistema de coordenadas euclidiano: [X,Y,Z]

2. Un punto en un sistema de coordenadas de parámetro de curva: [t]

3. Un punto en un sistema de coordenadas de parámetro de superficie: [U,V]

Si la forma más sencilla de datos es el número, la forma más sencilla de relacionarlos es mediante las matemáticas. Desde operadores sencillos como la división a funciones trigonométricas y fórmulas más complejas, las matemáticas son un método excelente para empezar a explorar relaciones y patrones numéricos.

Operadores aritméticos

Los operadores son un conjunto de componentes que utilizan funciones algebraicas con dos valores numéricos de entrada que dan como resultado un valor de salida (suma, resta, multiplicación, división, etc.). Estos se pueden encontrar en Operators > Actions.

Ejercicio: la fórmula de la espiral dorada

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.

Parte I: fórmula paramétrica

Combine operadores y variables para formar una relación más compleja mediante fórmulas. Utilice los controles deslizantes para crear una fórmula que se pueda manejar con parámetros de entrada.

1. Cree la secuencia numérica que representa la "t" de la ecuación paramétrica, por lo que debemos utilizar una lista lo suficientemente grande como para definir una espiral.

Number Sequence: defina una secuencia de números basada en tres entradas: start, amount y step.

2. En el paso anterior, hemos creado una lista de números para definir el dominio paramétrico. A continuación, cree un grupo de nodos que representen la ecuación de la espiral dorada.

La espiral dorada se define como la siguiente ecuación:

La imagen siguiente representa la espiral dorada en forma de programación visual. Al desplazarse por el grupo de nodos, intente prestar atención al paralelismo entre el programa visual y la ecuación por escrito.

a. Number Slider: añada dos controles deslizantes de número al lienzo. Estos controles deslizantes representarán las variables a y b de la ecuación paramétrica. Estas representan una constante que es flexible o parámetros que podemos ajustar hacia el resultado deseado.

b. Multiplication (*): el nodo de multiplicación se representa mediante un asterisco. Lo usaremos con frecuencia para conectar variables de multiplicación.

c. Math.RadiansToDegrees: los valores de "t" se deben convertir a grados para que se evalúen en las funciones trigonométricas. Recuerde que Dynamo utiliza por defecto los grados para evaluar estas funciones.

d. Math.Pow: como función de "t" y del número "e", crea la secuencia Fibonacci.

e. Math.Cos y Math.Sin: estas dos funciones trigonométricas distinguirán la coordenada X y la coordenada Y, respectivamente, de cada punto paramétrico.

f. Watch: ahora vemos que las salidas son dos listas, que serán las coordenadas x e y de los puntos utilizados para generar la espiral.

Parte II: de la fórmula a la geometría

El cúmulo de nodos del paso anterior funcionará correctamente, pero conlleva mucho trabajo. Para crear un flujo de trabajo más eficiente, consulte DesignScript a fin de definir una cadena de expresiones de Dynamo en un nodo. En la siguiente serie de pasos, veremos cómo utilizar la ecuación paramétrica para dibujar la espiral Fibonacci.

Point.ByCoordinates: conecte el nodo de multiplicación superior a la entrada "x" y el inferior a la entrada "y". Ahora se muestra una espiral paramétrica de puntos en la pantalla.

Polycurve.ByPoints: conecte Point.ByCoordinates del paso anterior a points. Podemos dejar connectLastToFirst sin entrada porque no estamos creando una curva cerrada. Se crea una espiral que pasa a través de cada punto definido en el paso anterior.

Ya hemos completado la espiral Fibonacci. Vamos a profundizar en estos conceptos con dos ejercicios separados a partir de aquí; a uno lo llamaremos caracol y al otro girasol. Se trata de abstracciones de sistemas naturales, pero las dos aplicaciones diferentes de la espiral Fibonacci estarán bien representadas.

Parte III: de la espiral al caracol

Circle.ByCenterPointRadius: utilizaremos aquí un nodo de círculo con las mismas entradas que en el paso anterior. El valor por defecto del radio es 1,0, por lo que vemos una salida de círculos inmediata. Se hace inmediatamente evidente cómo los puntos divergen más respecto al origen.

Number Sequence: es la matriz original de "t". Al conectarlo con el valor del radio de Circle.ByCenterPointRadius, los centros de círculo siguen divergiendo más respecto del origen, pero el radio de los círculos aumenta, lo que crea un gráfico de círculos Fibonacci con mucho estilo.

Un premio para quién consiga convertirlo a 3D.

Parte IV: del caracol al filotaxis

Ahora que hemos hecho una concha de caracol circular, vamos a pasar a las rejillas paramétricas. Vamos a usar una rotación básica en la espiral Fibonacci para crear una rejilla Fibonacci y modelar el resultado según el crecimiento de las semillas de girasol.

Como punto de partida, vamos a realizar el mismo paso del ejercicio anterior: crear una matriz de puntos de espiral con el nodo Point.ByCoordinates.


A continuación, siga estos pequeños pasos para generar una serie de espirales en varias rotaciones.

a. Geometry.Rotate: existen varias opciones de Geometry.Rotate; asegúrese de que ha elegido el nodo que contiene las entradas geometry, basePlane y degrees. Conecte Point.ByCoordinates en la entrada geometry. Haga clic con el botón derecho en este nodo y asegúrese de que el encaje se haya establecido en "Producto vectorial".

b. Plano.XY: conéctelo a la entrada basePlane. Rotaremos alrededor del origen, que es la misma ubicación que la base de la espiral.

c. Number Range: para la entrada de grados, vamos a crear varias rotaciones. Esto se puede realizar rápidamente con un componente Number Range. Conéctelo a la entrada degrees.

d. Number: para definir el rango de números, añada tres nodos numéricos al lienzo en orden vertical. De arriba a abajo, asigne valores de 0,0; 360,0 y 120,0 respectivamente. Estos valores controlan la rotación de la espiral. Observe los resultados de las salidas del nodo Number Range después de conectar los tres nodos numéricos al mismo.

Nuestro resultado empieza a parecerse a un remolino. Ajustemos algunos de los parámetros de Number Range y veamos cómo cambian los resultados.

Cambie el tamaño de paso del nodo Number Range de 120,0 a 36,0. Observe que esto crea más rotaciones y que, por tanto, nos proporciona una rejilla más densa.

Cambie el tamaño de paso del nodo Number Range de 36,0 a 3,6. Esto nos da una rejilla mucho más densa y la dirección de la espiral no está clara. Damas y caballeros, hemos creado un girasol.

¿Qué es una cadena?

Formalmente, una cadena es una secuencia de caracteres que representa una constante literal o algún tipo de variable. Informalmente, una cadena es texto en la jerga de la programación. Hemos trabajado con números, enteros y decimales, para controlar los parámetros y podemos hacer lo mismo con el texto.

Creación de cadenas

Las cadenas se pueden utilizar para una amplia gama de aplicaciones, como la definición de parámetros personalizados, la anotación de conjuntos de documentación y el análisis mediante conjuntos de datos basados en texto. El nodo string se encuentra en la categoría Core > Input.

Los nodos de ejemplo anteriores son cadenas. Un número puede representarse como una cadena, al igual que una letra o una matriz completa de texto.

Ejercicio

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.

Consulta de cadenas

Puede analizar rápidamente grandes cantidades de datos consultando cadenas. Hablaremos de algunas operaciones básicas que pueden acelerar un flujo de trabajo y ayudar a mejorar la interoperabilidad de software.

La imagen siguiente se basa en una cadena de datos procedentes de una hoja de cálculo externa. La cadena representa los vértices de un rectángulo en el plano XY. Vamos a desglosar algunas operaciones de división de cadenas en un ejercicio de miniaturas:

1. El separador ";" divide cada vértice del rectángulo. De este modo, se crea una lista con tres elementos para cada vértice.

1. Al pulsar "+" en el centro del nodo, se crea un nuevo separador.

2. Añada una cadena "," al lienzo y conéctela a la nueva entrada de separador.

3. Nuestro resultado es ahora una lista de diez artículos. El nodo realiza la división primero en función de separator0 y, a continuación, en función de separator1.

Aunque los elementos de la lista anterior pueden tener el aspecto de números, se siguen considerando cadenas individuales en Dynamo. Para crear puntos, su tipo de datos debe convertirse de una cadena a un número. Esto se realiza con el nodo String.ToNumber.

1. Este nodo es sencillo. Conecte los resultados de String.Split a la entrada. La salida no tiene un aspecto diferente, pero el tipo de datos es ahora un número en lugar de una cadena.

Con algunas operaciones básicas adicionales, ahora se ha dibujado un triángulo en el origen en función de la entrada de cadena original.

Manipulación de cadenas

Dado que una cadena es un objeto de texto genérico, alberga una amplia gama de aplicaciones. Echemos un vistazo a algunas de las acciones principales de la categoría Core > String de Dynamo:

Este es un método para fusionar dos cadenas en orden. Toma cada cadena literal de una lista y crea una cadena combinada.

A continuación, se representa la concatenación de tres cadenas:

1. Añada o sustraiga cadenas a la concatenación haciendo clic en los botones +/- del centro del nodo.

2. La salida es una cadena concatenada, incluidos espacios y signos de puntuación.

El método de unión es muy similar a la concatenación, excepto que tiene una capa añadida de signos de puntuación.

Si ha trabajado en Excel, es posible que haya encontrado un archivo CSV. Se trata de un archivo de valores separados por comas. Se puede utilizar una coma (o, en este caso, dos guiones) como separador con el nodo String.Join para crear una estructura de datos similar.

La imagen anterior representa la unión de dos cadenas:

1. La entrada "separator" permite crear una cadena que divide las cadenas unidas.

Trabajo con cadenas

En este ejercicio, vamos a usar métodos de consulta y manipulación de cadenas para deconstruir la última estrofa del poema Alto en el bosque en una noche de invierno de Robert Frost. No es la aplicación más práctica, pero nos ayudará a comprender las acciones de cadenas conceptuales a medida que las aplicamos a líneas legibles de ritmo y rima.

Comencemos con una división de cadenas básica de la estrofa. Primero, observamos que el formato de la escritura se basa en comas. Utilizaremos este formato para separar cada línea en elementos individuales.

1. La cadena base se pega en un nodo String.

2. Se utiliza otro nodo String para indicar el separador. En este caso, usamos una coma.

3. Se añade un nodo String.Split al lienzo y se conecta a las dos cadenas.

4. La salida muestra ahora que hemos separado las líneas en elementos individuales.

Ahora, vamos a la parte buena del poema: las dos últimas líneas. La estrofa original era un elemento de datos. En el primer paso, separamos estos datos en elementos individuales. Ahora debemos buscar el texto que deseamos encontrar. Y, aunque podemos hacerlo seleccionando los dos últimos elementos de la lista, si se tratara de un libro completo, no sería un método eficaz leerlo todo y aislar manualmente los elementos.

1. En lugar de realizar una búsqueda manual, se utiliza un nodo String.Contains para realizar una búsqueda de un conjunto de caracteres. Esto es similar a utilizar el comando "Buscar" en un procesador de texto. En este caso, obtenemos un valor de "verdadero" o "falso" si se encuentra esa subcadena en el elemento.

2. En la entrada searchFor, definimos la subcadena que buscamos dentro de la estrofa. Vamos a usar un nodo String con el texto "And miles".

3. La salida nos proporciona una lista de resultados de verdadero y falso. Utilizaremos esta lógica booleana para filtrar los elementos en el siguiente paso.

1. List.FilterByBoolMask es el nodo que debemos utilizar para seleccionar los resultados con valor "false" (falso) y "true" (verdadero). La salida "in" devuelve las instrucciones con una entrada "mask" de "verdadero", mientras que la salida "out" devuelve las que tienen un valor de "falso".

2. Nuestra salida de "in" es como se esperaba, ya que devuelve las dos frases finales de la estrofa.

Ahora, vamos a dejar clara la repetición de la estrofa fusionando las dos líneas. Al visualizar el resultado del paso anterior, observamos que hay dos elementos en la lista:

1. Mediante dos nodos List.GetItemAtIndex, se pueden aislar los elementos con los valores 0 y 1 como entrada del índice.

2. La salida de cada nodo nos proporciona, por orden, las dos líneas finales.

Para fusionar estos dos elementos en uno, se utiliza el nodo String.Join:

1. Después de añadir el nodo String.Join, observamos que necesitamos un separador.

2. Para crear el separador, se añade un nodo String al lienzo y se escribe una coma.

3. La última salida ha fusionado los dos últimos elementos en uno.

Puede parecer muy laborioso aislar las dos últimas líneas y es cierto que, a menudo, las operaciones de cadena requieren trabajo inicial. Pero son escalables y se pueden aplicar a grandes conjuntos de datos con relativa facilidad. Si trabaja paramétricamente con hojas de cálculo e interoperabilidad, asegúrese de mantener en mente las operaciones de cadena.

Este índice proporciona información adicional sobre todos los nodos utilizados en este manual de introducción, así como sobre otros componentes que pueden resultar útiles. Esto es solo una introducción a algunos de los 500 nodos disponibles en Dynamo.

Mostrar

Color

Visualización

Entrada

Lista

Lógica

Matemáticas

String

Geometría

Círculo

Ortoedro

Curva

Modificadores de geometría

Línea

NurbsCurve

NurbsSurface

Plano

Punto

PolyCurve

Rectángulo

Esfera

Superficie

UV

Vector

CoordinateSystem

Operadores

Superficies en Dynamo

¿Qué es una superficie?

Utilizamos una superficie en el modelo para representar los objetos que vemos en nuestro mundo tridimensional. Aunque las curvas no siempre son planas, es decir, tridimensionales, el espacio que definen siempre está vinculado a una dimensión. Las superficies nos ofrecen otra dimensión y un conjunto de propiedades adicionales que se pueden utilizar en otras operaciones de modelado.

Superficie en parámetro

Importe y evalúe una superficie en un parámetro de Dynamo para ver qué tipo de información se puede extraer.

1. Surface.PointAtParameter devuelve el punto en una coordenada UV especificada.

2. Surface.NormalAtParameter devuelve el vector normal en una coordenada UV especificada.

3. Surface.GetIsoline devuelve la curva isoparamétrica en una coordenada U o V; observe la entrada de isoDirection.

Descargue los archivos 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.

Información más detallada sobre...

Superficie

Una superficie es una forma matemática definida por una función y dos parámetros; en lugar de t para las curvas, utilizamos U y V para describir el espacio de parámetros correspondiente. Esto significa que hay más datos geométricos que dibujar cuando se trabaja con este tipo de geometría. Por ejemplo, las curvas tienen vectores y planos normales (que se pueden rotar o girar a lo largo de la longitud de la curva), mientras que las superficies tienen vectores normales y planos tangentes que serán coherentes en su orientación.

1. Superficie

2. Isocurva U

3. Isocurva V

4. Coordenada UV

5. Plano perpendicular

6. Vector normal

Dominio de superficie: un dominio de superficie se define como el rango de parámetros (U,V) que se evalúan en un punto tridimensional de esa superficie. El dominio de cada dimensión (U o V) se describe normalmente como dos números, de U mín. a U máx. y de V mín. a V máx.

Aunque la forma de la superficie puede no parecer "rectangular" y es posible que tenga un conjunto de isocurvas más ajustadas o sueltas, el "espacio" definido por su dominio siempre es bidimensional. En Dynamo, se entiende que las superficies tienen un dominio definido por un mínimo de 0.0 y un máximo de 1.0 en las direcciones U y V. Las superficies planas o recortadas pueden tener dominios diferentes.

Isocurva (o curva isoparamétrica): curva definida por un valor U o V constante en la superficie y un dominio de valores para la otra dirección U o V correspondiente.

Coordenada UV: el punto del espacio del parámetro UV definido por U, V y, a veces, W.

Plano perpendicular: un plano perpendicular a las isocurvas U y V en una coordenada UV especificada.

Vector normal: un vector que define la dirección de "arriba" en relación con el plano perpendicular.

Superficies NURBS

Las superficies NURBS son muy similares a las curvas NURBS. Las superficies NURBS se pueden considerar como una rejilla de curvas NURBS que van en dos direcciones. La forma de una superficie NURBS se define mediante un número de puntos de control y el grado de esa superficie en las direcciones U y V. Se utilizan los mismos algoritmos para calcular la forma, las normales, las tangentes, las curvaturas y otras propiedades mediante puntos de control, grosores y grados.

En el caso de las superficies NURBS, la geometría indica dos direcciones, ya que las superficies NURBS son, independientemente de la forma que veamos, rejillas rectangulares de puntos de control. Y, aunque estas direcciones son a menudo arbitrarias en relación con el sistema de coordenadas universal, las utilizaremos frecuentemente para analizar los modelos o generar otra geometría en función de la superficie.

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

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

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

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

PolySurfaces

Las PolySurfaces se componen de superficies unidas a lo largo de una arista. Las PolySurfaces ofrecen más de una definición de UV bidimensional, por lo que ahora podemos desplazarnos por las formas conectadas a través de su topología.

Aunque la "topología" describe normalmente un concepto sobre el modo en que las piezas están conectadas o relacionadas, la topología en Dynamo es también un tipo de geometría. En concreto, es una categoría principal de superficies, PolySurfaces y sólidos.

En ocasiones denominadas parches, este modo de unión de superficies nos permite crear formas más complejas y definir detalles a lo largo de la unión. De forma oportuna, podemos aplicar una operación de empalme o chaflán a las aristas de una PolySurface.

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.

¿Qué es una lista?

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í.

Índices basados en cero

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.

Entradas y salidas

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:

1. La entrada points de PolyCurve.ByPoints busca "Point[]". Esto representa una lista de puntos.

2. La salida de PolyCurve.ByPoints es una PolyCurve única creada a partir de una lista de cinco puntos.

3. La entrada centerPoint de Circle.ByCenterPointRadius solicita "Point".

4. 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.

Encaje

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:

Lista más corta

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:

Lista más larga

El algoritmo "Lista más larga" sigue conectando entradas, reutilizando elementos, hasta que todos los flujos se acaben:

Producto vectorial

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".

Ejercicio

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.

Lista más corta

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.

Lista más larga

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.

Producto vectorial

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.

Listas de listas

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.

Consulta

¿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.

Acción

¿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.

Ejercicio:

Jerarquía descendente

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:

1. Con el bloque de código, hemos definido dos intervalos: 0..2; 0..3;.

2. 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.

3. Observe que el nodo Watch proporciona tres listas con cuatro elementos en cada lista.

4. 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.

List.Flatten

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.

1. Inserte una línea de código para definir un intervalo en el bloque de código: -250..-150..#4;.

2. 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.

3. En el nodo Watch, se muestra que tenemos una lista de listas.

4. 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.

1. 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.

Chop

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.

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.

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 List@Level 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.

1. 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.

2. Con dos controles deslizantes de enteros, defina los valores de Nx y Ny conectándolos al bloque de código.

3. 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.

4. 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.

1. Enlace un nodo List.Count a la salida del nodo de visualización del paso anterior.

2. 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.

1. Mediante un nodo List.Map, nos desplazaremos un nivel hacia abajo en la jerarquía y ejecutaremos una "función" en este nivel.

2. 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.

3. 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.

List.Combine

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 List@Level a continuación.

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.

1. Utilice el nodo Sequence para generar 10 valores, cada uno con un incremento de 10 pasos.

2. Conecte el resultado a la entrada x de un nodo Point.ByCoordinates. De este modo, se creará una lista de puntos en Dynamo.

3. 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.

1. Añada List.Combine al espacio de trabajo y conecte los dos conjuntos de puntos como entrada list0 y list1.

2. 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.

List@Level

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.

1. 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.

2. 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.

3. 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.

1. Para utilizar la función List@Level, haga clic en ">". En este menú, verá dos casillas de verificación.

2. 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.

3. 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.

1. "@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.

2. 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.

3. 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.

4. 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:

1. 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

2. 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.

3. 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.

Transpose

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.

1. Conecte PolyCurve.ByPoints a la salida del nodo de inspección desde Point.ByCoordinates.

2. 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.

1. 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.

2. 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.

3. Observe el resultado geométrico: al utilizar PolyCurve.ByPoints, se obtienen tres PolyCurves en la dirección perpendicular a las curvas originales.

Bloque de código para creación de listas

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 Bloques de código y DesignScript. 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.

Consulta del 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 Bloques de código y DesignScript. 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.

Ejercicio: consulta e inserción de 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.

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.

1. 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;.

2. Asegúrese de establecer el encaje de Surface.PointAtParameter en "Producto vectorial".

3. 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?

1. 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.

2. 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];.

3. Con Geometry.Translate, desplazaremos el punto seleccionado hacia arriba en la dirección Z en 20 unidades.

1. 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.

1. Deseamos reemplazar primero el elemento de la lista que hemos aislado en un paso anterior.

2. 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).

3. 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.

1. Siguiendo la misma lógica, utilice List.ReplaceItemAtIndex para reemplazar la lista central por la lista modificada.

2. 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]).

3. 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.

1. Cree un nodo NurbsCurve.ByPoints y conecte la nueva estructura de datos para crear tres curvas NURBS.

1. 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.

Dynamo 2.0 no solo presenta los nodos indicados anteriormente para los diccionarios, sino que también hay nuevas funciones en los bloques de código para ello.

Puede utilizar una sintaxis como la siguiente o representaciones basadas en DesignScript de los nodos.

Dado que un diccionario es un tipo de objeto de Dynamo, podemos realizar las siguientes acciones con él.

Mantener este tipo de interacciones resulta especialmente útil al relacionar datos de Revit con cadenas. A continuación, veremos algunos casos de uso de Revit.

Los diccionarios representan una recopilación de datos relacionados con otro elemento de datos conocido como clave. Los diccionarios muestran la capacidad de buscar, suprimir e insertar datos en una colección.

Básicamente, podemos considerar un diccionario como una manera realmente inteligente de buscar algo.

Aunque la función de diccionario lleva disponible en Dynamo durante algún tiempo, Dynamo 2.0 presenta una nueva forma de administrar este tipo de datos.

Imagen original por cortesía de: sixtysecondrevit.com

¿Alguna vez ha deseado buscar algo en Revit mediante un segmento de datos incluido en la solución?

Si la respuesta es afirmativa, es probable que haya hecho algo similar a lo que aparece en el ejemplo siguiente.

En la imagen mostrada a continuación, recopilamos todas las habitaciones del modelo de Revit, obtenemos el índice de la habitación que deseamos (por número de habitación) y, por último, obtenemos la habitación en el índice.

1. Recopile todas las habitaciones del modelo.

2. Especifique el número de habitación que se va a buscar.

3. Obtenga el número de habitación y busque el índice en el que se encuentra.

4. Obtenga la habitación en el índice.

Ejercicio: diccionario de habitaciones

Parte I: creación de un diccionario de habitaciones

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.

Ahora vamos a recrear esta idea mediante diccionarios. Debemos recopilar primero todas las habitaciones de nuestro modelo de Revit.

1. Seleccionamos la categoría de Revit con la que deseamos trabajar (en este caso, trabajaremos con habitaciones).

2. Le indicamos a Dynamo que recopile todos esos elementos.

A continuación, debemos decidir las claves que vamos a utilizar para buscar estos datos. (La información sobre las claves se encuentra en la sección ¿Qué es un diccionario?).

1. Los datos que usaremos son el número de habitación.

Ahora crearemos el diccionario con las claves y los elementos especificados.

1. El nodo Dictionary.ByKeysValues creará un diccionario con las entradas correspondientes especificadas.

2. Keys debe ser una cadena, mientras que values puede ser diversos tipos de objeto.

Por último, ahora podemos recuperar una habitación del diccionario con su número de habitación.

1. String será la clave que utilizaremos para buscar un objeto en el diccionario.

2. Dictionary.ValueAtKey obtendrá ahora el objeto del diccionario.

Parte II: búsqueda de valores

Con esta misma lógica de diccionario, también podemos crear diccionarios con objetos agrupados. Si deseamos buscar todas las habitaciones en un nivel determinado, podemos modificar el gráfico anterior de la siguiente manera.

1. En lugar de utilizar el número de habitación como clave, ahora podemos utilizar un valor de parámetro (en este caso, utilizaremos nivel).

1. Ahora podemos agrupar las habitaciones por el nivel en el que residen.

1. Con los elementos agrupados por el nivel, ahora podemos utilizar las claves compartidas (claves exclusivas) como nuestra clave para el diccionario y las listas de habitaciones como elementos.

1. Por último, mediante los niveles del modelo de Revit, podemos buscar en el diccionario las habitaciones que se encuentran en ese nivel. Dictionary.ValueAtKey utilizará el nombre de nivel y devolverá los objetos de habitación presentes en ese nivel.

Las oportunidades de uso del diccionario son realmente infinitas. La capacidad de relacionar los datos de BIM de Revit con el propio elemento plantea diversos casos de uso.

Trabajo con listas

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

Consulta

¿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.

Acción

¿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.

Ejercicio

Operaciones de lista

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.

1. Comience con un bloque de código con un valor de 500;.

2. Conéctelo a la entrada x de un nodo Point.ByCoordinates.

3. Conecte el nodo del paso anterior a la entrada origin de un nodo Plane.ByOriginNormal.

4. Con un nodo Circle.ByPlaneRadius, conecte el nodo del paso anterior en la entrada plane.

5. Mediante el bloque de código, designe un valor de 50; para el radio. Este es el primer círculo que crearemos.

6. Con un nodo Geometry.Translate, desplace el círculo hacia arriba 100 unidades en la dirección Z.

7. 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;.

8. 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.

9. Con un nodo Line.ByStartPointEndPoint, conecte los dos nodos Curve.PointAtParameter.

List.Count

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.

1. 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.

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.GetItemAtIndex es una forma fundamental de consultar un elemento de la lista.

1. En primer lugar, haga clic con el botón derecho en el nodo Line.ByStartPointEndPoint para desactivar su vista preliminar.

2. 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.

List.Reverse

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.

1. 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;.

2. Duplique el nodo Line.ByStartPointEndPoint, inserte un nodo List.Reverse entre Curve.PointAtParameter y el segundo nodo Line.ByStartPointEndPoint.

3. 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.

List.ShiftIndices

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.

1. En el mismo proceso que la lista inversa, inserte un nodo List.ShiftIndices en Curve.PointAtParameter y Line.ByStartPointEndPointPoint.

2. Mediante un bloque de código, designe un valor de "1" para desplazar la lista un índice.

3. 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.

List.FilterByBooleanMask

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...

1. 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.

2. 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.

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".

4. El nodo Watch muestra solo esto; disponemos de un patrón verdadero/falso que dice: verdadero,falso,falso,falso,falso....

5. Mediante este patrón verdadero/falso, conéctelo a la entrada "mask" de dos nodos List.FilterByBooleanMask.

6. Conecte el nodo Curve.PointAtParameter en cada una de las entradas "list" de los nodos List.FilterByBooleanMask.

7. 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.

8. El nodo Watch3D indica que hay menos líneas que puntos. Hemos seleccionado solo el 25 % de los nodos filtrando solo los valores verdaderos.

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.

Asignación y combinaciones

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.

Ejercicio - Listas 2D: nivel básico

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.

1. Comencemos con el archivo .sat de la carpeta de archivos del ejercicio. Se puede acceder a este archivo mediante el nodo File Path.

2. 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.

1. Seleccionaremos el índice de 1 para capturar la superficie superior. Esta acción se realiza con el nodo List.GetItemAtIndex.

2. 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.

1. Para obtener información sobre cómo se organiza la estructura de datos, conectemos un nodo NurbsCurve.ByPoints a la salida de Surface.PointAtParameter.

2. Por ahora, puede desactivar la vista preliminar del nodo List.GetItemAtIndex para obtener un resultado más claro.

1. Un nodo List.Transpose básico cambiará las columnas y las filas de una lista de listas.

2. Al conectar la salida de List.Transpose a NurbsCurve.ByPoints, se obtienen cinco curvas que discurren horizontalmente a través de la superficie.

3. Puede desactivar la vista preliminar del nodo NurbsCurve.ByPoints en el paso anterior para obtener el mismo resultado en la imagen.

Ejercicio - Listas 2D: nivel avanzado

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.

1. Comience con un paso del ejercicio anterior, aislando la superficie superior de la geometría importada con el nodo List.GetItemAtIndex.

1. Con Surface.Offset, desfase la superficie con un valor de 10.

1. 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;.

2. 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.

1. Desactive la vista preliminar de estas superficies.

2. Como en el ejercicio anterior, conecte la salida a dos nodos NurbsCurve.ByPoints. En el resultado, se muestran las curvas correspondientes a dos superficies.

1. Con List.Create, podemos combinar los dos conjuntos de curvas en una lista de listas.

2. Observe en la salida que tenemos dos listas con 10 elementos cada una que representan cada conjunto de conexiones de curvas NURBS.

3. Al ejecutar Surface.ByLoft, podemos visualizar con claridad esta estructura de datos. El nodo soleva todas las curvas de cada sublista.

1. Desactive la vista preliminar del nodo Surface.ByLoft en el paso anterior.

2. 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.

3. Con Surface.ByLoft, llegamos a una estructura con nervios.

A continuación, mostraremos un proceso alternativo para lograr este resultado.

1. Antes de empezar, desactive la vista preliminar de Surface.ByLoft en el paso anterior para evitar confusiones.

2. Una alternativa a List.Transpose es utilizar List.Combine. Esta acción pondrá en funcionamiento un "combinador" en cada sublista.

3. En este caso, utilizaremos List.Create como "combinador", que creará una lista de cada elemento de las sublistas.

4. 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.

1. 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.

Ejercicio - Listas 3D

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.

1. Como en el ejercicio anterior, utilice el nodo Surface.Offset para desfasar por un valor de 10.

2. Observe en la salida que hemos creado dos superficies con el nodo de desfase.

1. 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;.

2. 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.

1. Como en el ejercicio anterior, conecte la salida a dos nodos NurbsCurve.ByPoints.

2. 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.

3. 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.

1. Antes de continuar, desactive la vista preliminar de las superficies existentes.

2. Con el nodo List.Create, se fusionan las curvas NURBS en una estructura de datos, lo que crea una lista de listas de listas.

3. 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.

1. 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.

1. List.Combine funcionará mejor aquí. Debemos usar los nodos List.Map y List.Combine cuando trabajamos con estructuras de datos más complejas.

2. Al utilizar List.Create como "combinador", creamos una estructura de datos que funcionará mejor para nosotros.

1. 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.

2. 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.

1. Por último, podemos solevar las curvas NURBS junto con una jerarquía de datos adecuada, lo que nos proporciona una estructura con nervios.

1. Añadamos profundidad a la geometría mediante un nodo Surface.Thicken con los parámetros de entrada, como se muestra.

1. 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.

2. 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.

1. 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í.

1. 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.

1. 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.

Sólidos en Dynamo

¿Qué es un sólido?

Si deseamos crear modelos más complejos que no se puedan crear a partir de una única superficie o si queremos definir un volumen explícito, debemos aventurarnos en el terreno de los sólidos (y las PolySurfaces). Incluso un cubo sencillo es lo suficientemente complejo como para necesitar seis superficies, una por cara. Los sólidos proporcionan acceso a dos conceptos clave que las superficies no ofrecen: una descripción topológica más refinada (caras, aristas y vértices) y operaciones booleanas.

Operación booleana para crear un sólido de bola llena de puntas

Puede utilizar operaciones booleanas para modificar sólidos. Vamos a utilizar algunas operaciones booleanas para crear una bola llena de puntas.

1. Sphere.ByCenterPointRadius: cree el sólido base.

2. Topology.Faces, Face.SurfaceGeometry: consulte las caras del sólido y conviértalas en geometría de superficie; en este caso, la esfera solo tiene una cara.

3. Cone.ByPointsRadii: cree conos mediante puntos en la superficie.

4. Solid.UnionAll: una los conos y la esfera.

5. Topology.Edges: consulte las aristas del nuevo sólido.

6. Solid.Fillet: empalme las aristas de la bola llena de puntas.

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.

Bloqueo

Las operaciones booleanas son complejas y pueden resultar lentas de calcular. Puede utilizar la función "Bloquear" para suspender la ejecución de nodos seleccionados y nodos descendentes afectados.

1. Utilice el menú contextual para bloquear la operación de unión de sólidos.

2. El nodo seleccionado y todos los nodos descendentes se previsualizan en modo atenuado con un color gris claro y los cables afectados se muestran como líneas continuas. La vista preliminar de la geometría afectada también se mostrará atenuada. Ahora puede cambiar los valores ascendentes sin calcular la unión booleana.

3. Para desbloquear los nodos, haga clic con el botón derecho y desactive la opción Bloquear.

4. Todos los nodos afectados y las vistas preliminares de la geometría asociada se actualizarán y se restablecerán al modo de vista preliminar estándar.

Información más detallada sobre...

Sólidos

Los sólidos constan de una o varias superficies que contienen volumen a partir de un contorno cerrado que define lo que está "dentro" o "fuera". Independientemente de cuántas superficies haya, estas deben formar un volumen "hermético" para que se considere un sólido. Los sólidos se pueden crear mediante la unión de superficies o PolySurfaces, o mediante operaciones como, por ejemplo, solevación, barrido y revolución. Las primitivas de esfera, cubo, cono y cilindro también son sólidos. Un cubo con al menos una cara eliminada se considera una PolySurface, que tiene algunas propiedades similares, pero no es un sólido.

1. Un plano está compuesto por una única superficie y no es un sólido.

2. Una esfera está formada por una única superficie, pero es un sólido.

3. Un cono está formado por dos superficies unidas para crear un sólido.

4. Un cilindro está formado por tres superficies unidas para crear un sólido.

5. Un cubo está formado por seis superficies unidas para crear un sólido.

Topología

Los sólidos se componen de tres tipos de elementos: vértices, aristas y caras. Las caras son las superficies que conforman el sólido. Las aristas son las curvas que definen la conexión entre las caras adyacentes y los vértices son los puntos inicial y final de esas curvas. Estos elementos se pueden consultar mediante los nodos de topología.

1. Caras

2. Aristas

3. Vértices

Operaciones

Los sólidos se pueden modificar mediante empalmes o achaflanados de sus aristas para eliminar esquinas y ángulos agudos. La operación de chaflán crea una superficie reglada entre dos caras, mientras que un empalme se fusiona entre las caras para mantener la tangencia.

1. Cubo sólido

2. Cubo achaflanado

3. Cubo empalmado

Operaciones booleanas

Las operaciones booleanas de sólidos son métodos para combinar dos o más sólidos. Una única operación booleana implica realmente la realización de cuatro operaciones:

1. Interseque dos o más objetos.

2. Divídalos en las intersecciones.

3. Suprima las partes no deseadas de la geometría.

4. Una todo de nuevo.

1. Unión: elimine las partes que se solapan de los sólidos y únalas en un único sólido.

2. Diferencia: reste un sólido a otro. El sólido que se va a restar se conoce como herramienta. Tenga en cuenta que puede cambiar el sólido que será la herramienta para conservar el volumen inverso.

3. Intersección: conserve solo el volumen de intersección de los dos sólidos.

1. UnionAll: operación de unión con esfera y conos orientados hacia fuera.

2. DifferenceAll: operación de diferencia con esfera y conos orientados hacia dentro.

La lógica o, más específicamente, la lógica condicional nos permite especificar una acción o un conjunto de acciones basadas en una prueba. Tras evaluar la prueba, dispondremos de un valor booleano que representa True o False que podemos utilizar para controlar el flujo del programa.

Booleanos

Las variables numéricas pueden almacenar una gran variedad de números diferentes. Las variables booleanas solo pueden almacenar dos valores denominados Verdadero o Falso, Sí o No, 1 o 0. Rara vez utilizamos booleanos para realizar cálculos debido a su rango limitado.

Instrucciones condicionales

La instrucción "If" ("si") es un concepto clave en la programación: "Si esto es cierto, eso ocurre; de lo contrario, otra cosa ocurre. La acción resultante de la instrucción se rige por un valor booleano. Hay varias formas de definir una instrucción "If" en Dynamo:

Veamos un breve ejemplo de cada uno de estos tres nodos en acción mediante la instrucción condicional "If".

En esta imagen, el nodo Boolean se ha establecido en Verdadero (True), lo que significa que el resultado es una cadena que dice: "este es el resultado si es verdadero". Los tres nodos que crean la instrucción If funcionan de la misma forma aquí.

De nuevo, los nodos funcionan de la misma forma. Si el nodo Boolean se cambia a Falso (False), el resultado es el número Pi, tal y como se define en la instrucción If original.

Ejercicio: lógica y geometría

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.

Parte I: filtrado de una lista

1. Usemos la lógica para separar una lista de números en una lista de números pares y una lista de números impares.

a. Number Range: añada un rango de números al lienzo.

b. Nodos Number: añada tres nodos numéricos al lienzo. El valor de cada nodo numérico debe ser 0,0 para start, 10,0 para end y 1,0 para step.

c. Salida: nuestra salida es una lista de 11 números que van del 0 al 10.

d. Módulo (%): Number Range se conecta a x y 2,0 a y. De este modo, se calcula el resto de cada número de la lista dividido por 2. La salida de esta lista nos proporciona una lista de valores alternantes entre 0 y 1.

e. Prueba de igualdad (==): añada una prueba de igualdad al lienzo. Conecte la salida de módulo a la entrada x y 0,0 en la entrada y.

f. Watch: la salida de la prueba de igualdad es una lista de valores que alterna entre verdadero y falso. Estos son los valores utilizados para separar los elementos de la lista. 0 (o true) representa números pares y 1 (o false) representa números impares.

g. List.FilterByBoolMask: este nodo filtrará los valores en dos listas diferentes en función del valor booleano de entrada. Conecte el nodo Number Range original a la entrada list y la salida de la prueba de igualdad en la entrada mask. La salida in representa los valores verdaderos, mientras que la salida out representa los valores falsos.

h. Watch: como resultado, ahora tenemos una lista de números pares y una de impares. Hemos utilizado operadores lógicos para separar las listas en patrones.

Parte II: de la lógica a la geometría

Basándonos en la lógica establecida en el primer ejercicio, vamos a aplicar esta configuración en una operación de modelado.

2. Comenzaremos por donde dejamos el ejercicio anterior, con los mismos nodos. Las únicas excepciones (además de cambiar el formato) son las siguientes:

a. Utilice un nodo Sequence con estos valores de entrada.

b. Se ha desconectado la entrada list en List.FilterByBoolMask. Dejaremos estos nodos a un lado por ahora, pero en fases posteriores del ejercicio serán muy útiles.

3. Creemos primero un grupo independiente de gráficos, como se muestra en la imagen anterior. Este grupo de nodos representa una ecuación paramétrica para definir una curva de línea. Información que debemos tener en cuenta:

a. El primer control deslizante de número representa la frecuencia de la onda; debe tener un mínimo de 1, un máximo de 4 y un paso de 0,01.

b. El segundo control deslizante de número representa la amplitud de la onda; debe tener un mínimo de 0, un máximo de 1 y un paso de 0,01.

c. PolyCurve.ByPoints: si se copia el diagrama de nodos anterior, el resultado es una curva de seno en la ventana de vista preliminar de Dynamo.

El método que se sigue para las entradas es utilizar nodos numéricos para las propiedades más estáticas y controles deslizantes de número para las más flexibles. Vamos a mantener el rango de números original que definimos al principio de este paso. Sin embargo, la curva de seno que se crea aquí debe tener cierta flexibilidad. Se pueden mover estos controles deslizantes para ver cómo se actualiza la frecuencia y la amplitud de la curva.

4. Vamos a saltar un poco en la definición, así que veamos el resultado final para que podamos tener como referencia lo que vamos a conseguir. Los dos primeros pasos se realizan por separado; ahora queremos conectar los dos. Utilizaremos la curva de seno base para controlar la ubicación de los componentes de cremallera y utilizaremos la lógica de verdadero/falso para alternar entre cuadros pequeños y cuadros más grandes.

a. Math.RemapRange: con la secuencia de números creada en el paso 02, vamos a crear una nueva serie de números reasignando el rango. Los números originales del paso 01 van del 0 al 100. Estos números oscilan entre 0 y 1 en las entradas newMin y newMax respectivamente.

5. Cree un nodo Curve.PointAtParameter y, a continuación, conecte la salida Math.RemapRange del paso 04 como su entrada param.

Este paso crea puntos a lo largo de la curva. Hemos reasignado los números a entre 0 y 1 porque la entrada param busca valores en este rango. El valor 0 representa el punto inicial; el valor 1 representa los puntos finales. Todos los números que se encuentran en medio se evalúan dentro del rango de [0,1].

6. Conecte la salida de Curve.PointAtParameter a List.FilterByBoolMask para separar la lista de índices pares e impares.

a. List.FilterByBoolMask: conecte el nodo Curve.PointAtParameter del paso anterior a la entrada list.

b. Watch: un nodo de visualización para in y otro para out indican que hay dos listas que representan índices pares e impares. Estos puntos se ordenan de la misma forma en la curva, que se muestra en el siguiente paso.

7. A continuación, vamos a utilizar el resultado de salida de List.FilterByBoolMask en el paso 05 para generar geometrías con tamaños según sus índices.

Cuboid.ByLengths: reproduzca las conexiones representadas en la imagen anterior para obtener una cremallera a lo largo de la curva de seno. Un cubo es solo un cuadro, y estamos definiendo su tamaño basándonos en el punto de curva del centro del cuadro. La lógica de la división par/impar debería ser clara ahora en el modelo.

a. Lista de ortoedros en índices uniformes.

b. Lista de ortoedros en índices impares.

Y eso es todo. Acaba de programar un proceso para definir las cotas de geometría de acuerdo con la operación lógica que se muestra en este ejercicio.

Dynamo 2.0 presenta una gran variedad de nodos de diccionario para nuestro uso. Esto incluye los nodos de creación, acción y consulta.

Crear

1. Dictionary.ByKeysValues creará un diccionario con las claves y los valores proporcionados. (El número de entradas será el de la entrada de lista más corta).

Acción

1. Dictionary.Components generará los componentes del diccionario de entrada. (Es el proceso inverso al nodo creado).

2. Dictionary.RemoveKeys generará un nuevo objeto de diccionario con las claves de entrada eliminadas.

3. Dictionary.SetValueAtKeys creará un nuevo diccionario basado en las claves de entrada y los valores para reemplazar el valor actual en las claves correspondientes.

4. Dictionary.ValueAtKey devolverá el valor en la clave de entrada.

Conteo

1. Dictionary.Count le indicará cuántos pares de clave-valor hay en el diccionario.

2. Dictionary.Keys devolverá las claves almacenadas actualmente en el diccionario.

3. Dictionary.Values devolverá los valores almacenados actualmente en el diccionario.

Relacionar de forma general datos con diccionarios es una magnífica alternativa al antiguo método de trabajo con índices y listas.

Dynamo 2.0 introduce el concepto de separación del tipo de datos del diccionario del tipo de datos de lista. Esta novedad puede conllevar algunos cambios importantes en la forma de crear y trabajar con datos en los flujos de trabajo. Antes de la versión 2.0, los diccionarios y las listas se combinaban como un tipo de datos. En resumen, las listas eran en realidad diccionarios con claves de enteros.

¿Qué es un diccionario?

Un diccionario es un tipo de datos compuesto por una colección de pares de clave-valor en los que cada clave es exclusiva para cada colección. Un diccionario no tiene orden y, básicamente, se pueden "buscar elementos" mediante una clave en lugar de un valor de índice como en una lista. En Dynamo 2.0, las claves solo pueden ser cadenas.

¿Qué es una lista?

Una lista es un tipo de datos compuesto por un conjunto de valores ordenados. En Dynamo, las listas utilizan enteros como valores de índice.

¿Por qué se ha realizado este cambio y en qué me afecta?

La separación de los diccionarios y las listas convierte a los diccionarios en componentes de primera clase que se pueden utilizar para almacenar y buscar valores de forma rápida y sencilla sin necesidad de recordar un valor de índice o mantener una estructura de listas estricta a lo largo del flujo de trabajo. Durante las pruebas realizadas por los usuarios, hemos detectado una reducción considerable del tamaño del gráfico cuando se utilizaron los diccionarios en lugar de varios nodos GetItemAtIndex.

¿Cuáles son los cambios?

• Se han producido cambios en la sintaxis que modifican el modo en que se inicializarán y se utilizarán los diccionarios y las listas en los bloques de código.

  • Los diccionarios utilizan la siguiente sintaxis: {key:value}.

  • Las listas utilizan la siguiente sintaxis: [value,value,value].

• Se han introducido nuevos nodos en la biblioteca para ayudarle a crear, modificar y consultar diccionarios.

• Las listas creadas con bloques de código v1.x se migrarán automáticamente al cargar la secuencia de comandos a la nueva sintaxis de lista que utiliza corchetes [ ] en lugar de llaves { }.

  ---

¿En qué me afecta? ¿Para qué se utilizan?

En las ciencias informáticas, los diccionarios, al igual que las listas, son colecciones de objetos. Mientras que las listas se encuentran en un orden específico, los diccionarios son colecciones sin ordenar. No dependen de números secuenciales (índices), sino de claves.

En la imagen siguiente, se muestra un posible caso de uso de un diccionario. A menudo, los diccionarios se utilizan para relacionar dos segmentos de datos que podrían no tener una correlación directa. En este caso, conectamos la versión en español de una palabra a la versión en inglés para su posterior búsqueda.

1. Cree un diccionario para relacionar los dos datos.

2. Obtenga el valor con la clave especificada.

El color es un excelente tipo de datos para crear imágenes convincentes, así como para renderizar la diferencia en la salida del programa visual. Cuando se trabaja con datos abstractos y números variables, a veces es difícil ver qué se está cambiando y en qué grado. Esta es una aplicación excelente para los colores.

Creación de colores

Los colores de Dynamo se crean con entradas de ARGB. Estas corresponden a los canales alfa, rojo, verde y azul. El canal alfa representa la transparencia del color, mientras que los otros tres se utilizan como colores principales para generar todo el espectro de color sincronizado.

Consulta de los valores de color

Los colores de la tabla siguiente consultan las propiedades utilizadas para definir el color: alfa, rojo, verde y azul. Observe que el nodo Color.Components nos proporciona las cuatro salidas diferentes, lo que hace que este nodo sea preferible para consultar las propiedades de un color.

Los colores de la tabla siguiente corresponden al espacio de color HSB. La división del color en el matiz, la saturación y el brillo es, probablemente, más intuitiva en la forma en que se interpreta el color: ¿Qué color debería ser? ¿Debería ser más o menos colorido? ¿Y debería ser más o menos claro u oscuro? Este es el desglose del matiz, la saturación y el brillo respectivamente.

Rango de colores

El rango de color es similar al nodo Remap Range del ejercicio ; asigna de nuevo una lista de números a otro dominio. Sin embargo, en lugar de asignarla a un dominio de número, la asigna a un degradado de color basado en números de entrada que van del 0 al 1.

El nodo actual funciona bien, pero puede resultar un poco incómodo para que todo funcione la primera vez. La mejor forma de familiarizarse con el degradado de color es probarlo de forma interactiva. Hagamos un ejercicio rápido para revisar cómo configurar un degradado con colores de salida que corresponden a números.

1. Definir tres colores: con un nodo Code Block, defina rojo, verde y azul mediante la conexión de las combinaciones adecuadas de 0 y 255.

2. Crear lista:fusione los tres colores en una lista.

3. Definir índices: cree una lista para definir las posiciones de pinzamiento de cada color (de 0 a 1). Observe el valor de 0,75 para el verde. De este modo, se coloca el color verde a tres cuartos de camino en el degradado horizontal del control deslizante de rango de colores.

4. Code Block: valores de entrada (entre 0 y 1) para convertir en colores.

Vista previa de color

El nodo Display.ByGeometry nos permite colorear la geometría en la ventana gráfica de Dynamo. Esto resulta útil para separar diferentes tipos de geometría, demostrar un concepto paramétrico o definir una leyenda de análisis para la simulación. Las entradas son sencillas, geometría y color. Para crear un degradado como el de la imagen anterior, la entrada de color se conecta al nodo Color Range.

Color en superficies

El nodo Display.BySurfaceColors nos permite asignar datos en una superficie mediante los colores. Esta función ofrece posibilidades interesantes para visualizar los datos obtenidos a través de análisis independientes como análisis solares, de energía o de proximidad. La aplicación de color a una superficie en Dynamo es similar a la aplicación de una textura a un material en otros entornos de CAD. Vamos a demostrar cómo utilizar esta herramienta en el siguiente ejercicio breve.

Ejercicio

Hélice básica con colores

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 ejercicio se centra en el control paramétrico del color en paralelo a la geometría. La geometría es una hélice básica que se define a continuación mediante el bloque de código. Esta es una forma rápida y sencilla de crear una función paramétrica y, como nuestro enfoque está en el color (en lugar de en la geometría), utilizamos el bloque de código para crear la hélice de forma eficaz sin sobrecargar el lienzo. Utilizaremos el bloque de código con más frecuencia a medida que el manual de introducción se adentre en materiales más avanzados.

1. Code Block: defina los dos bloques de código con las fórmulas mostradas anteriormente. Este es un método paramétrico rápido para crear una espiral.

2. Point.ByCoordinates: conecte las tres salidas del bloque de código a las coordenadas del nodo.

Ahora se muestra una matriz de puntos que crean una hélice. El siguiente paso consiste en crear una curva que atraviese los puntos para que podamos visualizar la hélice.

1. PolyCurve.ByPoints: conecte la salida Point.ByCoordinates en la entrada points del nodo. Se obtiene una curva helicoidal.

2. Curve.PointAtParameter: conecte la salida de PolyCurve.ByPoints a la entrada curve. La finalidad de este paso es crear un punto atractor paramétrico que se deslice a lo largo de la curva. Dado que la curva está evaluando un punto en el parámetro, necesitaremos introducir un valor en param entre 0 y 1.

3. Number Slider: después de añadirlo al lienzo, cambie el valor mínimo a 0,0, el valor máximo a 1,0 y el valor de paso a 0,01. Conecte la salida del control deslizante a la entrada param de Curve.PointAtParameter. Ahora se muestra un punto a lo largo de la longitud de la hélice representado por un porcentaje del control deslizante (0 en el punto inicial, 1 en el punto final).

Con el punto de referencia creado, ahora comparamos la distancia desde el punto de referencia a los puntos originales que definen la hélice. Este valor de distancia controlará la geometría y el color.

1. Geometry.DistanceTo: conecte la salida de Curve.PointAtParameter a la entrada. Conecte Point.ByCoordinates en la entrada geometry.

2. Watch: la salida resultante muestra una lista de las distancias desde cada punto helicoidal hasta el punto de referencia a lo largo de la curva.

El siguiente paso consiste en controlar los parámetros con la lista de distancias entre los puntos helicoidales y el punto de referencia. Utilizamos estos valores de distancia para definir los radios de una serie de esferas a lo largo de la curva. Para mantener las esferas en un tamaño adecuado, es necesario reasignar los valores de la distancia.

1. Math.RemapRange: conecte la salida de Geometry.DistanceTo a la entrada "numbers".

2. Code Block: conecte un bloque de código con un valor de 0,01 a la entrada newMin y un bloque de código con un valor de 1 a la entrada newMax.

3. Watch: conecte la salida de Math.RemapRange a un nodo y la salida de Geometry.DistanceTo a otro. Compare los resultados.

Este paso ha reasignado la lista de distancias para que tenga un rango más pequeño. Podemos editar los valores de newMin y newMax según consideremos adecuado. Los valores se reasignarán y tendrán la misma relación de distribución en todo el dominio.

1. Sphere.ByCenterPointRadius: conecte la salida de Math.RemapRange a la entrada radius y la salida de Point.ByCoordinates original a la entrada centerPoint.

Cambie el valor del control deslizante de número y observe cómo se actualiza el tamaño de las esferas. Ahora tenemos una guía paramétrica.

El tamaño de las esferas muestra la matriz paramétrica definida por un punto de referencia a lo largo de la curva. Usaremos el mismo concepto para que el radio de la esfera controle su color.

1. Color Range: añádalo al lienzo. Al pasar el cursor sobre la entrada value, observamos que los números solicitados se encuentran entre 0 y 1. Es necesario volver a asignar los números de la salida de Geometry.DistanceTo para que sean compatibles con este dominio.

2. Sphere.ByCenterPointRadius: por el momento, desactivemos la vista preliminar en este nodo (Haga clic con el botón derecho > Vista preliminar).

1. Math.RemapRange: este proceso debería resultarle familiar. Conecte la salida de Geometry.DistanceTo a la entrada "numbers".

2. Code Block: como hicimos en un paso anterior, cree el valor 0 para la entrada newMin y el valor 1 para la entrada newMax. Observe que, en este caso, podemos definir dos salidas de un bloque de código.

3. Color Range: conecte la salida de Math.RemapRange a la entrada value.

1. Color.ByARGB: esto es lo que haremos para crear dos colores. Aunque este proceso puede parecer incómodo, es el mismo que el utilizado con los colores RGB en otro software, solo que usamos programación visual para ello.

2. Code Block: cree dos valores de 0 y 255. Conecte las dos salidas a las dos entradas de Color.ByARGB de acuerdo con la imagen anterior (o cree sus dos colores favoritos).

3. Color Range: la entrada colors requiere una lista de colores. Se debe crear esta lista a partir de los dos colores creados en el paso anterior.

4. List.Create: combine los dos colores en una lista. Conecte la salida a la entrada colors de Color Range.

1. Display.ByGeometryColor: conecte Sphere.ByCenterPointRadius a la entrada geometry y Color Range a la entrada color. Ahora tenemos un degradado suave en el dominio de la curva.

Si se cambia el valor del control deslizante de número mostrado anteriormente, se actualizan los colores y los tamaños. Los colores y el tamaño del radio están directamente relacionados en este caso; ahora tenemos un vínculo visual entre dos parámetros.

Ejercicio de color en superficies

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.

Es necesario crear primero una superficie o hacer referencia a ella para utilizarla como entrada en el nodo Display.BySurfaceColors. En este ejemplo, se realiza la solevación entre una curva seno y coseno.

1. Este grupo de nodos crea puntos a lo largo del eje Z y los desplaza según las funciones de seno y coseno. Las dos listas de puntos se utilizan a continuación para generar curvas NURBS.

2. Surface.ByLoft: genere una superficie interpolada entre las curvas NURBS de la lista.

1. File Path: seleccione un archivo de imagen para muestrear datos de píxeles.

2. Utilice File.FromPath para convertir la ruta de archivo en un archivo y, a continuación, páselo a Image.ReadFromFile para obtener una imagen para el muestreo.

3. Image.Pixels: introduzca una imagen y proporcione un valor de muestra para utilizarlo en las cotas X e Y de la imagen.

4. Control deslizante: proporcione valores de muestra para Image.Pixels.

5. Display.BySurfaceColors: asigne los valores de matriz de color de la superficie a lo largo de X e Y respectivamente.

Vista preliminar ampliada de la superficie de salida con resolución de 400 x 300 muestras

Dynamo, un entorno de programación visual, le permite diseñar la forma en que se procesan los datos. Los datos son números o texto, pero también lo es la geometría. Tal y como lo entiende el equipo, la geometría (denominada a veces geometría computacional) son los datos que se pueden utilizar para crear modelos atractivos, complejos o basados en el rendimiento. Para ello, debemos conocer los pormenores de los diversos tipos de geometría que podemos utilizar.