# Color 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. | Icono | Nombre (sintaxis) | Entradas | Salidas | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------- | -------- | ------- | | ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-cbf364cdeffabd85f71cb24ba3e47bb8f556fc28%2FColor%20byARGB.jpg?alt=media) | Color ARGB (**Color.ByARGB**) | A,R,G,B | color | ### 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. | Icono | Nombre (sintaxis) | Entradas | Salidas | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- | -------- | ---------- | | ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-49bc59f0727da7b48eb331e713d85429b3a430e6%2FColor%20Alpha.jpg?alt=media) | Alfa (**Color.Alpha**) | color | A | | ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-d77cc4fe65c37c99042780beae5bbf09e22c6d75%2FColor%20Red.jpg?alt=media) | Rojo (**Color.Red**) | color | R | | ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-a6e731e9bc7a0814ac0c65630cd4c787da887736%2FColor%20Green.jpg?alt=media) | Verde (**Color.Green**) | color | G | | ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-7f00c165eb7d34ad4dfa9799c987300f94ae03af%2FColor%20Blue.jpg?alt=media) | Azul (**Color.Blue**) | color | B | | ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-c27affe0144d651e7ff5d0e3d17cd067314c0cff%2FColor%20Component.jpg?alt=media) | Componentes (**Color.Components**) | color | A, R, G, B | 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. | Icono | Nombre (sintaxis) | Entradas | Salidas | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------- | -------- | ---------- | | ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-c484d578ab1cdfcd1ff8ae89b3cdd878678e344b%2FColor%20Hue.jpg?alt=media) | Matiz (**Color.Hue**) | color | Matiz | | ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-dc7ef438678697382c8f7d35932cc9876e947c63%2FColor%20Saturation.jpg?alt=media) | Saturación (**Color.Saturation**) | color | Saturación | | ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-98841424ef9041db133648e381f9697359c8e404%2FColor%20Brightness.jpg?alt=media) | Brillo (**Color.Brightness**) | color | Brillo | ### Color Range El rango de color es similar al nodo **Remap Range** del ejercicio [#part-ii-from-logic-to-geometry](https://primer2.dynamobim.org/es/5_essential_nodes_and_concepts/3-logic#part-ii-from-logic-to-geometry "mention"); 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-523094bd38363f801b1993a6c33f43670fe0bc83%2Fcolor%20-%20color%20range.jpg?alt=media) > 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**. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-392a193180acccedab6da65a4a46367fb76bca89%2Fcolor%20-%20color%20preview.jpg?alt=media) ### 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-86ed81769387291a62403fe3b1325eb00c70bbb2%2F12.jpg?alt=media) ## 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-b3aa6ba516c31f3b5ae9018495892b215c2f318a%2Fcolor%20-%20basic%20helix%20with%20colors%2001.jpg?alt=media) > 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-54adb34f5218a9c9454d895844c41f5fd768dd46%2Fcolor%20-%20basic%20helix%20with%20colors%2002.jpg?alt=media) > 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-9c22afb318d993eb2f088f5d487dc49c75dc2c99%2Fcolor%20-%20basic%20helix%20with%20colors%2003.jpg?alt=media) > 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-3e8dc934098e149adfc7538beffbf92d564c8899%2Fcolor%20-%20basic%20helix%20with%20colors%2004.jpg?alt=media) > 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-d73f213953dbe598f00d1179780f39781c8af365%2Fcolor%20-%20basic%20helix%20with%20colors%2005.jpg?alt=media) > 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-439fdeb3932452388a955c30a705a990e799e34c%2Fcolor%20-%20basic%20helix%20with%20colors%2006.gif?alt=media) 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-6114f713865077d05f43c19960cd8cc4f1165283%2Fcolor%20-%20basic%20helix%20with%20colors%2007.jpg?alt=media) > 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*). ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-36647dea9f49ae366b9da3048d83a14cf09d003c%2Fcolor%20-%20basic%20helix%20with%20colors%2008.jpg?alt=media) > 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*. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-41d7e60c615a17d1eca3d299b364bd8ddeddac40%2Fcolor%20-%20basic%20helix%20with%20colors%2009.jpg?alt=media) > 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**. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-381a9213045bb22f3f8d7d8057efc6c0c43d7d42%2Fcolor%20-%20basic%20helix%20with%20colors%2010.jpg?alt=media) > 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-2338cf2f0a9e58e11d0ca2d75f5e7b7653d10e7e%2Fcolor%20-%20basic%20helix%20with%20colors%2011.gif?alt=media) ### 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-7de0ac5c29be074438603977ed08b6c3c2b3a552%2Fcolor%20-%20color%20on%20surface%2001.jpg?alt=media) > 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. ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-42455318382bbf697350aac5ecf9f26af00ce09d%2Fcolor%20-%20color%20on%20surface%2002.jpg?alt=media) > 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 ![](https://4010443943-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F34TIEzzNzA4rkNWukVIo%2Fuploads%2Fgit-blob-917fa02e0679554e24a0b7ea485c2585be80a231%2Fcolor%20-%20color%20on%20surface%2003.jpg?alt=media)