Ejemplos de ImageMagick -- Creación de lienzos

Los lienzos son utilizados por ImageMagick tanto como imagen de partida sobre la que dibujar, como fondos para superponer imágenes con áreas transparentes, o incluso simplemente como parte del procesamiento general de imágenes. Pueden ser de un color sólido, de un rango de colores, o incluso un mosaico de una imagen más pequeña. Aquí se examinan solo algunos de los métodos que se pueden emplear para generar toda una gama de imágenes de lienzo.

Lienzos de color sólido

Generación directa

Generar un lienzo de un color y un tamaño concretos es muy sencillo. Basta con especificar "[-size](https://imagemagick.org/command-line-options/#size)" (que toma por defecto "1x1" si no se indica tamaño) y luego usar "canvas:" para generar un lienzo del color dado. Si no se especifica un color, se genera un lienzo 'white'. Por ejemplo... aquí se genera un lienzo de color 'khaki'. |

  magick -size 100x100 canvas:khaki  canvas_khaki.gif

Más habitualmente se usa un formato abreviado (y más tradicional) "xc:" (que significaba "X Constant Image", imagen constante de X). Esto es lo que suelo utilizar. Por ejemplo, aquí hay una imagen que usa el color de la ventana X 'wheat'. |

  magick -size 100x100 xc:wheat  canvas_wheat.gif

Usando algunos elegantes Modificadores de lectura de imagen podemos especificar una imagen de lienzo de color sólido como un único argumento. Esta técnica permite especificar una imagen de lienzo 'xc' de un tamaño y color concretos como un único argumento de 'imagen de entrada' en muchos scripts de ImageMagick. |

  magick 'xc:Salmon[100x100!]'  canvas_salmon.gif

| El '!' es necesario porque los números son valores de redimensionado; de lo contrario no se obtendrá el tamaño solicitado si no es cuadrado.
---|---

Si ya se ha creado un lienzo, pero se necesita uno de un color distinto, se puede reemplazar ese color usando el operador "[-opaque](https://imagemagick.org/command-line-options/#opaque)". |

  magick canvas_khaki.gif -fill tomato -opaque khaki canvas_tomato.gif

Incluso se puede tomar un único píxel de una imagen existente y expandirlo al tamaño de lienzo deseado. Usamos "[-scale](https://imagemagick.org/command-line-options/#scale)" para un redimensionado simple y rápido del único píxel. Aquí tomamos un color rosa de la imagen integrada "rose:". |

  magick rose: -crop 1x1+40+30 +repage -scale 100x100\! canvas_rose_red.gif

Crear una imagen del mismo tamaño

Una de las técnicas más básicas al usar ImageMagick es generar un lienzo del mismo tamaño que alguna imagen existente. Esto puede hacerse convirtiendo esa imagen existente en el lienzo necesario, pero conservando el tamaño original de la imagen. Por lo general no es solo el tamaño de la imagen lo que necesita conservarse, sino también todos los metadatos de la imagen. Es decir, elementos como etiquetas, comentarios, perfiles de color, retardos de tiempo, así como la compresión y la profundidad de guardado. Estos metadatos pueden ser importantes si se quiere anotar dicha información sobre el lienzo recién vaciado, o si se planea superponer la imagen original sobre el nuevo lienzo y se necesita conservar esa información. Naturalmente, IM ofrece numerosas formas de hacerlo, normalmente como efecto secundario del uso de varias operaciones de imagen. Solo unas pocas son muy claras en cuanto a su uso para vaciar una imagen a un color sólido. A la izquierda hay una imagen de prueba... No se preocupe por cómo generé realmente esta imagen, no es importante para el ejercicio. La diseñé para que contuviera una gama de colores, transparencias y otras características, específicamente para someter a IM a una buena prueba al usarla. Si de verdad le interesan los comandos usados para generar esta imagen, puede consultar el script especial "generate_test", que uso para crearla.

Superponer un color concreto

A partir de IM v6.4.2-1 se puede usar "[+level-colors](https://imagemagick.org/command-line-options/#level_colors)" con un único color y sin comas, para establecer todos los colores. |

  magick test.png  -alpha Opaque +level-colors Sienna  color_levelc.gif

Observe el uso del operador "[-alpha](https://imagemagick.org/command-line-options/#alpha)" para fijar la transparencia a algo útil antes (o después) de añadir el color. Como alternativa, se podría usar "-channel All" para asegurar que el canal de transparencia también quede establecido por la operación de reajuste del color. Otra técnica más antigua consiste en usar "[-colorize](https://imagemagick.org/command-line-options/#colorize)" para superponer el color de relleno pero con un valor totalmente opaco. Sin embargo, antes de IM v6.7.9 no se modificaba el canal alfa de la imagen original, así que es buena idea desactivar primero el canal alfa, usando "[-alpha](https://imagemagick.org/command-line-options/#alpha) [Off](masking.html#alpha_off)", o hacerlo opaco con "[-alpha](https://imagemagick.org/command-line-options/#alpha) [Opaque](masking.html#alpha_off)", aunque se obtendría el mismo resultado sin ello. |

  magick test.png -alpha off -fill Chocolate -colorize 100%
color_colorize.gif

| Tenga en cuenta que "[-alpha](https://imagemagick.org/command-line-options/#alpha) [Off](masking.html#alpha_off)" (o el equivalente más antiguo "[-alpha off](https://imagemagick.org/command-line-options/#matte)") solo desactiva el canal alfa. Si lo vuelve a activar con On después, se restaurará el canal alfa original (que se había conservado). Antes de IM v6.7.9 el alfa se conservaba al usar "[-colorize](https://imagemagick.org/command-line-options/#colorize)".
---|---

A partir de IM v6.4.3-0 se puede usar el operador "[-sparse-color](https://imagemagick.org/command-line-options/#sparse-color)" para fijar algún punto al color deseado y hacer que se extienda hasta cubrir toda la imagen, usando prácticamente cualquier método de coloreado que ofrezca (véase Puntos de color dispersos más abajo). |

  magick test.png  -alpha Off \
          -sparse-color Voronoi '0,0 Peru' color_sparse.gif

Una forma más general es usar "[-draw](https://imagemagick.org/command-line-options/#draw)" para reajustar directamente todos los colores de la imagen actual al color "[-fill](https://imagemagick.org/command-line-options/#fill)" vigente. |

  magick test.png -fill Tan -draw 'color 0,0 reset' color_reset.gif

Este era el método recomendado en la versión 5 de ImageMagick.
La principal objeción a todos los métodos 'simples' anteriores es que ninguno reajusta sin más la imagen al color "[-background](https://imagemagick.org/command-line-options/#background)" actual. El siguiente conjunto de métodos hace uso de la Composición alfa para forzar a varios operadores a reemplazar la imagen por el color deseado. Estas técnicas con varias imágenes funcionan con operadores que usan "[-compose](https://imagemagick.org/command-line-options/#compose)". Por ejemplo, se puede usar "[-flatten](https://imagemagick.org/command-line-options/#flatten)" (véase el ejemplo Aplanar sobre el fondo), que crea un lienzo usando el color "[-background](https://imagemagick.org/command-line-options/#background)". |

  magick test.png   -background Wheat \
            -compose Dst   -flatten   color_flatten.gif

Lo anterior usa el método de composición '[Dst](compose.html#Dst)' para leer solo el lienzo de fondo e ignorar los colores de los píxeles de la imagen original. Si solo se desea tomar los metadatos de la imagen original (como los datos de comentario o etiqueta), pero reemplazar la imagen en sí por una imagen de lienzo de un color y tamaño concretos, entonces el operador "[-extent](https://imagemagick.org/command-line-options/#extent)" (véase Extent, ajuste directo del tamaño de imagen) puede ser la mejor solución. De nuevo se usa el método de composición [Dst](compose.html#Dst)' para que ignore los datos de píxel de la imagen original y use solo el color "[-background](https://imagemagick.org/command-line-options/#background)". |

  magick test.png   -background LemonChiffon \
            -compose Dst   -extent 100x100   color_extent.gif

O se puede usar "[-border](https://imagemagick.org/command-line-options/#border)" (véase Añadir un borde), usando "[-bordercolor](https://imagemagick.org/command-line-options/#bordercolor)" como fuente del color. |

  magick test.png   -bordercolor Khaki \
            -compose Dst   -border 0   color_border.gif

Este último método tiene la ventaja añadida de permitir también ampliar ligeramente el lienzo de la imagen respecto al tamaño de la imagen original. | El método de generación de lienzos con "[-border](https://imagemagick.org/command-line-options/#border)" no funcionará con versiones de IM anteriores a la 6.1.4. Antes de esta, el fondo generado por el operador "[-border](https://imagemagick.org/command-line-options/#border)" no era un simple color sólido, sino un lienzo negro rodeado por el color del borde. No muy útil.
---|---
Un método de generación de lienzos más flexible (pero muy lento) lo proporcionaba el operador "[FX, operador hágalo usted mismo](transform.html#fx)". También será necesario desactivar el canal de transparencia de la imagen de entrada, ya que por defecto "[-fx](https://imagemagick.org/command-line-options/#fx)" no toca el canal de transparencia. |

  magick test.png -alpha off -fx Gold  color_fx_constant.gif

El operador "[-fx](https://imagemagick.org/command-line-options/#fx)" incluso permite hacer algo de matemática de colores. Por ejemplo, ¿qué tal un color oro un 70% más oscuro... |

  magick test.png -alpha off -fx "Gold*.7"  color_fx_math.gif

Todos los métodos anteriores no solo pueden rellenar usando un color totalmente opaco, sino que también pueden usar colores semitransparentes. No obstante, conviene asegurarse de que la imagen tenga un canal de transparencia de antemano. Aquí, por ejemplo, creamos un lienzo con un rojo semitransparente. Sin embargo, al superponerlo sobre el fondo 'azulado' de las páginas web obtenemos un color rosa-púrpura apagado. |

  magick test.png -alpha set -fill '#FF000040' -draw 'color 0,0 reset' \
            color_semitrans.png

Tenga en cuenta también que, al usar el operador "[-fx](https://imagemagick.org/command-line-options/#fx)" con transparencia, será necesario fijar "[-channel](https://imagemagick.org/command-line-options/#channel)" para modificar los cuatro canales de color 'RGBA'.

Vaciar una imagen con un color seleccionado

También es posible vaciar imágenes usando un color de la imagen original, aunque puede resultar complicado. Es una técnica útil cuando se quiere usar un píxel concreto como 'color de fondo'. Por ejemplo, el píxel 0,0 es una elección habitual. En los siguientes ejemplos seleccionaré colores de varios píxeles de la imagen integrada rose (mostrada a la izquierda) a medida que vacío la imagen. El método más obvio (aunque lento) es simplemente usar el "[FX, operador hágalo usted mismo](transform.html#fx)" para seleccionar el píxel que se usará en el vaciado de color. |

  magick rose: -fx 'p{0,0}'  color_pick_fx.png

Sin embargo, esto puede acelerarse seleccionando el píxel una sola vez. Esto puede hacerse usando la fórmula fx como argumento de Sparse Color. Puede parecer menos simple, pero es mucho más rápido. |

  magick rose: -sparse-color voronoi '0,0 %[pixel:p{40,30}]'
color_pick_sparse.png

Otro método más complejo consiste en recortar ese único píxel y disponerlo en mosaico por toda la imagen, usando técnicas descritas en detalle más adelante en Mosaico con una imagen ya en memoria |

  magick rose: \( +clone -crop 1x1+64+22 -write MPR:pixel +delete \) \
          -fill mpr:pixel  -draw 'color 0,0 reset' \
          color_pick_draw.png

|

  magick rose: -set option:distort:viewport '%wx%h+0+0' \
          -crop 1x1+10+25 +repage     -distort SRT 0 \
          color_pick_distort.png

Otras técnicas de lienzo

Existen muchas otras formas de generar lienzos de colores muy concretos, pero son bastante enrevesadas. Por ello, sin comentarios abundantes, puede no resultar evidente qué se está haciendo realmente cuando se revisa el script de IM meses o años después. No recomiendo estas técnicas, pero conviene conocerlas si se usan versiones de IM más antiguas y menos flexibles. Lienzo negro-threshold", y luego desactivar el canal de transparencia. Tradicionalmente se puede crear un lienzo negro usando "

  magick test.png -threshold 100% -alpha off  black_threshold.png

-level" con el mismo argumento tanto para el punto 'black' como para el 'white' tendrá el mismo efecto. Proporcionar el operador "

  magick test.png -level 100%,100% -alpha off  black_level.png

-fx" proporciona una forma más obvia de crear un lienzo negro poniendo a cero todos los píxeles. No obstante, también será necesario reajustar el canal alfa para hacerlo totalmente opaco. El operador "

  magick test.png  -fx 0 -alpha off   black_fx.png

-evaluate" de esto debería ser más rápida, sobre todo en imágenes más grandes. Sin embargo, la versión "

  magick test.png  -evaluate set 0  -alpha off  black_evaluate.png

-gamma" para dejar una imagen totalmente negra. También se puede hacer un uso indebido del operador "

  magick test.png  -gamma 0  -alpha off  black_gamma.png

Una forma menos obvia es 'posterizar' la imagen con muy pocos niveles de color, lo que resulta en que se use un solo color, el negro. |

  magick test.png  -posterize 1 -alpha off black_posterize.png

Operador alfa Se puede asegurar que la imagen sea totalmente transparente y luego 'extract' la máscara de la imagen, usando el

  magick test.png  -alpha transparent -alpha extract  black_alpha.png

Lienzo blanco-threshold". El valor, sin embargo, debe ser un número negativo, solo para asegurar que todos los colores se asignen a blanco, en todas las versiones de IM. La forma tradicional es de nuevo usar "

  magick test.png  -threshold -1 -alpha off   white_threshold.png

-level" con el mismo argumento tanto para el punto 'black' como para el 'white' tendrá el mismo efecto. Proporcionar el operador "

  magick test.png -level -1,-1 -alpha off  white_level.png

-fx". Por supuesto, se pueden fijar los valores de los píxeles directamente usando el operador "

  magick test.png -fx 1.0 -alpha off  white_fx.png

-evaluate" de esto debería ser más rápida, sobre todo en imágenes más grandes. Sin embargo, la versión "

  magick test.png  -evaluate set 100%  -alpha off  white_evaluate.png

O negar algún otro método de generación de lienzo negro. |

  magick test.png -posterize 1 -alpha off -negate  white_posterize.png

Operador alfa Se puede asegurar que la imagen sea totalmente opaca (sin transparencia) y luego 'extract' la máscara de la imagen, usando el

  magick test.png  -alpha opaque -alpha extract  white_alpha.png

Lienzo transparenteProbablemente el lienzo más importante que se desea generar a partir de una imagen existente es un lienzo transparente. Sobre él se pueden dibujar y añadir cosas, dejarlo como se quiera y luego superponerlo sobre la imagen original. -alphatransparent" (añadido en IM v6.4.3-7). La forma más rápida y sencilla es hacer que IM vacíe directamente la imagen a transparencia, usando el operador "

  magick test.png  -alpha transparent trans_alpha.png

Sin embargo, como esta es una incorporación muy reciente, probablemente aún no esté ampliamente disponible.

Clear', con cualquier imagen de superposición (un único píxel "null:" en este caso), ya que se ignorará. Podemos crear un lienzo 'negro' totalmente transparente usando el operador de composición alfa '

  magick test.png  null: -alpha set -compose Clear -composite -compose Over \
          trans_compose.png

-fill". En este caso hacerlo totalmente transparente. Aquí usamos el operador "-draw matte" para reemplazar el valor del canal mate (transparencia) por el valor de transparencia del color "

  magick test.png -alpha set -fill none  -draw 'matte 0,0 reset'
color_matte.png

-fx" operador. También podemos hacer esto de forma más directa con el operador "

  magick test.png -alpha set -channel A -fx 0 +channel  trans_fx.png

-evaluate" de esto debería ser más rápida, en particular con imágenes más grandes. Naturalmente, la versión "

  magick test.png  -alpha set -channel A -evaluate set 0 +channel \
          trans_evaluate.png

-threshold" pero limitando de nuevo sus efectos únicamente al canal de transparencia. Otra forma de hacer la imagen completamente transparente es usar "

  magick test.png -channel A -threshold -1 +channel trans_threshold.png

En realidad, en este caso estamos tratando matemáticamente con un canal 'matte', usando el umbral para establecerlo en su valor máximo, en lugar de cero como hicimos con el operador "-fx". Por eso se usó un '-1' en el ejemplo anterior, en lugar de algo como 101%'. En muchos de los resultados de imagen anteriores, los colores RGB originales de la imagen siguen presentes; simplemente se han vuelto transparentes. Por ejemplo, aquí leemos una de las imágenes anteriores y le pedimos a IM que desactive el canal matte/alfa de la imagen para hacer los colores visibles de nuevo. |

  magick trans_fx.png -alpha off  trans_fx_alpha_off.jpg

Tenga en cuenta, no obstante, que no todos los formatos de archivo de imagen, y muy pocas operaciones de imagen, conservarán los colores RGB parcialmente transparentes que siguen presentes en la imagen resultante.
Como se mencionó antes, y vale la pena repetir, muchos de los métodos anteriores dependen de que la imagen ya tenga un canal alfa. Si no lo tiene, añada uno usando "[-alpha](https://imagemagick.org/command-line-options/#alpha) [On](masking.html#alpha_on)", pero en ese caso bien puede usar directamente el operador "[-alpha](https://imagemagick.org/command-line-options/#alpha) Transparent". Vea los ejemplos en Control de la transparencia de la imagen. Coloración diversa del lienzoAparte de usar un color específico, solo el operador "-gamma" es realmente lo bastante flexible para generar un lienzo de cualquier color primario/secundario. Básicamente se usa 0 para anular un canal y -1 para maximizar los valores de un canal. Por ejemplo, aquí genero un lienzo amarillo... |

  magick test.png  -gamma -1,-1,0  -alpha off  yellow_gamma.png

A partir de IM v6.4.2 también se puede usar el operador "[+level](https://imagemagick.org/command-line-options/#level)" para establecer un nivel de gris específico en todos los canales de color. |

  magick test.png  +level 40%,40%  -alpha off  grey_level.png

Degradados de color

Como vio arriba, es bastante fácil crear lienzos de colores sólidos. Pero a veces se quiere algo más interesante. Uno de los operadores de creación de imágenes muy útiles es "gradient:". Por ejemplo... |

  magick -size 100x100 gradient:  gradient.jpg

Como puede ver, por defecto "gradient:" crea una imagen con blanco arriba y negro abajo, y un suave sombreado de gris a lo largo de la altura de la imagen. Pero no tiene por qué ser solo un degradado en escala de grises; también puede generar un degradado de colores distintos especificando un color, o ambos.

  magick -size 100x100  gradient:blue              gradient_range1.jpg
  magick -size 100x100  gradient:yellow            gradient_range2.jpg
  magick -size 100x100  gradient:green-yellow      gradient_range3.jpg
  magick -size 100x100  gradient:red-blue          gradient_range4.jpg
  magick -size 100x100  gradient:tomato-steelblue  gradient_range5.jpg

Observe que, cuando se da un solo color, el segundo color será 'white' o 'black', el que produzca la mayor distancia de color respecto al color dado. Así, 'blue' produce un degradado 'blue-white', mientras que 'yellow' genera un degradado 'yellow-black'. El degradado 'red-blue' muestra una banda de colores púrpura mucho más oscura en el centro. Este oscurecimiento se debe al uso del espacio de color sRGB no lineal, más oscuro, especialmente con colores primarios intensos. Vea Procesamiento de imágenes reales para más detalles. | _"gradient:" actualmente solo entiende representaciones de color en el espacio de color sRGB Color Space. Por ello no se puede usar para generar un degradado 'púrpura' más brillante y correcto usando los colores 'red-blue' en un espacio de color LAB lineal.

También significa que no se pueden generar degradados 'arcoíris' multicolor usando el espacio de color HSV.

Sin embargo, se pueden 'simular' tales degradados de forma relativamente sencilla. Vea Degradados en otros espacios de color más abajo.
---|---
| _Actualmente los degradados no se pueden especificar en otros ángulos ni con más de dos colores. No obstante, como esta capacidad es parte integral de los degradados SVG, es probable que esta situación cambie, con una mejora importante en las opciones de degradado.
---|---
Algunos degradados especialmente agradables incluyen... |

  magick -size 10x120  gradient:snow-navy          gradient_ice-sea.jpg
  magick -size 10x120  gradient:gold-firebrick     gradient_burnished.jpg
  magick -size 10x120  gradient:yellow-limegreen   gradient_grassland.jpg
  magick -size 10x120  gradient:khaki-tomato       gradient_sunset.jpg
  magick -size 10x120  gradient:darkcyan-snow      gradient_snow_scape.jpg

| _A partir de IM v6.3.1 el algoritmo usado para generar degradados ahora produce colores horizontalmente uniformes, de modo que a todos los píxeles de cada fila de una imagen se les asigna el mismo color. Es decir, un color por fila.

Antes de esta versión, el operador "gradient:" funcionaba ignorando el ancho de la imagen, asignando simplemente el siguiente incremento de color, fila por fila desde la esquina superior izquierda hasta la inferior derecha de la imagen.

Como resultado, el degradado era predominantemente vertical, igual que ahora, pero no uno perfecto. Por lo general, este hecho solo era importante en casos especiales como imágenes de prueba, y para su uso en Mapeo de imágenes.

_
---|---

Tenga en cuenta que el comportamiento de los degradados puede verse afectado por estas definiciones:

Degradados radiales

A partir de IM v6.4.4 también se pueden generar imágenes de degradado radial de forma similar. |

  magick -size 100x100 radial-gradient:  rgradient.jpg

Tenga en cuenta que el degradado está centrado en medio de la imagen generada y tiene un diámetro ajustado para encajar con el mayor entre el tamaño X o Y de la imagen. Por tanto, si el tamaño de la imagen no es cuadrado, obtendrá un degradado radial 'recortado'. |

  magick -size 100x60 radial-gradient:  rgradient_clip.jpg

Esto permite generar fácilmente un degradado radial cuadrado desde el centro hasta una esquina haciendo un borde 1.42 (raíz cuadrada de 2) veces mayor, y recortándolo. |

  magick -size 100x142 radial-gradient: \
          -gravity center -crop 100x100+0+0 rgradient_crop.jpg

Los colores del degradado en sí siguen las mismas convenciones que el generador de imágenes lineal "[gradient:](#gradient)", mucho más antiguo.

  magick -size 100x100  radial-gradient:blue              rgradient_range1.jpg
  magick -size 100x100  radial-gradient:yellow            rgradient_range2.jpg
  magick -size 100x100  radial-gradient:green-yellow      rgradient_range3.jpg
  magick -size 100x100  radial-gradient:red-blue          rgradient_range4.jpg
  magick -size 100x100  radial-gradient:tomato-steelblue  rgradient_range5.jpg

Degradados con transparencia

A partir de IM v6.2.9-8 el operador de creación de imágenes "gradient:" (y posteriormente "radial-gradient:") admite el uso de colores transparentes y semitransparentes. |

  magick -size 100x100 gradient:none-firebrick gradient_transparent.png

| _Antes de ImageMagick 6.5.4-7 los degradados que implicaban transparencia completa (como en el último ejemplo) producían por lo general un halo negro.

Lo que ocurría es que el degradado generado iba del color dado al color especial 'none' o negro transparente. Como resultado, los colores se sombreaban hacia un negro semitransparente antes de volverse completamente transparentes.

La solución a este problema era generar un degradado de transparencia y luego colorearlo con el color deseado._
---|---
|

  magick -size 100x100 gradient:none-black \
          -fill firebrick -colorize 100% gradient_trans_colorize.png

Degradados por ajuste de histograma

Puede crear un degradado no lineal aplicando alguna forma de ajuste de histograma a un degradado lineal. Por ejemplo, puede usar una función de contraste sigmoidal para crear un degradado de aspecto más natural. |

  magick -size 100x100 gradient: -sigmoidal-contrast 6,50% \
            gradient_sigmoidal.jpg

Este tipo de degradado es especialmente bueno para generar fotos superpuestas, ya que elimina los cambios bruscos del degradado al inicio de la región de superposición.

Degradados con Evaluate/Function

También puede usar el operador Evaluate y el operador Function relacionado para modificar un degradado lineal simple. |

  magick -size 100x100 gradient: -evaluate cos 0.5 -negate \
            gradient_cosine.jpg

O dar un paso más y crear un pico parabólico suave en el centro del degradado lineal. |

  magick -size 100x100 gradient: -function Polynomial -4,4,0 \
            gradient_peak.jpg

O una banda o un patrón ondulado... |

  magick -size 100x100 gradient: -function sinusoid 4,-90  \
            gradient_bands.jpg

Ambos operadores, estrechamente relacionados, permiten modificar imágenes y degradados a partir de funciones matemáticas de curvas sinusoidales, polinomios, logarítmicas y de potencia. Vea Funciones matemáticas de Evaluate y Function, Evaluate de varios argumentos para más ejemplos.

Degradados distorsionados

Degradado rotado

Aunque el método '[Barycentric](#barycentric)' de color disperso (vea más abajo) ofrece una forma cómoda de generar degradados en cualquier ángulo, si su IM es anterior a la versión 6.4.3-0 puede que necesite usar otros métodos para generar un degradado diagonal o rotado. Por ejemplo, aumentando el tamaño de la imagen del degradado (multiplicando por la raíz cuadrada de 2, o 1.42), luego rotándola 45 grados y recortando la imagen a su tamaño final, puede crear un degradado diagonal. |

  magick -size 142x142 gradient: -rotate -45 \
          -gravity center -crop 100x100+0+0 +repage \
          gradient_diagonal.jpg

A partir de IM v6.3.5 dispone de una forma mucho más rápida y sencilla de generar un degradado rotado usando una distorsión SRT. Por ejemplo, aquí hay un degradado de 100 píxeles rotado 60 grados, en una imagen de 100x100 píxeles. |

  magick -size 100x100 gradient: -distort SRT 60 gradient_srt.jpg

Esto usa la configuración por defecto Píxel virtual, Edge para asegurar que el degradado solicitado cubra toda la imagen. También puede usar la configuración avanzada Distort Viewport para mapear un degradado sobre una imagen más grande, como para su uso en fotos superpuestas.

Deformación de degradados

Pero puede usar los mismos métodos de distorsión para hacer mucho más que simples rotaciones. El degradado también puede retorcerse... |

  magick -size 100x100 gradient: -swirl 180 gradient_swirl.jpg

Puede reasignar el degradado a una forma trapezoidal. |

  magick -size 100x100 gradient: -rotate -90 \
          -distort Perspective '0,0 40,0  99,0 59,0  0,99 -10,99 99,99 109,99' \
          gradient_trapezoid.jpg

O envolver el degradado en arcos y círculos usando el operador de distorsión general... |

  magick -size 100x100 gradient: -distort Arc '180 0 50 0' \
          gradient_arc.jpg

|

  magick -size 100x100 gradient: -distort Arc '360 0 50 0' \
          gradient_circle.jpg

Aunque el nuevo "[radial-gradient:](#radial-gradient)" es probablemente el método más sencillo para generar estos degradados. Un degradado muy útil pero más difícil de generar es el degradado de ángulo polar. La forma exacta de este degradado depende de si debe centrarse en una imagen de tamaño par o de tamaño impar. Por ejemplo, una distorsión Arc puede usarse para generar imágenes con un número par de dimensiones en píxeles, 76 píxeles en este caso. |

  magick -size 1x1000 gradient: -rotate 90 \
          -distort Arc '360 -90 50 0' +repage \
          -gravity center -crop 76x76+0+0 +repage  gradient_angle_even.png

El '-90' anterior establece el ángulo de la 'discontinuidad' donde 'cero' y 'máximo' se enlazan en el mismo valor. El valor '50' debería ser de más de 1/2 del tamaño de la imagen recortada final. Observe cómo usé un degradado mucho más largo para generar la imagen más pequeña. Esto mejora la corrección general del resultado, especialmente a medida que la imagen se hace más grande. La estrechamente relacionada distorsión Polar también puede generar tal degradado, pero como tiene control sobre la posición exacta del 'centro' de la distorsión, puede asegurar que genere correctamente una imagen de degradado polar de tamaño impar en píxeles. En este caso, una imagen de 75 píxeles (radio = '36.5' ) |

  magick -size 1x1000 gradient: -rotate 90 \
          +distort Polar '36.5,0,.5,.5' +repage \
          -transverse  gradient_angle_odd.png

Las dos últimas imágenes pueden parecer muy similares, salvo por su tamaño, pero el tratamiento de los píxeles más centrales es ligeramente distinto. Si mira con atención verá que el último ejemplo tiene un píxel central gris perfecto, mientras que el ejemplo anterior no tiene un único píxel central, sino cuatro. El tamaño final de la imagen quedó determinado por el valor '36.5', que es la mitad de los '75' píxeles deseados. Los desplazamientos '.5' son el aspecto importante para el tratamiento correcto del centro polar. Tenga en cuenta que, por defecto, la distorsión coloca la discontinuidad en la parte superior de la imagen, por lo que la deformación Transverse corrige el ángulo y la ubicación de la discontinuidad para que coincidan con la producida por la distorsión Arc. Aquí hay una variante ligeramente distinta que genera un degradado angular pero con una máscara circular transparente. |

  magick -size 50x1000 gradient: -rotate 90 -alpha set \
          -virtual-pixel Transparent +distort Polar 49 +repage \
          -transverse  gradient_angle_masked.png

El valor '49' es el radio menos 1, ya que por defecto una distorsión añade un búfer de antialiasing de 1 píxel alrededor de la imagen resultante. Así, la imagen final es de 100x100 píxeles.
Las formas y degradados circulares pueden deformarse para producir interesantes degradados no lineales. Por ejemplo, arquearlo usando una distorsión Wave puede generar un degradado de forma aproximadamente triangular. |

  magick -size 100x100 radial-gradient: \
          -background black -wave -28x200 -crop 100x100+0+0 +repage \
          gradient_triangle.jpg

O una forma muy extraña parecida a un pájaro, generada mediante distorsión polar a lo largo del borde superior de la forma circular. |

  magick -size 100x100 radial-gradient: \
          +distort Polar '49' +repage \
          gradient_bird.jpg

Degradados por composición

También puede modificar degradados combinándolos mediante varios métodos de composición. Por ejemplo, puede usar el método de composición Modulus_Add para producir degradados de tipo persiana veneciana. |

  magick -size 100x100 gradient: \( +clone +clone \) \
          -background gray50 -compose ModulusAdd -flatten \
          gradient_venetian.jpg

E incluso hacerlo en diagonal. |

  magick -size 100x100 gradient: \( gradient: -rotate -90 \) \
          \( -clone 0--1 -clone 0--1 \) \
          -background gray50 -compose ModulusAdd -flatten \
          gradient_vent_diag.jpg

O mezclando dos degradados de color plano mediante los métodos de composición de Copia de canal o de Mezcla matemática, puede generar degradados de mapa de color coloridos en dos dimensiones. |

  magick -size 100x100 gradient:yellow-blue \
          \( gradient:black-lime -rotate -90 \) \
          -compose CopyGreen -composite  gradient_colormap.jpg

Degradados en otros espacios de color

Aunque el generador "gradient:" actualmente no puede generar degradados directamente en algún otro Espacio de color, (solo se crean imágenes de degradado sRGB no lineal) puede transferir degradados a un espacio de color diferente para generar efectos interesantes. Por ejemplo...

  magick -size 30x600 xc:red -colorspace HSB \
          gradient: -compose CopyRed -composite \
          -colorspace RGB -rotate 90  gradient_rainbow.jpg

Esto primero convierte un color muy saturado ('red') al espacio de color HSL; puede usarse cualquier color saturado. Esto ajusta correctamente los canales de saturación y brillo de la imagen a los valores apropiados. Después de esto se genera un degradado y se copia en el canal 'Tono' (equivalente al 'rojo') de esta imagen en espacio de color HSL. Y, como por arte de magia, cuando convertimos la imagen HSL de vuelta a RGB, obtenemos un degradado de arcoíris completo de colores totalmente saturados. Otro método es generar un degradado con justo los valores correctos para uno de estos espacios de color, y luego cambiar el espacio de color de la imagen (mediante "[-set](https://imagemagick.org/command-line-options/#set)"). Esto cambia el espacio de color sin cambiar los valores de color que creamos en la imagen. Ahora, cuando convertimos de vuelta a RGB, obtenemos el mismo arcoíris de valores.

  magick -size 30x600 gradient:'#FFF-#0FF' -rotate 90 \
          -set colorspace HSB -colorspace RGB \
          gradient_rainbow_2.jpg

El resultado es en realidad exactamente el mismo que el del método anterior, solo que un poco más directo, en que generamos los valores correctos para el espacio de color deseado y luego establecemos el espacio de color al que pertenecen esos valores. Aquí tomamos el degradado angular enmascarado (véase arriba) y lo reasignamos al espacio de color HSB para generar un tono circular de colores. El rojo (tono=0) se rota hacia la derecha, donde tradicionalmente se coloca (coordenadas polares, ángulo 0). |

  magick -size 100x300 gradient:'#FFF-#0FF' -rotate 90 \
          -alpha set -virtual-pixel Transparent +distort Polar 49 +repage \
          -rotate 90 -set colorspace HSB -colorspace RGB \
          gradient_hue_polar.png

Un ejemplo similar al anterior es la Rueda de color, que se genera Combinando imágenes de canal con un degradado de Tono y otro de Luminosidad.

Degradado redimensionado

Un truco que planteó Glenn Randers-Pehrson consistía en crear una imagen muy pequeña, de dos píxeles de ancho, y luego expandirla al tamaño de imagen necesario mediante "[-resize](https://imagemagick.org/command-line-options/#resize)". El Operador de redimensionado intenta suavizar las imágenes ampliadas, para que se vean mejor a mayor escala. Es este suavizado lo que usamos para generar un degradado no lineal. Por ejemplo, aquí generamos la imagen pequeña usando una imagen de 'mapa de bits portable' (o formato PBM) y la pasamos a IM para su ampliación. |

  echo "P1 1 2   0  1 " | \
  magick - -resize 100x100\!   gradient_resize.jpg

| Algunos intérpretes de comandos como 'csh' y sus variantes no manejan muy bien el carácter '!' en el ajuste de geometría de redimensionado anterior, ni siquiera entre comillas. Por ello puede ser necesario el carácter de barra invertida '\'. Se recomienda precaución.
---|---
El degradado producido no es lineal, con un inicio y un final suaves para los colores dados, lo que hace que esos colores sean mucho más pronunciados que los que obtendría usando un degradado normal. La función real que sigue el degradado depende de (y se aproxima a) el Filtro de remuestreo exacto que usó el redimensionado. Una forma sencilla de generar esa imagen inicial de dos píxeles es, de hecho, ¡con el propio degradado! Esto le permite especificar los colores directamente. Por supuesto, eso lo limitará a un degradado vertical, a menos que también rote el resultado. |

  magick -size 1x2  gradient:khaki-tomato \
          -resize 100x100\!   gradient_resize2.jpg

Por supuesto, con esta técnica no está limitado a una sola dimensión. Aquí uso un 'mapa de grises portable' (o formato de imagen PGM) de cuatro píxeles para generar un degradado bidimensional. |

  echo "P2 2 2 2   2 1 1 0 " | \
  magick - -resize 100x100\!   gradient_resize3.jpg

Como puede ver, este degradado diagonal no es muy lineal en comparación con el Degradado rotado anterior. | Los formatos de imagenNetwork Portable Bitmap son muy versátiles para generar imágenes a partir de scripts. Es un formato que bien vale la pena conocer como medio para generar o manipular datos de imagen.
---|---
Si observa con atención, también verá que el degradado comienza desde el centro del píxel ampliado, y no cubre toda la imagen de borde a borde. Esto queda más claro si usamos un Filtro de redimensionado triangular. |

  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -filter triangle -resize 100x100\!   gradient_resize4.jpg

El Operador de redimensionado suaviza el color entre estos píxeles según los ajustes del "[Filtro de remuestreo](filter.html#filter)". Ajustando el filtro puede hacer que el degradado de redimensionado genere un efecto más de borde a borde. |

  magick -size 1x2  gradient: \
          -filter Cubic  -resize 100x100\!    gradient_resize5.jpg

Aquí hay un "Degradado de arcoíris" aproximado creado usando la técnica de 'redimensionado'.

  magick xc:black xc:red xc:yellow xc:green1 xc:cyan xc:blue xc:black \
          +append -filter Cubic -resize 600x30\! gradient_rs_rainbow.jpg

Con este método puede usar cualquier combinación y orden de colores para la generación de degradados. Esto lo hace muy adecuado para generar Tablas de búsqueda de color.

Degradados de búsqueda interpolada

Para más información sobre el ajuste "[-interpolate](https://imagemagick.org/command-line-options/#interpolate)" véase Ajuste de interpolación. Otro método de generar degradados es usar el Ajuste de interpolación especial. Este ajuste se usa para determinar el color de píxel devuelto cuando la búsqueda de píxel no es un entero y, por lo tanto, no coincide exactamente con un píxel específico. La interpolación entonces determina el color en función de los píxeles que rodean el punto de búsqueda. El ajuste predeterminado de 'bilinear', por ejemplo, determinará linealmente el color de una búsqueda que caiga entre dos píxeles.

  magick -size 600x30 xc:   \( +size xc:gold xc:firebrick +append \)  \
          -fx 'v.p{i/(w-1),0}'    gradient_interpolated.jpg

Aquí la posición X de búsqueda 'i/(w-1)' va de '0.0' a '1.0' sobre la segunda imagen de dos píxeles. El número de punto flotante produce un degradado lineal perfecto, muy parecido a lo que hace "[gradient:](#gradient)". Lo anterior es de hecho casi equivalente (véase Degradados perfectos para la diferencia) a usar Imágenes recoloreadas con Clut" para recolorear una imagen de degradado, mediante búsqueda interpolada de la imagen de dos colores.

  magick -size 30x600 gradient: -rotate 90 \
          \( +size xc:gold xc:firebrick +append \) -clut \
          gradient_clut_recolored.jpg

Usar este método también le permite generar degradados multicolores.

  magick -size 30x600 gradient: -rotate 90  -interpolate Bicubic \
          \( +size xc:black xc:tomato xc:wheat +append \) -clut \
          gradient_clut.jpg

La limitación, sin embargo, es que los colores solo pueden definirse con espaciado igual. No puede simplemente desplazar la posición del color central, salvo modificando aproximadamente el degradado de entrada a alguna forma no lineal, para desplazar ese centro. Para más de tres colores la situación se vuelve peor. Lo anterior también es una buena técnica para colorear imágenes en escala de grises usando Duotonos, con la garantía de definir exactamente el color de tono medio (a diferencia de usar el Operador de tinte).
Los degradados de búsqueda interpolada también pueden expandirse a 2 dimensiones, y generar degradados lineales cuadrados (Interpolación bilineal), con la misma facilidad que los degradados puramente de una dimensión. |

  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap  -fx 'v.p{i/(w-1),j/(h-1)}' \
          gradient_bilinear.jpg

Aquí está el mismo ejemplo pero usando Interpolación Catrom, y generando mediante el Operador de distorsión en lugar del muy lento operador FX. |

  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -filter point -interpolate catrom \
          -define distort:viewport=100x100 \
          -distort Affine '.5,.5 .5,.5   1.5,1.5 99.5,99.5' \
          gradient_catrom.jpg

El punto clave para entender lo anterior es que estamos ampliando la imagen pequeña en función de los centros de sus píxeles. Véase Coordenadas de imagen vs. coordenadas de píxel para más detalles. Tenga en cuenta que la mayoría de los métodos de interpolación tienen Filtros de redimensionado interpolados equivalentes. Pero el uso de la ventana gráfica y las coordenadas de píxel elimina los efectos de borde que se muestran en los anteriores Degradados redimensionados, causados por la ampliación extrema de la imagen muy pequeña.
El ajuste de Interpolación de malla, sin embargo, no está disponible como Filtro de redimensionado. Es una interpolación bidimensional especial que divide el área intra-píxel en dos triángulos planos lineales, articulados a lo largo de la diagonal que conecta las esquinas con la mínima diferencia de color. Así, al hacer que dos colores sean el mismo color y usar "-interpolate mesh", puede generar un degradado 2D muy diferente. |

  magick \( xc:red xc:gold +append \) \
          \( xc:gold xc:green +append \) -append \
          -filter point -interpolate mesh \
          -define distort:viewport=100x100 \
          -distort Affine '.5,.5 .5,.5   1.5,1.5 99.5,99.5' \
          gradient_mesh.jpg

Como las dos esquinas amarillas diagonalmente opuestas son iguales, se usó una diagonal de amarillo para unirlas. Con los otros colores mapeados linealmente a esos triángulos. Si los dos colores diagonales no son iguales, puede obtener una división diagonal diferente.

Cree su propio degradado

El Operador FX hágalo usted mismo le permite definir sus propios degradados u otra generación de imágenes, basándose en la posición del píxel actual. Como este operador requiere una imagen con la que trabajar, puede generar sus degradados u otras imágenes para que coincidan con esa imagen. Es decir, ¡no necesita conocer el tamaño de la imagen para generarle un degradado! Por ejemplo, puede generar fácilmente un degradado lineal, dimensionado correctamente para la imagen con la que esté trabajando. |

  magick rose: -channel G -fx 'i/w' -separate   gradient_fx_linear.gif

| Al generar degradados en escala de grises, puede hacer que el operador -fx sea 3 veces más rápido, simplemente pidiéndole que genere solo un canal de color, como el canal 'G' o verde en el ejemplo anterior. Este canal puede luego Separarse para formar la imagen en escala de grises requerida. Esto puede representar un aumento de velocidad muy grande, especialmente al usar una fórmula "[-fx](https://imagemagick.org/command-line-options/#fx)" muy compleja.
---|---
Incluso puede generar algunos degradados no lineales muy elegantes. |

  magick rose: -channel G -fx '(i/w)^4' -separate   gradient_fx_x4.gif

|

  magick rose: -channel G -fx 'cos(pi*(i/w-.5))' \
           -separate   gradient_fx_cos.gif

¿Qué tal un degradado radial lineal circular bidimensional (un cono)? |

  magick -size 100x100 xc: -channel G \
          -fx 'rr=hypot(i/w-.5, j/h-.5); 1-rr*1.42' \
          -separate gradient_fx_radial.gif

| La función "[-fx](https://imagemagick.org/command-line-options/#fx)" 'rr=hypot(xx,yy)' se añadió en IM v6.3.6 para acelerar la expresión muy comúnmente usada 'rr=sqrt(xx*xx+yy*yy)'. También significó que ya no necesitamos hacer asignaciones extra como 'xx=i/w-.5' al crear un degradado radial.
---|---
El valor '1.42' (o sqrt(2)) en lo anterior controla el tamaño general del degradado en relación con las dimensiones de la imagen. De este modo, el radio del degradado (la distancia del negro desde el centro) es la distancia diagonal a la esquina. Incluso puede eliminar el 'sqrt()' (incorporado en la función 'hypot()') de la expresión para crear un degradado esférico más interesante, que puede ser útil para Efectos de sombreado 3D. |

  magick -size 100x100 xc: -channel G \
          -fx 'xx=i/w-.5; yy=j/h-.5; rr=xx*xx+yy*yy; 1-rr*4' \
          -separate gradient_fx_spherical.gif

Observe cómo uso algunas expresiones de asignación para simplificar el cálculo de la distancia desde el centro de la imagen, y luego lo convierto en un degradado. Esta característica se añadió en IM v6.3.0. Usando una función de potencia alta, puede dar a las fotos un efecto de desvanecimiento alrededor de los bordes rectangulares de la imagen. Ajuste el valor de potencia '4' para controlar la cantidad de desvanecimiento. |

  magick -size 100x100 xc: -channel G \
          -fx '(1-(2*i/w-1)^4)*(1-(2*j/h-1)^4)' \
          -separate  gradient_fx_quad2.gif

Aquí hay un degradado angular, generado usando matemáticas directas. |

  magick -size 100x100 xc:  -channel G \
          -fx '.5 - atan2(j-h/2,w/2-i)/pi/2' \
          -separate  gradient_fx_angular.gif

Tenga en cuenta que la función 'atan2(y,x)' devuelve un ángulo en radianes de -PI a +PI (véase su página de manual), por lo que su salida necesita escalarse y trasladarse para encajar correctamente en un rango de color de 0.0 a 1.0. Por eso lo anterior parece mucho más complejo de lo que realmente es. Este último ejemplo puede generarse más rápido Distorsionando un degradado.

Degradados DIY más complejos

AL MARGEN: Esta sección se creó antes de la adición de losPuntos dispersos de color, y tuvo una influencia directa en su creación. Por supuesto, una función FX puede generar degradados de color. Por ejemplo, aquí hay un degradado basado en razones de distancia, usando una expresión FX extremadamente compleja. |

  magick -size 100x100 xc: +size xc:red xc:yellow -colorspace RGB \
          -fx 'ar=hypot( i/w-.8, j/h-.3 )*4;
               br=hypot( i/w-.3, j/h-.7 )*4;
               u[1]*br/(ar+br) + u[2]*ar/(ar+br)' \
          -colorspace RGB gradient_dist_ratio.gif

| El procesamiento de la imagen se realizó en un espacio de color lineal (RGB) para evitar el 'oscurecimiento sRGB' durante la mezcla de colores primarios tan intensos. VéaseProcesamiento de imágenes reales para más detalles.
---|---
Al pasar de dos puntos a tres puntos, la razón de cuánto color aporta cada 'punto de control' es un poco más compleja, y usa una técnica llamada Interpolación por Distancia Inversa Ponderada (IDW). Puede ver más detalles matemáticos sobre esto en Wikipedia, IDW. Aquí hay un ejemplo de distancia inversa para tres puntos. |

  magick -size 100x100 xc: +size xc:red xc:yellow xc:lime -colorspace RGB \
          -fx 'ar=1/max(1, hypot(i-50,j-10)  );
               br=1/max(1, hypot(i-10,j-70)  );
               cr=1/max(1, hypot(i-90,j-90)  );
               ( u[1]*ar + u[2]*br + u[3]*cr )/( ar+br+cr )' \
          -colorspace sRGB gradient_inverse.gif

Y aquí uso una distancia inversa al cuadrado, que es el método más normal usado para una interpolación IDW. Esto también se conoce como el método de interpolación de Shepard. |

  magick -size 100x100 xc: +size xc:red xc:yellow xc:lime -colorspace RGB \
          -fx 'ar=1/max(1,  (i-50)*(i-50)+(j-10)*(j-10)  );
               br=1/max(1,  (i-10)*(i-10)+(j-70)*(j-70)  );
               cr=1/max(1,  (i-90)*(i-90)+(j-90)*(j-90)  );
               ( u[1]*ar + u[2]*br + u[3]*cr )/( ar+br+cr )' \
          -colorspace sRGB gradient_shepards.gif

Tenga en cuenta que la función 'hypot()' no se usó en lo anterior, ya que no hay necesidad de generar una raíz cuadrada de la distancia. Lo anterior ahora se ha implementado usando los métodos de Color disperso '[Inverse](#inverse)' y '[Shepard's](#shepards)'. Como tal, lo anterior ahora puede hacerse de forma mucho más sencilla usando...

  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color  Inverse '50,10 red  10,70 yellow  90,90 lime' \
          -colorspace sRGB  gradient_inverse_alt.gif
  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color  Shepards '50,10 red  10,70 yellow  90,90 lime' \
          -colorspace sRGB  gradient_shepards_alt.gif

El problema de usar tanto la 'Distancia Inversa' como el 'Método de Shepard' (distancia inversa al cuadrado) es que todos los 'puntos de control' tienen un efecto global sobre toda la imagen. Como resultado se obtiene una especie de 'color promedio' subyacente entre los puntos, y especialmente a gran distancia de todos los puntos de control. Esto, a su vez, produce 'manchas' de color en lugar de un degradado suave de color.

Degradados y matices caseros

-- (Los matices son difíciles de manejar)

NOTA AL MARGEN: Este fue una especie de intento fallido de generar un efecto arcoíris interesante. Fue un fracaso, pero aprendí mucho de ese fracaso, que les presento aquí. Lo anterior funciona bien, pero quería intentar hacerlo mejor. Pensé que quizás podría generar un degradado de colores de arcoíris brillante entre los puntos, en lugar de generar manchas que se fusionan en un color promedio. Así que para generar un degradado de matiz, intenté hacer la Interpolación Ponderada por Distancia Inversa en el espacio de color HSB, aunque cambié el amarillo por el azul, para que los colores quedaran más equiespaciados alrededor del matiz, y con suerte proporcionar otra manera de generar una rueda de colores (véase Degradados en otros espacios de color más arriba). |

  magick -size 100x100 xc: +size xc:red xc:blue xc:lime -colorspace HSB \
          -fx 'ar=1/max(1,  (i-50)*(i-50)+(j-10)*(j-10)  );
               br=1/max(1,  (i-10)*(i-10)+(j-70)*(j-70)  );
               cr=1/max(1,  (i-90)*(i-90)+(j-90)*(j-90)  );
               ( u[1]*ar + u[2]*br + u[3]*cr )/( ar+br+cr )' \
          -colorspace sRGB   gradient_shepards_HSB.gif

Como puede ver, todos los colores son agradables y brillantes, ya que solo estamos generando un degradado de matiz. Sin embargo, también se ve muy extraño, lo cual es causado por la naturaleza 'cíclica' del canal de color 'Matiz'. Como consecuencia, el área entre el azul y el rojo recorre el camino largo a través de un matiz verde, en lugar del camino 'modular' más corto a través de un matiz púrpura. Tras mucha investigación finalmente descubrí cómo hacer la matemática modular necesaria para hacer lo anterior correctamente usando una Media Circular para el promedio ponderado de distancias. Esto implica convertir el Matiz, como ángulo polar, en coordenadas rectangulares X e Y. Eso permite realizar matemática lineal, permitiéndonos efectuar una ponderación lineal de los valores, apropiadamente. El resultado se convierte luego de nuevo en un Matiz angular. |

  magick -size 100x100 xc: +size xc:red xc:blue xc:lime \
          -colorspace HSB -channel R \
          -fx 'aa=u[1]*2*pi; ba=u[2]*2*pi; ca=u[3]*2*pi;
               ar=1/max(1, hypot(i-50,j-10) );
               br=1/max(1, hypot(i-10,j-70) );
               cr=1/max(1, hypot(i-90,j-90) );
               nr=ar+br+cr;
               mod(atan2( ( sin(aa)*ar + sin(ba)*br + sin(ca)*cr )/nr,
                         ( cos(aa)*ar + cos(ba)*br + cos(ca)*cr )/nr
                       )/(2*pi)+1, 1)' \
          -separate -background white -combine +channel \
          -set colorspace HSB -colorspace sRGB  gradient_circular_mean_hue.gif

NOTA: Lo anterior solo realizó sus operaciones sobre el canal de matiz únicamente. Para una imagen real, todavía necesitaríamos operar (como es normal) sobre los canales de saturación y brillo. Como puede ver, ahora obtenemos un degradado correcto entre el rojo y el azul, aunque el método, cuando se aplica a colores primarios que tienen una alta separación angular, tiende a generar cambios de degradado muy bruscos en el medio. Es decir, si bien el resultado es correcto, la variación angular del matiz no es lineal para cambios de matiz muy grandes. Funcionaría bien para promediar muchos matices cercanos, pero no para estos primarios muy separados. Incluso cambié a usar una 'Ponderación Inversa' más fuerte en lugar del método más habitual 'Inverso al Cuadrado' o de 'Shepard' (véase más arriba) y, aunque mejoró las cosas, los cambios de matiz seguían comprimiéndose en el centro debido a los efectos no lineales. Como los colores de entrada son constantes, preconvertirlos en coordenadas matiz-x y matiz-y, hacer la ponderación de Shepard sobre esos canales y luego volver a convertir haría en realidad el proceso aún más rápido. Es decir, convertir los colores de un espacio de color HSB a un espacio de color Hx,Hy,S,B, para aplicar la técnica. Si esto se hace, entonces el punto central e incluso el degradado entre los puntos se sombrearía hacia el blanco (el punto central de un espacio de color HSB). Si esto se realizara en el espacio de color HSL, esa área se sombrearía hacia un gris de tono medio.
Esta conversión de un Matiz polar a coordenadas X-Y sería en cierto modo similar a simplemente hacer los cálculos en un espacio RGB no polar, que muestra esos mismos efectos de sombreado hacia el gris (véase los ejemplos anteriores). Así que si al usar una Media Circular estamos de hecho simplemente convirtiendo un espacio de color HSB en una variante RGB muy distorsionada, ¿por qué no hacer directamente la tarea en un espacio de color RGB lineal, y saturar los colores, para generar el matiz!

  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color  Inverse '50,10 red  10,70 blue  90,90 lime' \
           -colorspace sRGB gradient_inverse_RGB.png
  magick gradient_inverse_RGB.png -colorspace HSB \
          -channel GB -evaluate set 100% +channel \
          -colorspace sRGB gradient_inverse_RGB_Hue.gif

| El procesamiento de imagen se realizó en un espacio de color lineal (RGB) para evitar el 'oscurecimiento sRGB' durante la mezcla de colores primarios tan intensos. VéaseProcesamiento de imágenes reales para más detalles.
---|---
Como puede ver, obtenemos prácticamente exactamente el mismo resultado que antes, pero con toda la compleja 'matemática modular' eliminada. Sin embargo, sigo sin estar más cerca de conseguir una distribución más lineal de matices entre los puntos iniciales de color. La moraleja de todo esto es que trabajar con matices es difícil, no solo debido a la 'discontinuidad del rojo', sino también por los efectos no lineales que ocurren cuando los colores están muy separados. Y al final el resultado fue el mismo que si hubiera hecho la tarea directamente en espacio RGB lineal y saturando los colores. En esencia, si bien los espacios de color HSB y HSL son divertidos, no son espacios de color lineales, realistas ni prácticos con los que trabajar. Esto es probablemente también por lo que muy pocas operaciones trabajan realmente con el matiz directamente.

Generación del degradado perfecto (matemáticamente)

Generar un degradado matemático perfecto, como para Transformadas de Fourier (que es cíclica), Mapeo de imágenes, o incluso Matemática de degradados; requiere degradados especiales que son distintos de los degradados que hemos visto hasta ahora. ¿Qué quiero decir con esto? Bueno, aquí hay una pequeña imagen "gradient:" de 1x5 píxeles, que he Escalado para que pueda ver los colores de los píxeles individuales. |

  magick -size 1x5 gradient:  -scale 2000% gradient.png

Esta imagen crea un degradado que va de un color 'blanco' exacto a lo largo de la fila superior, a un color 'negro' exacto a lo largo de la fila más inferior. Es un degradado 'idealizado', y normalmente exactamente lo que un usuario quiere, ya que de hecho contiene los colores reales que el usuario especificó. Sin embargo, aunque esto es lo que un usuario espera, no es un degradado matemáticamente correcto. Como se discutió en Coordenadas de imagen frente a coordenadas de píxel, los píxeles en realidad tienen un área, y como tal el píxel blanco en la parte superior de la imagen representa el centro de ese píxel, mientras que el negro representa el centro del píxel más inferior. Es decir, no el borde de la imagen sino a 1/2 píxel del borde. Matemáticamente las imágenes comienzan en el borde. Por tanto, para generar un degradado matemático perfecto, necesita especificar las ubicaciones de color en el borde de la imagen, en coordenadas de píxel. Como tal, en coordenadas de imagen, las posiciones están desplazadas 1/2 píxel, y el tamaño de la imagen es exactamente el número de píxeles de la imagen (una distancia), en lugar de una ubicación que es 1 píxel menor que el tamaño de la imagen. Una manera de generar un degradado matemáticamente perfecto es usar Color disperso baricéntrico (visto en detalle en la siguiente sección) para generar un degradado perfecto de borde a borde... |

  magick -size 1x5 xc: \
          -sparse-color Barycentric '0,-0.5 white  0,%[fx:h-.5] black' \
          -scale 2000%  gradient_math.png

Observe que las coordenadas usadas van de -0.5 a la altura de la imagen menos 0.5, esas son las coordenadas de píxel de los bordes reales de la imagen. Y si mirara de cerca los resultados, encontraría que los píxeles superior e inferior no son de color blanco ni negro. El píxel es del color del degradado en el centro del píxel. Como este degradado es matemáticamente correcto, este degradado se 'embaldosará' correctamente cuando se use en situaciones especiales de 'embaldosado' o 'cíclicas'. La imagen de degradado anterior no se 'embaldosará' correctamente. Obtiene un píxel blanco puro, junto a un píxel negro puro, de modo que se genera un hueco de un píxel o 'disyunción' en el ciclo matemático, en situaciones donde el blanco puro y el negro puro normalmente se consideran valores equivalentes. Una manera más sencilla es generar una imagen "[gradient:](#gradient)" que sea un píxel más larga, y recortar un píxel de cualquiera de los extremos (según la configuración actual de "[-gravity](https://imagemagick.org/command-line-options/#gravity)"). Por ejemplo, aquí se recortó el píxel blanco superior, ya que tener un píxel negro (o valor cero) suele ser más deseable en el resultado final. |

  magick -size 1x6 gradient: -chop 0x1 -scale 2000%  gradient_chopped.png

La imagen de degradado resultante puede entonces Rotarse según sea necesario, para generar la imagen requerida para el procesamiento posterior. Sin embargo, aunque este degradado 'ciclará' correctamente, la posición real del color no es exactamente correcta. Pero en muchos casos esto es suficientemente bueno. Si necesita un 'degradado perfecto' le recomiendo que use un degradado de color disperso. En resumen... Un poco de reflexión sobre exactamente lo que quiere de su degradado puede marcar una gran diferencia en la precisión de sus resultados finales. Pero si no importa, entonces no se preocupe por ello, use lo que sea más simple para la tarea en cuestión.

Puntos dispersos de color

El operador "[-sparse-color](https://imagemagick.org/command-line-options/#sparse-color) " se agregó en IM v6.4.3-0 y toma una imagen y establece el color dado en cada una de las coordenadas de punto flotante 'x,y' dadas. Es decir, de la forma...

-sparse-color {method}  'x,y color   x,y color   x,y color ...'

El resto de los píxeles (limitados según la configuración de "[-channel](https://imagemagick.org/command-line-options/#channel)") se mapearán entonces según su relación con estos puntos aislados de color, de modo que se suavicen los colores entre esos puntos. El method define cuál será esa relación. Naturalmente hay muchas maneras de definir cuál debería ser el color intermedio, y el método que elija realmente depende de lo que esté intentando lograr. También puede clasificarse de hecho como una versión completamente libre de la interpolación bidimensional (véase Interpolación, Wikipedia). La ampliación de imagen, o Redimensionar es en realidad un subconjunto especializado de esto, pero uno donde se comienza con una cuadrícula fija completa de píxeles a ampliar. Lamentablemente, pocos de los Filtros de redimensionado o Métodos de interpolación que están específicamente diseñados para tratar con una cuadrícula de puntos, se traducirán directamente a un conjunto libre de puntos de color separados de forma dispersa. Es decir, digamos que el redimensionado que involucra una cuadrícula incompleta simplemente no funciona. Esto también está relacionado con los métodos de los "Sistemas de Información Geográfica (GIS)" donde los paisajes se miden usando puntos de altura separados de forma dispersa (que raramente están en una cuadrícula estricta), determinándose el resto del paisaje a partir de esos puntos aislados. En una situación similar, la meteorología a menudo tiene puntos aislados de presión y temperatura del aire, que luego necesitan ser interpolados. Normalmente, tras la interpolación, los mapas se procesan más para generar 'isolíneas' que muestran puntos de igual valor (altura, presión, temperatura), produciendo los diversos mapas meteorológicos con los que casi todos están familiarizados. En este caso, pensaría en la imagen generada como un simple 'mapa de altura' en escala de grises de los datos de entrada, o quizás incluso de las tres variables simultáneamente, cada una en un 'canal' de imagen separado.

Baricéntrico (degradado triangular)

El método "Barycentric" mapeará tres y solo tres puntos en un triángulo lineal de color. Los colores fuera de este triángulo continúan como antes. He marcado los puntos de entrada con un pequeño círculo, de modo que los colores que ve son todos los valores interpolados que fueron generados por el Operador de color disperso. |

  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color  Barycentric '30,10 red   10,80 blue   90,90 lime' \
          -colorspace sRGB  -fill white -stroke black \
          -draw 'circle 30,10 30,12  circle 10,80 10,82  circle 90,90 90,92' \
          sparse_barycentric.png

| El procesamiento de imagen se realizó en un espacio de color lineal (RGB) para evitar el 'oscurecimiento sRGB' durante la mezcla de colores primarios tan intensos. VéaseProcesamiento de imágenes reales para más detalles.
---|---
Si se dan cuatro o más puntos se realizará un 'mejor ajuste', sobre todos los puntos dados, y como resultado los puntos reales pueden no obtener el color exacto especificado para esos puntos. Sin embargo, tenga en cuenta que el degradado no simplemente 'se detiene' sino que continúa cambiando más allá de esos puntos. Tradicionalmente un degradado baricéntrico estará limitado al interior del triángulo envolvente de los puntos usados para generarlo. Por ejemplo.. |

  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color Barycentric '30,10 red   10,80 blue   90,90 lime' \
          -colorspace sRGB  -fill white -stroke black \
          \( -size 100x100 xc:black -draw 'polygon 30,10  10,80  90,90' \) \
          -alpha off -compose CopyOpacity -composite \
          -draw 'circle 30,10 30,12  circle 10,80 10,82  circle 90,90 90,92' \
          sparse_bary_triangle.png

|

  magick -size 100x100 xc:none -draw "polygon 30,10  10,80  90,90" \
          -colorspace RGB -channel rgb \
          -sparse-color Barycentric '30,10 red   10,80 blue   90,90 lime' \
          -colorspace sRGB  sparse_bary_triangle_2.png

| Las máscaras triangulares usadas arriba son 1/2 píxel demasiado grandes debido a la manera en que draw dibuja una línea extra alrededor de sus formas. VéaseLímites de relleno de Draw para detalles. Esto podría ser un problema al generar una malla triangular de degradados.
---|---
El método 'barycentric' es en realidad un mapeo de una ecuación afín lineal a cada uno de los tres canales de color por separado. Como tal, si separo cada uno de los canales de color del ejemplo anterior de tres puntos, obtiene tres simples degradados lineales en cada canal de color.

  magick sparse_barycentric.png -separate sparse_bary_%d.gif

Es solo debido al uso de colores primarios que los degradados anteriores se mapearon todos paralelos a uno de los bordes del triángulo. Es decir, no es lo típico. Pero siempre obtendrá un simple degradado lineal en cada canal separado de la imagen, y un plano de valores plano en el espacio de color 3D.

Baricéntrico y degradados de dos colores

Este efecto paralelo del degradado baricéntrico triangular es en realidad muy útil. Si dos de los puntos se establecen en el mismo color, entonces esos puntos definirán el 'ángulo' del degradado entre ellos y el otro punto coloreado. Por ejemplo, al hacer dos de los puntos 'red' el degradado se hará paralelo a los dos puntos 'red'... |

  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color  Barycentric '30,10 red   10,80 red   90,90 lime' \
          -colorspace sRGB  -fill white -stroke black \
          -draw 'circle 30,10 30,12  circle 10,80 10,82  circle 90,90 90,92' \
          sparse_bary_gradient.png

Aquí está el mismo ejemplo pero con uno de los puntos de control de ángulo movido para mostrar cómo establece el ángulo del degradado. |

  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color  Barycentric '50,70 red   10,80 red   90,90 lime' \
          -colorspace sRGB  -fill white -stroke black \
          -draw 'circle 50,70 50,72  circle 10,80 10,82  circle 90,90 90,92' \
          sparse_bary_gradient_2.png

Degradados diagonales

Esto proporciona una manera simple de generar cualquier degradado diagonal lineal usando solo dos colores. Por ejemplo, aquí hay una manera particularmente agradable de crear un degradado diagonal, yendo de una esquina a otra esquina, para una imagen de entrada de CUALQUIER tamaño.

  magick -size 600x60 xc: -colorspace RGB \
          -sparse-color barycentric '0,0 skyblue  -%w,%h skyblue  %w,%h black' \
          -colorspace sRGB diagonal_gradient.jpg

Y para alinear con las otras dos esquinas...

  magick -size 600x60 xc: -colorspace RGB \
          -sparse-color barycentric '0,%h black  -%w,0 black  %w,0 skyblue' \
          -colorspace sRGB diagonal_gradient_2.jpg

Estos 'degradados diagonales' producen un degradado de aspecto natural incluso con imágenes largas como la anterior. Estudie las ubicaciones de los tres puntos de color, especialmente los dos puntos de igual color que definen el ángulo del degradado entre las dos esquinas. Observe que en ambos casos uno de esos puntos ni siquiera está ubicado dentro de la propia imagen. Observe también el uso de Escapes de porcentaje para hacer que las posiciones se ajusten automáticamente al tamaño de las imágenes sobre las que se dibuja el degradado.

Degradados de dos puntos

Si solo se dan dos puntos de color, IM generará el tercer punto por usted, de modo que el ángulo sea perpendicular entre los dos puntos originales. El resultado es un simple degradado lineal sobre el cual tiene mucho control. |

  magick -size 100x100 xc:  -colorspace RGB \
          -sparse-color  Barycentric '30,10 red  90,90 lime' \
          -colorspace sRGB  -fill white -stroke black \
          -draw 'circle 30,10 30,12  circle 90,90 90,92' \
          sparse_bary_two_point.png

Sin embargo, los degradados de dos puntos no funcionan muy bien cuando se aplican a las esquinas de imágenes muy 'anchas' o 'altas' (alta relación de aspecto). Básicamente el degradado no está alineado diagonalmente, a diferencia de los degradados de tres puntos anteriores. Está inclinado, pero no lo suficiente como para hacerlo 'interesante'.

  magick -size 600x60 xc: -colorspace RGB \
          -sparse-color barycentric '0,0 skyblue  %w,%h black' \
          -colorspace sRGB  sparse_bary_two_point_wide.jpg

Bilineal (degradado de 4 puntos)

Este método ajusta una ecuación a 4 puntos, sobre los tres canales de color, para producir un degradado de color uniforme entre los puntos, y más allá. |

  magick -size 100x100 xc:  -colorspace RGB \
    -sparse-color Bilinear '30,10 red  10,80 blue  70,60 lime  80,20 yellow' \
    -colorspace sRGB  -fill white -stroke black \
    -draw 'circle 30,10 30,12  circle 10,80 10,82' \
    -draw 'circle 70,60 70,62  circle 80,20 80,22' \
    sparse_bilinear.png

Puede ver este 'ajuste de 4 puntos' tomando la imagen anterior y separando los degradados de canal de color individuales.

  magick sparse_bilinear.png -separate sparse_bilin_%d.gif

Observe cómo la ecuación produce curvas (curvas cuadráticas en realidad). Sin embargo, si los 4 puntos forman líneas paralelas, el degradado generado se volverá lineal. Este método es en realidad equivalente al método de Interpolación Bilineal (véase Degradados de búsqueda interpolados más abajo), cuando los 4 puntos están alineados a una cuadrícula ortogonal (rectangular). Si se dan menos de 4 puntos, la función anterior será reemplazada por un método '[Barycentric](#barycentric)' de 3 puntos (véase más arriba). Si se dan más de cuatro puntos, hará un mejor ajuste de todos los puntos, y por tanto puede no coincidir realmente con el color dado en el punto especificado. Esto no es recomendable.

Voronoi (color más cercano)

El método "Voronoi" simplemente mapea cada píxel al punto de color más cercano que haya proporcionado. Esto básicamente divide la imagen en un conjunto de 'celdas' poligonales alrededor de cada punto. Por ejemplo.. |

  magick -size 100x100 xc:  -colorspace RGB \
    -sparse-color  Voronoi '30,10 red  10,80 blue  70,60 lime  80,20 yellow' \
    -colorspace sRGB  -fill white -stroke black \
    -draw 'circle 30,10 30,12  circle 10,80 10,82' \
    -draw 'circle 70,60 70,62  circle 80,20 80,22' \
    sparse_voronoi.gif

Como puede ver, no se hace ningún intento de proporcionar suavizado de bordes (anti-aliasing) de las 'celdas' coloreadas alrededor de cada punto. El borde de cada celda cae exactamente a medio camino entre los vecinos más cercanos de cada punto. Esto puede usarse, por ejemplo, para generar máscaras que recorten la imagen de varias maneras. Simplemente asigne un punto como blanco y todos los demás como negro para extraer una sola 'celda' de la imagen. Si quiere suavizar (anti-alias) el resultado puede usar alguna forma de Supermuestreo para suavizar la imagen. Por ejemplo, genere una imagen 4 veces más grande y "[-scale](https://imagemagick.org/command-line-options/#scale)" para reducirla al tamaño deseado. |

  magick -size 400x400 xc: -colorspace RGB \
    -sparse-color Voronoi '120,40 red 40,320 blue 270,240 lime 320,80 yellow'
\
    -scale 25%  -colorspace sRGB -fill white -stroke black \
    -draw 'circle 30,10 30,12  circle 10,80 10,82' \
    -draw 'circle 70,60 70,62  circle 80,20 80,22' \
    sparse_voronoi_ssampled.png

| Todo el procesamiento de imagen se realizó en un espacio de color lineal (RGB) para evitar el 'oscurecimiento sRGB' durante la mezcla de colores primarios tan intensos. VéaseProcesamiento de imágenes reales para más detalles.
---|---
La manera más sencilla (aunque no muy agradable) es simplemente desenfocar la imagen muy ligeramente... |

  magick -size 100x100 xc: -colorspace RGB \
    -sparse-color Voronoi '30,10 red  10,80 blue  70,60 lime  80,20 yellow' \
    -blur 1x0.7  -colorspace sRGB  -fill white -stroke black \
    -draw 'circle 30,10 30,12  circle 10,80 10,82' \
    -draw 'circle 70,60 70,62  circle 80,20 80,22' \
    sparse_voronoi_smoothed.png

Al desenfocar la imagen generada en gran medida puede establecer algunos degradados no lineales entre las 'celdas' que se generaron. |

  magick -size 100x100 xc:  -colorspace RGB \
    -sparse-color  Voronoi '30,10 red  10,80 blue  70,60 lime  80,20 yellow' \
    -blur 0x15  -colorspace sRGB  -fill white -stroke black \
    -draw 'circle 30,10 30,12  circle 10,80 10,82' \
    -draw 'circle 70,60 70,62  circle 80,20 80,22' \
    sparse_voronoi_blur.png

Cuanto mayor sea el "[-blur](https://imagemagick.org/command-line-options/#blur)", mayor será el degradado entre las diversas 'celdas'. Sin embargo, tenga en cuenta que esto puede no preservar las celdas coloreadas pequeñas, ni asegurar que el punto original permanezca con el color que se le dio, si está cerca del borde (y de otro punto) de un color diferente. Usando una técnica especial de 'desenfoque lineal', desarrollada por Fred Weinhaus, puede producir un degradado lineal de ancho fijo entre las celdas. |

  magick -size 100x100 xc: -colorspace RGB \
    -sparse-color  Voronoi '30,10 red  10,80 blue  70,60 lime  80,20 yellow' \
    -blur 10x65535  -colorspace sRGB  -fill white -stroke black \
    -draw 'circle 30,10 30,12  circle 10,80 10,82' \
    -draw 'circle 70,60 70,62  circle 80,20 80,22' \
    sparse_voronoi_gradient.png

La salida sin desenfocar también podría pasarse a varias técnicas de Detección de bordes para generar varios bordes delimitados. Puede reasignar la imagen mediante un Convertidor de ráster a vector para generar líneas vectoriales. Sin embargo, encontré que la configuración predeterminada de 'autotrace' puede necesitar ajustarse con "-corner-threshold 120" para que detecte mejor las esquinas.

Shepards (manchas de color)

El método "Shepards" usa una razón de los inversos de los cuadrados de las distancias a cada uno de los puntos dados para determinar el color del lienzo en cada punto. Vea Degradados DIY más complejos más arriba para ejemplos de cómo se realizan las matemáticas. Es un poco como tener focos de color en cada punto que interactúan entre sí, a medida que la luz se difunde hasta un promedio uniforme de todos los colores dados en el infinito. |

  magick -size 100x100 xc: -colorspace RGB \
    -sparse-color  Shepards '30,10 red  10,80 blue  70,60 lime  80,20 yellow'
\
    -colorspace sRGB  -fill white -stroke black \
    -draw 'circle 30,10 30,12  circle 10,80 10,82' \
    -draw 'circle 70,60 70,62  circle 80,20 80,22' \
    sparse_shepards.png

| El procesamiento de la imagen se realizó en un espacio de color lineal (RGB) para evitar el 'oscurecimiento sRGB' durante la mezcla de colores primarios tan intensos. VeaProcesamiento de imágenes reales para más detalles.
---|---
Al rodear un área específica con un color similar puede generar una meseta de ese color concreto, aunque los límites entre los puntos de borde pueden 'filtrarse', y el centro de la 'meseta' puede hundirse formando un cuenco poco profundo (según la distancia a otros puntos de color). Este método es también el que se usa para generar un campo de desplazamiento, como el que se utiliza en Distorsiones de imagen Shepards. En ese caso, lo que se mapea son los vectores de desplazamiento X e Y en lugar de los valores de color R,G,B.

Inverse (puntos nítidos de color)

El método "Inverse" es prácticamente idéntico a "Shepards", salvo que usa una ponderación de distancia inversa más directa de los puntos dados. Vea Degradados DIY más complejos más arriba para ejemplos de cómo se realizan las matemáticas. Esto fue una adición mucho más tardía a la versión 6.6.9-7 de ImageMagick. Por ejemplo... |

  magick -size 100x100 xc: -colorspace RGB \
    -sparse-color  Inverse '30,10 red  10,80 blue  70,60 lime  80,20 yellow' \
    -colorspace sRGB  -fill white -stroke black \
    -draw 'circle 30,10 30,12  circle 10,80 10,82' \
    -draw 'circle 70,60 70,62  circle 80,20 80,22' \
    sparse_inverse.png

Como puede ver, genera puntos nítidos de color que rápidamente se funden con el 'color promedio' del fondo. En comparación con el método Shepards, que genera manchas redondeadas, con un color 'plano' alrededor de los puntos de color. Sin embargo, funciona mejor al generar degradados lineales donde todos los puntos de control forman una línea. Es decir, para generar degradados unidimensionales a lo largo de una línea específica en la imagen. No obstante, queda un punto más por señalar. La rapidez con que estos puntos de color caen a un nivel cercano al 'promedio' se controla por la cercanía entre ellos. Coloque dos fuentes puntuales cerca una de otra y caen rápidamente; cuanto más separadas estén, mayor será la influencia de los colores individuales en el resultado.

  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color Inverse '45,45 red  55,55 lime' \
          -colorspace sRGB  -fill white -stroke black \
          -draw 'circle 45,45 45,47  circle 55,55 55,57' \
          sparse_inverse_near.png
  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color Inverse '30,30 red  70,70 lime' \
          -colorspace sRGB  -fill white -stroke black \
          -draw 'circle 30,30 30,32  circle 70,70 70,72' \
          sparse_inverse_far.png

Además, si 'duplica' un punto específico (exactamente sobre, o muy cerca uno de otro) con el mismo color o uno similar, hará que ese punto de color sea el doble de intenso. |

  magick -size 100x100 xc: -colorspace RGB \
          -sparse-color Inverse '30,30 red  75,65 lime  65,75 lime' \
          -colorspace sRGB -fill white -stroke black \
          -draw 'circle 30,30 30,32  circle 75,65 75,67  circle 65,75 65,77 '
\
          sparse_inverse_stronger.png

¡Estos efectos también se aplican al método '[Shepards](#shepards)'!

Factor de potencia de Shepards

Tanto el método de color disperso Shepards como el Inverse son en realidad el mismo, pero con diferentes 'niveles de potencia' aplicados a las ponderaciones de distancia inversa. (2.0 y 1.0 respectivamente). A partir de IM v6.8.0-10, puede establecer este nivel de potencia usando un define operacional, 'shepards:power', que será utilizado por el método '[Shepards](#shepards)'. Por ejemplo

  magick -size 100x100 xc: -colorspace RGB -define shepards:power=0.5 \
     -sparse-color Shepards '30,10 red  10,80 blue  70,60 lime  80,20 yellow'
\
     -colorspace sRGB -fill white -stroke black \
     -draw 'circle 30,10 30,12  circle 10,80 10,82' \
     -draw 'circle 70,60 70,62  circle 80,20 80,22' \
     sparse_shepards_pow0.5.png
  magick -size 100x100 xc: -colorspace RGB -define shepards:power=1 \
     -sparse-color Shepards '30,10 red  10,80 blue  70,60 lime  80,20 yellow'
\
     -colorspace sRGB -fill white -stroke black \
     -draw 'circle 30,10 30,12  circle 10,80 10,82' \
     -draw 'circle 70,60 70,62  circle 80,20 80,22' \
     sparse_shepards_pow1.png
  magick -size 100x100 xc: -colorspace RGB -define shepards:power=2 \
     -sparse-color Shepards '30,10 red  10,80 blue  70,60 lime  80,20 yellow'
\
     -colorspace sRGB -fill white -stroke black \
     -draw 'circle 30,10 30,12  circle 10,80 10,82' \
     -draw 'circle 70,60 70,62  circle 80,20 80,22' \
     sparse_shepards_pow2.png
  magick -size 100x100 xc: -colorspace RGB -define shepards:power=3 \
     -sparse-color Shepards '30,10 red  10,80 blue  70,60 lime  80,20 yellow'
\
     -colorspace sRGB -fill white -stroke black \
     -draw 'circle 30,10 30,12  circle 10,80 10,82' \
     -draw 'circle 70,60 70,62  circle 80,20 80,22' \
     sparse_shepards_pow3.png
magick -size 100x100 xc: -colorspace RGB -define shepards:power=8 \
     -sparse-color Shepards '30,10 red  10,80 blue  70,60 lime  80,20 yellow'
\
     -colorspace sRGB -fill white -stroke black \
     -draw 'circle 30,10 30,12  circle 10,80 10,82' \
     -draw 'circle 70,60 70,62  circle 80,20 80,22' \
     sparse_shepards_pow8.png

potencia 0.5 |
potencia 1.0
(inverse) |
potencia 2.0
(shepards) |
potencia 3.0 |
potencia 8.0
---|---|---|---|---

Como puede ver, las 'manchas de color' se expanden desde puntos muy nítidos, a manchas redondeadas, y hasta amplias áreas de color. A niveles de potencia muy altos, acabará reproduciendo el mismo patrón que un método de color disperso Voronoi. Este -define no solo afecta a Shepards Sparse Color, sino que también tendrá efectos similares en el método de distorsión Shepards, que se basa en mapas de desplazamiento calculados generados por el método de color disperso. Sin embargo, no afecta al método de color disperso Inverse, que siempre usa un nivel de potencia de 1.0.

Resumen de los métodos de color disperso

Aquí hay una repetición de las diversas imágenes "[-sparse-color](https://imagemagick.org/command-line-options/#sparse-color)" de 4 puntos, para comparar.
Voronoi |
Voronoi (difuminado) |
Shepards |
Inverse |
Bilinear
---|---|---|---|---
Y aquí hay un resumen de los diversos métodos de 3 puntos.
Voronoi |
Voronoi (difuminado) |
Shepards |
Inverse |
Barycentric
---|---|---|---|---
Por ahora, solo los métodos '[Voronoi](#voronoi)', '[Shepards](#shepards)' e '[Inverse](#inverse)' son adecuados para más de cuatro puntos. Se planean más métodos "[-sparse-color](https://imagemagick.org/command-line-options/#sparse-color)". Si tiene alguna idea, envíemela por correo.

Canal y color disperso

El operador "[-sparse-color](https://imagemagick.org/command-line-options/#sparse-color)" se ve afectado por la opción "[-channel](https://imagemagick.org/command-line-options/#channel)", lo que significa que puede usar esa opción para limitar sus efectos a un solo canal, o ampliarlos al canal de transparencia. También puede usar la opción "[-channel](https://imagemagick.org/command-line-options/#channel)" para acelerar el procesamiento de imágenes en escala de grises operando solo sobre un canal, y luego "[-separate](https://imagemagick.org/command-line-options/#separate)" ese canal (vea Manejo de canales para más detalle). Por ejemplo.. |

  magick -size 100x100 xc: -channel G -sparse-color Shepards \
              '30,10 gray70  10,80 black  70,60 white  80,20 gray(33.3333%)' \
          -separate +channel    -fill white -stroke black \
          -draw 'circle 30,10 30,12  circle 10,80 10,82' \
          -draw 'circle 70,60 70,62  circle 80,20 80,22' \
          sparse_shepards_gray.gif

A partir de IM v6.6.8-5 se preservan los canales no modificados, de modo que ahora puede usar Sparse Color con la opción "[-channel](https://imagemagick.org/command-line-options/#channel)" para añadir un degradado transparente a cualquier imagen, de forma rápida y sencilla. Por ejemplo, aquí añado un degradado diagonal transparente, alineado de modo que el 50% de transparencia quede a lo largo de la diagonal de la imagen integrada "rose:. |

  magick rose: -alpha set -channel A \
          -sparse-color Barycentric \
                 '0,0 opaque   %w,-%h opaque    %w,%h transparent' \
          rose_alpha_gradient.png

| El color 'Opaque' es simplemente otro nombre para 'Black'. Básicamente se usa cuando realmente solo le interesa especificar un color totalmente opaco, pero el color en sí no importa. De forma similar con el color 'Transparent'. Igualmente podría haber usado 'White' y 'None' respectivamente.
---|---
| Antes de IM v6.6.8-5, cualquier canal no seleccionado por la opción "[-channel](https://imagemagick.org/command-line-options/#channel)" se restablecía a valores cero (negro). Esto limitaba gravemente su utilidad efectiva
---|---
Sparse Color también acepta valores de punto flotante normalizados en lugar de un nombre de color. Exactamente cuántos valores se deben proporcionar para reemplazar el nombre de color depende de la opción "[-channel](https://imagemagick.org/command-line-options/#channel)" actual, y de si ese canal está 'activo' en la imagen que se procesa. Lo más fácil es limitar el procesamiento a un solo canal. Note además que al usar números en bruto, en lugar de nombres de color, los valores de transparencia son valores 'matte' (0=opaco) y no valores 'alpha' (1=opaco) (para IMv7). Así, en lo anterior podría haber usado números en lugar de nombres de color...

  -channel A  -sparse-color Bilinear '0,0 1.0   -%w,%h 1.0    %w,%h 0.0'

Esto puede ser más fácil de manejar en scripts programados, y en API, que pueden no tener acceso al traductor de 'nombres de color'.

Color disperso como operador de relleno

Una de las razones originales para crear el operador de color disperso fue para poder dar una imagen que contiene solo un pequeño número de puntos fijos de color, y a partir de esto 'rellenar' el resto de los colores no definidos. Por ejemplo, aquí he dibujado un pequeño número de píxeles. La opción "[+antialias](https://imagemagick.org/command-line-options/#antialias)" se desactivó específicamente para que no se dibujen colores semitransparentes o mezclados, de modo que la imagen solo contiene los cuatro colores exactos especificados y ningún otro. |

  magick -size 100x100 xc:none +antialias -fill none -strokewidth 0.5 \
          -stroke Gold        -draw "path 'M 20,70  A 1,1 0 0,1 80,50'" \
          -stroke DodgerBlue  -draw "line 30,10  50,80" \
          -stroke Red         -draw "circle 80,60  82,60" \
          sparse_source.gif

Ahora podemos extraer los pocos píxeles no transparentes presentes en esta imagen, y luego rellenar todos los demás colores usando el método de color disperso multipunto, '[Shepards](#shepards)'. |

  magick sparse_source.gif sparse-color:- |\
      magick sparse_source.gif -alpha off \
              -sparse-color shepards '@-' sparse_fill.png

El comando "sed" anterior toma el formato de archivo de texto enumerado, elimina la primera línea de cabecera y cualquier línea que contenga transparencia, antes de reformatearlo en una lista de coordenadas de píxeles y colores. Esa lista se 'canaliza' luego al operador de color disperso usando el argumento especial "@-". Sí, lo anterior es muy ingenioso, pero funciona. Al menos para un número muy pequeño de puntos. Sin embargo, cuantos más puntos se proporcionen, más lenta se vuelve la operación. Esto se debe a que Sparse Color está orientado a 'puntos' en su procesamiento, en lugar de estar orientado a imágenes o Morfología. Con el tiempo espero poder proporcionar un conjunto de métodos de 'relleno de huecos' orientados a la morfología, donde simplemente pueda dar la imagen anterior tal cual y que rellene las áreas transparentes automáticamente. Esta técnica de extracción de puntos se puede combinar con el método de morfología EdgeIn para extraer los píxeles alrededor de los bordes de objetos o huecos, de modo que luego pueda 'rellenar' el fondo o los huecos que faltan (como se muestra en Morfología y canales). Por ejemplo...

  magick figure.gif -channel A -morphology EdgeIn Diamond
shape_edge_pixels.gif
  magick shape_edge_pixels.gif txt:- |\
    sed '1d; / 0) /d; s/:.* /,/;' | \
     magick shape_edge_pixels.gif -alpha off \
             -sparse-color shepards '@-' shape_edge_in_lights.png
  magick shape_edge_in_lights.png figure.gif -composite shape_in_lights.png

Note que la imagen resultante es exactamente igual a la entrada, pero con el fondo transparente reemplazado por unos 'colores de borde' difuminados por distancia. Por eso los bordes de la imagen se han vuelto indistintos. Esta imagen se desarrolló específicamente para intentar generar mejores técnicas de 'difuminado de bordes'. Vea Difuminado por desenfoque y Difuminado por distancia para otras técnicas de difuminado.

Color disperso Shepards, una alternativa al desenfoque

Una alternativa a usar "[-sparse-color](https://imagemagick.org/command-line-options/#sparse-color)" es tomar la imagen de píxeles sobre un fondo transparente y aplicarle desenfoque. Luego se descarta la transparencia.

  magick sparse_source.gif   -channel RGBA -blur 0x15 \
          -alpha off  sparse_blur_simple.png

El problema con esto es que los colores originales no se preservan, y además tiene el problema de qué valor exacto de 'sigma ' debería usarse. Tampoco tiene en cuenta lo 'cerca' que está cada color, de modo que dos píxeles de color cercanos (a menos de la distancia 'sigma ') se inundarán mutuamente, y quedarán mezclados por el desenfoque.
Un método mejor es generar múltiples capas de imágenes desenfocadas con valores de 'sigma ' progresivamente menores, y la imagen original sin desenfocar encima.

  for sigma in  64 32 16 8 4 2 1 0;  do
    magick sparse_source.gif -depth 16 \
            -channel RGBA -blur 0x$sigma miff:-
  done |
    magick - -background none -flatten -alpha off sparse_blur_layered.png

Esta técnica de desenfoque por capas equivale al resultado de un método '[Shepards](#shepards)' sobre la misma imagen; aunque no tan exacta, es muy cercana. Sin embargo, es probable que sea mucho más rápida cuando hay muchos píxeles de entrada involucrados, ya que está orientada a imágenes (morfología), en lugar de calcular usando puntos individuales. Otro método de desenfoque por capas es usar Redimensionar para generar una 'pirámide' de imágenes desenfocadas. Esta técnica se detalla en Desenfoques grandes usando Resize. |

  magick sparse_source.gif \
          \( +clone -resize 50% \) \
          \( +clone -resize 50% \) \
          \( +clone -resize 50% \) \
          \( +clone -resize 50% \) \
          \( +clone -resize 50% \) \
          \( +clone -resize 50% \) \
          \( +clone -resize 50% \) \
          -layers RemoveDups -filter Gaussian -resize 100x100\! -reverse \
          -background None -flatten -alpha off    sparse_blur_pyramid.png

Esto funcionará muy rápido con imágenes muy grandes sin necesitar valores grandes de 'sigma ' (y por tanto muy lentos) para cada uno de los pasos de desenfoque. En esencia, está usando una técnica más rápida de redimensionado de imágenes para generar las capas desenfocadas del ejemplo anterior. No es tan exacta, pero generará una buena aproximación del resultado correcto. Sin embargo, funciona mejor para imágenes que son cuadradas, y una potencia de dos en tamaño, o será menos precisa. El operador especial "[-layers](https://imagemagick.org/command-line-options/#layers) RemoveDups" en lo anterior eliminará cualquier imagen extra de 'un solo píxel promedio' que se haya generado, por las múltiples operaciones de 'clone-resize'. Las imágenes se redimensionan luego de vuelta al tamaño original usando un filtro de redimensionado gaussiano (el equivalente a un desenfoque). El orden de las imágenes se invierte luego para colocar la original encima, y las capas más borrosas debajo, antes de aplanarlas juntas como antes. Tiene la ventaja de necesitar leer la imagen solo una vez, haciendo todo el trabajo en un único comando. También funciona muy rápido incluso para imágenes grandes, especialmente porque el redimensionado solo reduce la imagen a la mitad en cada paso, evitando así el lento desenfoque con un sigma muy grande. La única desventaja de este método es que necesitará tener una idea aproximada del tamaño original de la imagen para restaurar las imágenes 'desenfocadas', y para obtener al menos una idea aproximada de cuántos clones redimensionados generar (Log2 de la dimensión más grande, más 1). Sin embargo, excederse con los clones de redimensionado no es un gran golpe al rendimiento, ya que el redimensionado simplemente se convierte en una 'no-op' cuando la imagen de entrada ya se ha reducido a la imagen mínima de 1 píxel. Las capas de 'imagen redimensionada' adicionales e inútiles se manejan luego automáticamente usando "[-layers](https://imagemagick.org/command-line-options/#layers) RemoveDups".El único problema real es la posibilidad de que las imágenes redimensionadas queden 'fuera de sincronía' al manejar una imagen que no es una potencia de dos en tamaño. No se sabe cuán grave es este problema, pero no debería ser demasiado, ya que esas imágenes son también las más desenfocadas. Por supuesto, todavía tiene el problema de 'filtración' del método '[Shepards](#shepards)', así que veamos este problema con más detalle.

El método Shepards 'se filtra'

El método '[Shepards](#shepards)' no tiene ninguna comprensión de los 'límites', y como tal los colores en el lado lejano de alguna 'línea de color' se filtrarán, o 'sangrarán' más allá de esa línea. Eventualmente, a una distancia grande obtendrá un color promedio puro de todos los píxeles. Este no es siempre un resultado deseable (aunque sí es deseable en algunos casos). En este ejemplo, cuanto más se acerca la curva 'Red' a la línea 'White', más se 'filtrará' el color a través de las dos líneas hacia el lado lejano, produciendo un color rosa. |

  magick -size 100x100 xc:none +antialias -fill none -strokewidth 0.5 \
          -stroke Red    -draw "path 'M 26,0  A 55,61 0 0,1 26,100'" \
          -stroke White  -draw "line 50,0  50,100" \
          sparse_lines_near_source.gif

|

  magick sparse_lines_near_source.gif txt:- |\
    sed '1d; / 0) /d; s/:.* /,/;' |\
      magick -size 100x100 xc: -sparse-color shepards '@-' \
              sparse_lines_near.png

Esta filtración de colores es el principal problema al usar el método Shepards para el 'relleno de huecos', especialmente cuando hay múltiples huecos involucrados, ya que los colores asociados a un hueco pueden filtrarse y de hecho lo harán en otro hueco completamente diferente, afectando sus colores. Y viceversa. Es la comprensión de los límites lo que constituye la diferencia entre el método Shepards y otra forma de 'relleno de huecos' de color conocida como 'Difusión de color '. Básicamente, con la 'Difusión de color ', los colores no pueden atravesar una línea de algún otro color definido. Se logra limitando el efecto solo a los colores en 'línea de visión', o a los que se filtran, alrededor del exterior de un borde. Esto requiere usar la distancia a los colores más cercanos para limitar qué colores influyen en un píxel. Un uso importante de la 'Difusión de color ' se presenta en el sitio web de Curvas de difusión. Este no solo hace un uso intensivo de la difusión de color, sino que también incluye información sobre técnicas para generar difusiones muy rápidamente. Espero implementar esto en ImageMagick en algún momento futuro.

Imágenes de plasma

Degradados de plasma

Mientras que los degradados proporcionan un rango suave de colores, otro operador de creación de imágenes "plasma:" proporciona un tipo diferente de degradado. Uno que es idóneo para generar un telón de fondo aleatorio de color para sus imágenes. Antes que nada, debo señalar que "plasma:" es una imagen aleatorizada. Como tal, puede producir y producirá una imagen diferente cada vez que se ejecuta. Por ejemplo, aquí generamos tres imágenes de plasma 'estándar' separadas, y cada imagen es diferente de las demás, aunque se usó el mismo comando para generarlas.

  magick -size 100x100  plasma:  plasma1.jpg
  magick -size 100x100  plasma:  plasma2.jpg
  magick -size 100x100  plasma:  plasma3.jpg

También puede ver que las imágenes de plasma son igualmente un tipo de degradado aleatorizado de colores, y como "gradient:" comenzaron con blanco arriba y negro abajo. Lo que no está bien documentado es que puede especificar el color del degradado de plasma exactamente de la misma forma que para los degradados lineales de arriba.

  magick -size 100x100  plasma:blue              plasma_range1.jpg
  magick -size 100x100  plasma:yellow            plasma_range2.jpg
  magick -size 100x100  plasma:green-yellow      plasma_range3.jpg
  magick -size 100x100  plasma:red-blue          plasma_range4.jpg
  magick -size 100x100  plasma:tomato-steelblue  plasma_range5.jpg

También puede ver que los colores de tonos medios como 'tomato' y 'steelblue' tienden a funcionar mejor que los colores puros como 'red' y 'blue'. Al usar el mismo color dos veces con plasma puede producir un fondo que sea predominantemente ese color, pero con manchas aleatorias de colores cercanos a los de los colores originales.

  magick -size 100x100  plasma:black-black          plasma_black.jpg
  magick -size 100x100  plasma:grey-grey            plasma_grey.jpg
  magick -size 100x100  plasma:white-white          plasma_white.jpg
  magick -size 100x100  plasma:yellow-yellow        plasma_yellow.jpg
  magick -size 100x100  plasma:tomato-tomato        plasma_tomato.jpg
  magick -size 100x100  plasma:steelblue-steelblue  plasma_steelblue.jpg

De nuevo, como puede ver, los colores de tonos medios generarán más variedades de color en la imagen resultante que un color extremo, como negro, blanco o amarillo. El plasma 'grey' de arriba es particularmente agradable, dando un efecto iridiscente tipo 'nácar', básicamente porque el gris tiene total libertad en los colores que "plasma:" generará. Normalizar un plasma gris perfecto al 50% producirá una imagen de plasma multicolor particularmente uniforme, sobre el rango completo de colores, incluyendo blanco y negro. |

  magick -size 100x100  plasma:grey50-grey50 -auto-level plasma_grey_norm.jpg

De forma alternativa, basta con expandir el contraste de los colores para hacerlos más intensos, pero sin llegar a los extremos. |

  magick -size 100x100  plasma:grey50-grey50 \
                       -sigmoidal-contrast 8x50%   plasma_grey_contrast.jpg

Compare esta imagen con las imágenes de 'plasma fractal' de más abajo.

Plasma fractal

El generador de plasma también dispone de un modo fractal especial, que produce efectos muy coloridos. Los colores generados se realzan para producir cambios de color más exagerados.

  magick -size 100x100  plasma:fractal  plasma_fractal1.jpg
  magick -size 100x100  plasma:fractal  plasma_fractal2.jpg
  magick -size 100x100  plasma:fractal  plasma_fractal3.jpg

De hecho, esto es muy similar a las imágenes de plasma de color constante que ya hemos visto y, en realidad, se generan de la misma manera pero con cambios de color más pronunciados.
A menudo encuentro que las imágenes de plasma son un poco 'ruidosas'. Por ello, normalmente se benefician de un poco de suavizado mediante "[-blur](https://imagemagick.org/command-line-options/#blur)". Aquí he suavizado el ruido de la imagen de plasma central de más arriba. |

  magick plasma_fractal2.jpg  -blur 0x2  plasma_smooth.jpg

Puede utilizar "[-paint](https://imagemagick.org/command-line-options/#paint)" para crear manchas aleatorias de color. |

  magick plasma_fractal2.jpg  -blur 0x1 -paint 8  plasma_paint.jpg

O bien hacer los colores más pronunciados y circulares mediante el operador de imagen "[-emboss](https://imagemagick.org/command-line-options/#emboss)", después de usar "[-blur](https://imagemagick.org/command-line-options/#blur)" para eliminar el ruido de bajo nivel. |

  magick plasma_fractal2.jpg  -blur 0x5 -emboss 2 plasma_emboss.jpg

Mediante un "[-blur](https://imagemagick.org/command-line-options/#blur)" seguido de un "[-sharpen](https://imagemagick.org/command-line-options/#sharpen)" se puede producir un patrón de color más pastel que el que produjimos con "[-emboss](https://imagemagick.org/command-line-options/#emboss)". |

  magick plasma_fractal2.jpg  -blur 0x5 -sharpen 0x15 plasma_sharp.jpg

La verdad es que generar un degradado de plasma con remolinos me resulta particularmente agradable como patrón de fondo. |

  magick -size 160x140  plasma:fractal \
          -blur 0x2  -swirl 180  -shave 20x20  plasma_swirl.jpg

Plasma en escala de grises

Ahora bien, el generador de plasma siempre generará color, incluso sobre un color sólido negro puro. Sin embargo, a menudo resulta útil generar un plasma en escala de grises puro. Pues bien, hay dos maneras sencillas de hacerlo. La forma más simple es tomar la imagen de plasma y convertirla a escala de grises. |

  magick -size 100x100 plasma:fractal -blur 0x2 \
          -colorspace Gray   plasma_greyscale.jpg

Otra forma es copiar uno de los canales de color sobre los otros dos, para obtener un efecto más fuerte, de una sola capa. |

  magick -size 100x100 plasma:fractal -blur 0x2 \
          -channel G -separate   plasma_grey_copy.jpg

Una última técnica consiste en usar "[-shade](https://imagemagick.org/command-line-options/#shade)" sobre el plasma. |

  magick -size 100x100 plasma:fractal -blur 0x5 \
          -shade 120x45  -auto-level  plasma_grey_shade.jpg

Probablemente pensaría que obtendría muchos efectos de luz y sombra, pero el plasma en bruto es tan aleatorio que "[-shade](https://imagemagick.org/command-line-options/#shade)" solo parece producir un efecto de 'plasma moteado'. En lugar de utilizar un plasma fractal, con sus cambios de color tan exagerados, puede crear un plasma en escala de grises usando el método de plasma de color constante. Como efecto secundario, este método también le permite controlar el brillo general de la imagen de plasma en escala de grises generada.

  magick -size 100x100 plasma:black-black \
           -blur 0x2 -colorspace Gray plasma_grey0.jpg
  magick -size 100x100 plasma:grey25-grey25 \
           -blur 0x2 -colorspace Gray plasma_grey1.jpg
  magick -size 100x100 plasma:grey50-grey50 \
           -blur 0x2 -colorspace Gray plasma_grey2.jpg
  magick -size 100x100 plasma:grey75-grey75 \
           -blur 0x2 -colorspace Gray plasma_grey3.jpg
  magick -size 100x100 plasma:white-white   \
           -blur 0x2 -colorspace Gray plasma_grey4.jpg

Si esto no es lo bastante intenso, utilice el método de copia de canal para pasar la imagen de plasma a escala de grises.

  magick -size 100x100 plasma:black-black   \
          -blur 0x2  -channel G  -separate   plasma_grey5.jpg
  magick -size 100x100 plasma:grey25-grey25 \
          -blur 0x2  -channel G  -separate   plasma_grey6.jpg
  magick -size 100x100 plasma:grey50-grey50 \
          -blur 0x2  -channel G  -separate   plasma_grey7.jpg
  magick -size 100x100 plasma:grey75-grey75 \
          -blur 0x2  -channel G  -separate   plasma_grey8.jpg
  magick -size 100x100 plasma:white-white   \
          -blur 0x2  -channel G  -separate   plasma_grey9.jpg

Estas imágenes de plasma en escala de grises son muy útiles para un procesamiento posterior, lo que le permite generar otros efectos de imagen. Por ejemplo, consulte la página sobre Imágenes de fondo para ver una enorme cantidad de ejemplos en los que se usó el plasma fractal para producir muchos efectos interesantes.

Sembrar o repetir una imagen de plasma

Recuerde que "plasma:" puede producir áreas de negro casi puro o blanco puro, o cualquier otro color (aunque es poco probable que sea puro). Y aunque es improbable que obtenga una imagen totalmente de un solo color, también es un resultado posible. Así que, cuando obtenga un buen resultado, quizá quiera guardarlo para reutilizarlo más adelante. Por ello, los scripts que usan imágenes de plasma pueden incluir opciones para generar y reutilizar este tipo de imágenes aleatorias. Es decir, quizá quiera separar la generación de la imagen de plasma de las otras partes que la utilizan, para permitir su reutilización. Sin embargo, una técnica más simple es 'sembrar' o inicializar el generador de números aleatorios de IM, de modo que 'plasma:' genere la misma imagen 'aleatorizada'. De esa manera puede ajustar un script o un programa para que produzca una buena o interesante coloración o efecto, una y otra vez. |

  magick -size 100x100 -seed 4321  plasma:    plasma_seeded.jpg

La imagen anterior nunca cambiará, así que mientras no cambie el número de "[-seed](https://imagemagick.org/command-line-options/#seed)" siempre tendré un área 'roja' en la esquina inferior derecha. Curiosamente, usar la misma semilla con distintos degradados de color de inicialización puede producir un conjunto de imágenes que, aunque aleatorias, son similares en su patrón interno.

  magick -size 100x100 -seed 4321 plasma:grey-grey         plasma_rnd1.jpg
  magick -size 100x100 -seed 4321 plasma:white-blue        plasma_rnd2.jpg
  magick -size 100x100 -seed 4321 plasma:green-yellow      plasma_rnd3.jpg
  magick -size 100x100 -seed 4321 plasma:red-blue          plasma_rnd4.jpg
  magick -size 100x100 -seed 4321 plasma:tomato-steelblue  plasma_rnd5.jpg

Como puede ver, el mismo patrón de colores está presente en todas las imágenes anteriores, aunque la base de color subyacente puede resaltar u ocultar partes del patrón compartido. Solo una última advertencia. Otros operadores de IM también pueden usar el generador de números aleatorios, como la función 'rand()' de "[-fx](https://imagemagick.org/command-line-options/#fx)", el ajuste 'random' de "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)", el operador de tramado "[-random-threshold](https://imagemagick.org/command-line-options/#random-threshold)" y el operador "[-noise](https://imagemagick.org/command-line-options/#noise)". Por ello, es buena idea sembrar el generador inmediatamente antes de su uso concreto del generador de números aleatorios. A partir de IM v6.3.4-3, también puede re-aleatorizar el generador mediante "[+seed](https://imagemagick.org/command-line-options/#seed)". Así que colocar este ajuste después de su 'plasma sembrado' asegurará que cualquier operador posterior genere correctamente un resultado aleatorizado si así se desea. De forma predeterminada, la semilla se aleatoriza cuando IM arranca, así que normalmente no necesita aleatorizarla usted mismo mediante "[+seed](https://imagemagick.org/command-line-options/#seed)" para obtener un resultado aleatorio.

Problemas al usar plasma

Un problema que debe evitar con las imágenes "plasma:" es generarlas con una relación de aspecto elevada. Tiende a distorsionar los efectos de color normales del plasma, estirando los colores en forma de vetas con aspecto de aguja.

  magick -size 200x50 plasma:  plasma_high_aspect.jpg

No hay una solución simple para esto, así que, a menos que sea lo que busca, se aconseja precaución. También hay una clara deformación diagonal de la esquina superior izquierda a la inferior derecha en la imagen de plasma que no debería existir. Es decir, hay una especie de defecto de 'sesgo espacial' en el algoritmo. Por ejemplo, como señaló Thomas Maus , si refleja y añade la misma imagen de plasma, siempre verá una clara 'V' en la imagen resultante...

  magick -size 60x60 plasma: \( +clone -flop \) +append plasma_flaw.jpg

Esto no debería ocurrir. Pero el problema parece ser demasiado profundo como para poder corregirse sin básicamente reescribir por completo toda la función generadora de plasma.

Imágenes aleatorias

Ruido aleatorio en bruto

A partir de IM v6.3.5 puede generar una imagen puramente aleatoria a partir de una imagen existente usando el generador de ruido, "[+noise](https://imagemagick.org/command-line-options/#noise)" con el método 'Random'. |

  magick -size 100x100 xc:   +noise Random   random.png

Si su IM es más antiguo que esto, todavía puede generar una imagen de ruido puramente aleatorio usando el más lento operador FX casero, "[-fx](https://imagemagick.org/command-line-options/#fx)". |

  magick -size 100x100 xc: -fx 'rand()'   random_fx.png

O bien, por velocidad, puede usar el operador "[-spread](https://imagemagick.org/command-line-options/#spread)" para aleatorizar un degradado (por separado para los tres canales de color) o utilizando alguna otra imagen. |

  magick -size 100x100 gradient: -separate \
          -virtual-pixel tile   -spread 200   -combine  random_spread.png

El resultado puede parecer muy aleatorio, pero producirá un rango de colores más controlado (o simplemente valores de color).

Motas aleatorias (polvo de píxeles)

Generar imágenes de píxeles aleatorios dispersos también puede ser muy útil. . solo recuerde que cada uno de los tres canales de color de una imagen aleatoria puede considerarse como una imagen en escala de grises aleatoria independiente, y estos canales pueden fusionarse de varias maneras. Por ejemplo, puede generar una máscara de puntos aleatorios primero aplicando un umbral a un canal de color (el canal 'G' o verde) y separándolo como una imagen en escala de grises. |

  magick random.png  -channel G -threshold 5% -separate \
          +channel -negate    random_mask.png

Como cada color es un valor aleatorio lineal, el porcentaje de umbral usado arriba define directamente la densidad de los píxeles seleccionados. Puede ir más allá y usar un canal de color (el canal 'G' o verde) para seleccionar valores aleatorios de otro canal de color (el canal 'R' o rojo), usando varios métodos de composición de imágenes.

  magick random.png   -channel G -threshold 5% -negate \
          -channel RG -separate +channel \
          -compose Multiply    -composite   random_black.png
  magick random.png   -channel G -threshold 5% \
          -channel RG -separate +channel \
          -compose Screen      -composite   random_white.png
  magick random.png   -channel G -threshold 5% -negate \
          -channel RG -separate +channel \
          -compose CopyOpacity -composite   random_trans.png

Este tipo de imágenes son directamente utilizables para generar animaciones de brillo. Pero un procesamiento posterior, en particular sobre la versión con fondo negro, le permitirá agrandar los puntos en función de su intensidad en escala de grises o generar vetas o destellos en forma de estrella a partir de esos puntos. Para ejemplos, consulte Generadores de estrellas. Al igual que con las imágenes de plasma sembradas, también puede usar el ajuste "[-seed](https://imagemagick.org/command-line-options/#seed)" para preinicializar el generador de números aleatorios. Esto le permite generar de forma repetible las mismas imágenes aleatorias para una máquina concreta, igual que puede hacerlo con las imágenes de plasma.

Imágenes aleatorias desenfocadas (manchas aleatorias)

Ahora bien, aunque puede hacer uso directo de las imágenes aleatorias para crear efectos moteados, las imágenes puramente aleatorias generalmente no son muy útiles. Pero al desenfocar una imagen puramente aleatoria introducirá cierto orden de 'vecindad', de modo que los píxeles cercanos quedan relacionados entre sí. Por ejemplo, aquí desenfoco una sola imagen aleatoria, haciendo que los valores aleatorios produzcan 'manchas' más grandes o colores moteados.

  magick random.png -virtual-pixel tile  -blur 0x1  -auto-level  random_1.png
  magick random.png -virtual-pixel tile  -blur 0x3  -auto-level  random_3.png
  magick random.png -virtual-pixel tile  -blur 0x5  -auto-level  random_5.png
  magick random.png -virtual-pixel tile  -blur 0x10 -auto-level
random_10.png
  magick random.png -virtual-pixel tile  -blur 0x20 -auto-level
random_20.png

No obstante, observe que sin el ajuste de píxel virtual el operador "[-blur](https://imagemagick.org/command-line-options/#blur)" tendrá fuertes efectos de borde, que es mejor evitar. Como ventaja adicional, al cambiar el ajuste "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" a 'tile', la imagen aleatorizada sigue siendo embaldosable, con los colores envolviéndose a través de los límites de la imagen. Esta capacidad de embaldosado es algo que actualmente no es posible con las imágenes de plasma aleatorias y es un resultado inherente de que las imágenes puramente aleatorias sean tan aleatorias desde el principio. Tonos aleatorios desenfocados Una conversión concreta de una imagen de ruido aleatorio desenfocada que me resultó particularmente agradable es mapear los valores a los tonos de color HSB. |

  magick random_10.png -set colorspace HSB \
          -channel GB -evaluate set 100% +channel \
          -colorspace RGB random_hues_cyan.png

El problema de lo anterior es que el desenfoque tenderá a crear manchas de rojo-amarillo (valores bajos) y rojo-magenta (valores altos), con bandas de verde, cian y azules entre ellas. Esto es simplemente consecuencia de la forma en que se desenfocaron y nivelaron los valores de tono. La solución ideal para esto sería un tipo de desenfoque modular que tuviera en cuenta la naturaleza cíclica de los valores de tono. Sin embargo, tal operador no está disponible actualmente, y quizá nunca lo esté. La mejor solución que conozco es simplemente sumar los tres canales aleatorios de la imagen (usando la composición de suma modular) para así ampliar el rango de valores. Esto también tiene el efecto secundario de hacer más pequeñas las manchas desenfocadas, pero al menos ahora obtiene un rango dinámico de colores de arcoíris más amplio. ¿Alguien tiene una idea mejor? |

  magick random_10.png -separate -background white \
          -compose ModulusAdd -flatten -channel R -combine +channel \
          -set colorspace HSB -colorspace RGB random_hues.png

Para más métodos de procesamiento de imágenes aleatorias, consulte Imágenes de plasma más arriba, así como Generación de fondos. Grises aleatorios desenfocados Como puede ver en lo anterior, obtiene una imagen con varias manchas de colores primarios. Es decir, porque cada canal se procesa de forma completamente separada de los otros, como imágenes en escala de grises. Vamos a extraer uno de los canales de cada una de las imágenes anteriores para que pueda ver la estructura de la imagen desenfocada...

  magick random.png     -channel G  -separate   random_0_gray.png
  magick random_1.png   -channel G  -separate   random_1_gray.png
  magick random_3.png   -channel G  -separate   random_3_gray.png
  magick random_5.png   -channel G  -separate   random_5_gray.png
  magick random_10.png  -channel G  -separate   random_10_gray.png
  magick random_20.png  -channel G  -separate   random_20_gray.png

Lo primero que debería notar es que la imagen contendrá en general (pero no siempre) cantidades aproximadamente iguales de áreas tanto negras como blancas. Puede verlo si aplicamos un umbral a las imágenes aleatorias al 50%

  magick random_0_gray.png   -threshold 50%   random_0_thres.png
  magick random_1_gray.png   -threshold 50%   random_1_thres.png
  magick random_3_gray.png   -threshold 50%   random_3_thres.png
  magick random_5_gray.png   -threshold 50%   random_5_thres.png
  magick random_10_gray.png  -threshold 50%   random_10_thres.png
  magick random_20_gray.png  -threshold 50%   random_20_thres.png

Como puede ver, obtiene aproximadamente un 50% de áreas blancas y un 50% de áreas negras, separadas por una línea curva. Además, la curvatura de esta línea varía según el valor 'sigma ' usado para el desenfoque de la imagen puramente aleatoria. Desde píxeles individuales que generan una 'nieve' en blanco y negro hasta una separación muy uniforme (aunque todavía aleatoria) de la imagen en dos áreas, una blanca y otra negra. Para más ejemplos de uso de imágenes aleatorias, consulte Imágenes de fondo o, para ver la generación de lienzos aleatorizados, consulte Manchas aleatorias de color sólido.

Granularidad aleatoria (orden en el caos)

Ahora recuerde que todas las imágenes aleatorias desenfocadas se generaron a partir de la misma imagen aleatoria inicial, por lo que todas están relacionadas. Pero cada nueva imagen aleatoria generada tendrá un patrón completamente diferente, aunque los patrones tendrán una estructura más o menos similar. Pero primero demos un ejemplo completo de la generación de una 'imagen aleatoria desenfocada' desde cero... |

  magick -size 100x100 xc:  -channel G +noise Random \
         -virtual-pixel Tile -blur 0x5 -auto-level \
          -separate +channel   random_5_gray.png

El uso intensivo del ajuste "[-channel](https://imagemagick.org/command-line-options/#channel)" para limitar las operaciones al canal 'verde' de la imagen es importante, ya que acelera la generación global de la imagen en un factor de 3. La separación de canal garantizará entonces que obtengamos un resultado puramente en escala de grises. Si lo desea, podría omitir ambos ajustes "[-channel](https://imagemagick.org/command-line-options/#channel)", lo que daría como resultado la generación de 3 'imágenes aleatorias desenfocadas' completamente separadas y distintas. La imagen tiene algunas características importantes, que podemos ver con más claridad si dividimos la imagen en tres conjuntos iguales de colores (usando una técnica llamada posterización); puede ver que dentro de cada una de las zonas blanca y negra se obtienen más manchas circulares o 'gránulos'. Por ejemplo... |

  magick random_5_gray.png  -ordered-dither threshold,3  random_5_blobs.png

En primer lugar, conviene señalar cómo se obtienen cantidades aproximadamente iguales de zonas claras y oscuras dentro de la imagen, pero que esas zonas están interconectadas por los colores grises 'intermedios' del degradado que se forma entre las áreas claras y oscuras. Ahora bien, los grumos o 'gránulos' individuales varían de un área a otra a lo largo de la imagen, pero todos promedian aproximadamente un diámetro de unas tres a cuatro veces el valor usado para desenfocar la imagen aleatoria inicial. Este valor de desenfoque se conoce como la 'granularidad ' de la imagen y es un valor muy importante, ya que básicamente representa el tamaño medio de las estructuras circulares que produce la imagen aleatoria. A veces se le llama la 'curvatura' de la imagen. Cuanto mayor sea el valor, más grandes y lentas serán estas curvas dentro de la imagen. Este es el factor más importante que describe una imagen aleatoria desenfocada, así que dejémoslo muy claro...

La 'Granularidad ' de una imagen aleatoria (o factor de desenfoque)
determina el tamaño de las estructuras circulares que contiene

Por supuesto, cuanto menor sea el 'factor de desenfoque' o 'Granularidad ', más pequeñas o cerradas se vuelven las curvas, hasta que se alcanza un valor de '0', momento en el cual todo el agrupamiento o 'grumos' dentro de la imagen desaparece, y queda únicamente un efecto puramente aleatorio de tipo 'ruido', 'nieve' o 'polvo de píxeles'.
NOTA AL MARGEN: En realidad, el tamaño de los propios 'gránulos' puede variar dependiendo del factor de umbral usado para generarlos. Lo que el factor describe realmente es la distancia media entre los centros de las áreas blancas y negras. Cuanto mayor sea el valor, mayor será la distancia, y más grandes y dispersos tendrán que ser los puntos para acomodar esa distancia incrementada. Esto se vuelve más evidente cuando empezamos a examinar las Ondulaciones Aleatorias más abajo.
También puede que desee probar a usar una operación de Solarización al 50% con algunos Ajustes de Nivel adicionales para extraer de la imagen tanto los gránulos negros como blancos bien separados. Por ejemplo, aquí hay un ejemplo completo con una granularidad de '8' y un umbral de grumos del '25%' que genera puntos blancos a partir de las partes tanto negras como blancas de la imagen. |

  magick -size 100x100 xc: -channel G +noise random \
          -virtual-pixel tile -blur 0x8 -auto-level  \
          -solarize 50% -separate +channel \
          -threshold 25% -negate   random_granules.png

Tenga en cuenta que, a medida que el valor crece, el tiempo necesario para generar la imagen aleatoria desenfocada también se vuelve mucho más largo. Además, cuando el valor alcanza aproximadamente la mitad de la dimensión más pequeña de la imagen, el efecto deja de crecer a medida que la imagen aleatoria se asienta en un único punto blanco y negro. No se recomiendan valores grandes. Para terminar, a la izquierda se muestra una Animación de Ciclo de Patrulla resultante de variar la 'granularidad' (desenfoque aleatorio) de una única imagen aleatoria. La animación se generó usando el script de shell "[animate_granularity](../static/img/canvas/animate_granularity)", que puede descargar, estudiar y experimentar con él. Observe que, como se usa la misma imagen aleatoria como fuente, los 'gránulos' o puntos en realidad no se mueven, sino que más bien crecen juntos o se desvanecen, de modo que producen 'gránulos' más grandes a medida que aumenta la granularidad. Recuerde también que, aunque he reducido el número de colores en la animación, la estructura de la imagen aleatoria completa es en realidad un degradado suave entre dos conjuntos de gránulos blancos y negros. Este degradado es lo que hace que la imagen sea útil en otras técnicas.

Flujo Aleatorio (ciclos de animación)

Como vio anteriormente, los gránulos o puntos en realidad no se mueven demasiado. Pero para los efectos de animación se desea un patrón que se mueva de forma fluida en el tiempo. Además, no se quiere que ese patrón simplemente se mueva de un lado a otro. Y finalmente, no se quiere que ese patrón de movimientos salte o dé tirones repentinos cuando la animación se repite en bucle. Así que lo que se necesita es alguna forma de generar un patrón aleatorio que se repita de forma fluida. Una tarea ambiciosa. Además, como se necesita que sea fluido, habrá que generar todos los patrones a partir de la misma única imagen aleatoria. Aquí hay una idea que permite generar tal patrón aleatorio. En lugar de pensar en cada valor de píxel aleatorio como una intensidad aleatoria, pensamos en cambio en ese valor como un valor de 'tiempo' que define cuándo ese píxel alcanza su máxima o mínima intensidad. Es decir, convertimos ese valor en una posición sobre una 'onda'. Así, cada píxel representa alguna 'fase' de una curva sinusoidal. Esto suena complicado, pero en realidad no lo es. Simplemente usamos la Imagen Aleatoria como imagen fuente para una Función Sinusoidal. Ahora, para cada imagen de la secuencia temporal, establecemos la 'fase ' temporal para ese punto particular del ciclo de tiempo.

  magick random.png   -function Sinusoid 1,_{time}_ \
          ... realiza el desenfoque granular, y otro procesamiento ...

Donde '_{time}_' va de '0' a '360' a lo largo del ciclo completo de animación. El resultado es que, en lugar de que cada píxel tenga un valor aleatorio 'estático', ahora tenemos uno que cicla en bucle entre negro y blanco durante un periodo de tiempo. Cada píxel seguirá este mismo ciclo, pero como cada píxel tiene una 'fase' completamente diferente, ciclará de forma independiente de todos los demás píxeles. Es decir, la imagen sigue siendo aleatoria, pero cambia de forma fluida con el valor de 'tiempo' proporcionado. Para los de mentalidad científica, esto se parece un poco a observar el 'flujo cuántico' que existe a nivel subatómico, donde el espacio está lejos del estado 'estático' que vemos a escalas normales. De ahí el nombre de 'Flujo Aleatorio '. Por ejemplo, generemos una secuencia temporal de 12 imágenes...

  for i in `seq 0 30 359`; do
    magick random.png  -channel G  -function Sinusoid 1,${i} \
            -virtual-pixel tile -blur 0x8 -auto-level \
            -separate flux_${i}.png
  done

Y su única imagen aleatoria puede ahora generar toda una secuencia de imágenes que forman un ciclo. Observe que la extracción del 'tiempo' tiene que ocurrir antes de cualquier otro procesamiento como el desenfoque, que probablemente es la parte más lenta de todo el proceso de generación. La otra cosa que hay que notar es que en la fase '180' (abajo a la derecha), en realidad se obtiene exactamente el negativo de la primera imagen (arriba a la izquierda). Es decir, los gránulos 'blancos' se han convertido en gránulos 'negros', y viceversa. De hecho, toda la segunda mitad de la animación es en realidad el negativo de la primera mitad. Esto puede usarse para reducir el tiempo de generación de una simple animación de 'Flujo Aleatorio'. Como la imagen es un negativo en una fase de 180 grados, encontrará que cada gránulo 'blanco' se mueve lentamente para intercambiar lugares con un gránulo 'negro' vecino. Pero como toda la segunda mitad es un negativo de la primera, no puede simplemente desplazarse de un lado a otro, sino que debe seguir avanzando para volver a la imagen original, o describir un círculo en bucle, o simplemente desvanecerse y aparecer de forma adecuada. En otras palabras, los gránulos blancos y negros se mueven en un ciclo mucho más complejo. A la derecha hay una animación de los fotogramas anteriores... El patrón fluctuante es completamente aleatorio, pero cambia de forma fluida de fotograma a fotograma, y cuando la animación se repite en bucle. No se aprecia ni principio ni fin en el resultado. A veces se obtendrá un movimiento arremolinado, otras veces parece que todos los grumos parecidos a 'gas' están siendo absorbidos hacia una zona oscura, o simplemente aparecen y se desvanecen de nuevo. También se obtienen periodos de movimientos muy rápidos, así como movimientos muy lentos. Es totalmente aleatorio. En resumen : Las mismas propiedades presentes en las Imágenes Aleatorias Desenfocadas están también presentes en esta animación. La imagen sigue siendo una división aproximadamente igual entre segmentos blancos y negros, y forma grumos de unas tres veces el tamaño del desenfoque o Granularidad de la imagen. Pero además de esto, se garantiza que todas las partes de la imagen formarán algún ciclo entre colores más claros y más oscuros, ya que la mitad del ciclo es el negativo de la otra mitad. Una cosa que quizá no haya notado es que, debido a la conversión de un valor lineal aleatorio en una forma de onda sinusoidal, se obtiene una separación de colores blanco y negro más nítida (contraste). Por ello, puede que desee usar el aspecto de reducción de contraste del operador de Contraste Sigmoidal para hacer que la imagen resultante se parezca menos a 'grumos' y realzar el degradado entre los gránulos, en lugar de los gránulos mismos. Ahora bien, esto es solo un punto de partida para lo que se puede hacer con una animación aleatoria cíclica. Todo lo que se puede hacer con una Imagen Aleatoria, como se describe en Generación de Fondos, también puede aplicarse a la 'Animación de Flujo Aleatorio ' Por ejemplo, mostremos solo el movimiento de los gránulos 'blancos'... |

  magick flux_anim.gif -threshold 70% flux_thres_anim.gif

O generar filamentos eléctricos cambiantes que fluyen lentamente sobre la imagen. |

  magick flux_anim.gif  \
          -sigmoidal-contrast 30x50% -solarize 50% -auto-level \
          -set delay 20 filaments_anim.gif

Tenga en cuenta que, debido a que la mitad del ciclo es una negación de la primera mitad y usamos una Solarización para plegar los colores blanco y negro a la mitad, el ciclo en realidad se repite dos veces a lo largo de un ciclo de animación. Realmente se necesitan muchos más fotogramas para eliminar algunos de los cambios muy rápidos que tienen lugar.
Para hacer el movimiento menos predecible en una secuencia cíclica más larga, también puede usar algo de Matemática de Degradados para combinar múltiples ciclos sinusoidales, de múltiples imágenes aleatorias, o incluso usando simplemente los otros canales de color de la misma imagen aleatoria.

FUTURO: Crear ciclos 'armónicos' de largo tiempo aún menos predecibles.

Ondulaciones Aleatorias

Al añadir otra variación a una Imagen Aleatoria Desenfocada podemos agregar otro nivel de complejidad que hace que estas imágenes sean mucho más útiles, y nos da otra variable de control más allá de su Granularidad. Pero primero hay que recordar que la imagen aleatoria no consiste únicamente en áreas claras y oscuras, sino que también contiene una pendiente entre esas áreas. Usando esa pendiente como entrada a la Función Sinusoidal, se pueden generar ondulaciones entre los puntos de la imagen. Observe que la diferencia clave de este uso de la Función Sinusoidal respecto a los ejemplos anteriores de Flujo Aleatorio era que esta vez la función se aplica a la imagen DESPUÉS de haber sido suavizada mediante desenfoque, en lugar de antes. Además, en este caso es el valor de 'Frecuencia ', y no el segundo valor de 'Fase ', el que es más importante. Por ejemplo...

  magick random_10_gray.png  -function Sinusoid 1,90   ripples_1.png
  magick random_10_gray.png  -function Sinusoid 2,90   ripples_2.png
  magick random_10_gray.png  -function Sinusoid 3,90   ripples_3.png
  magick random_10_gray.png  -function Sinusoid 4,90   ripples_4.png

Como puede ver, cuanto mayor es la 'Frecuencia ' de la Función Sinusoidal, más ondulaciones se añaden al degradado entre los 'gránulos'. Una 'Frecuencia ' de '1' básicamente convertirá en blanco tanto los grumos claros como los oscuros de la imagen fuente, y dejará un hueco oscuro entre ellos. Una 'Frecuencia ' de '2' comprime una 'cresta' u 'ondulación' adicional en ese hueco oscuro. A medida que la frecuencia aumenta, se obtienen cada vez más 'ondulaciones' entre las áreas más claras y más oscuras de la imagen original, haciéndola cada vez más compleja. A medida que el número de crestas aumenta, se puede perder de vista los 'grumos' o 'gránulos' originales de la imagen. Esto se puede corregir modificando el degradado antes de añadir las ondulaciones, ya sea 'recortando' el degradado mediante un Ajuste de Nivel, o comprimiendo los tonos medios mediante Contraste Sigmoidal. Esto dará a los 'gránulos' algo de masa o área, proporcionando zonas de 'calma' entre las ondulaciones.

  magick random_10_gray.png        -level 25%            random_enhanced.png
  magick random_enhanced.png  -function Sinusoid 4,90    ripples_4e.png
  magick random_10_gray.png   -sigmoidal-contrast 10,50% random_sigmoidal.png
  magick random_sigmoidal.png -function Sinusoid 4,90    ripples_4s.png

Ambos métodos tienen ventajas y desventajas, pero en esencia agrandarán los gránulos, aunque no la distancia entre los conjuntos de gránulos blancos y negros. El efecto secundario de esto es, por supuesto, una compresión de las ondulaciones entre los dos conjuntos de gránulos.
El segundo valor '90' usado en los ejemplos anteriores es la 'Fase ' de la Función Sinusoidal. Determinará el color en que se convertirá el gránulo 'negro' de la imagen fuente en la imagen 'ondulada'.

  magick random_enhanced.png  -function Sinusoid 3,0     ripples_3e000.png
  magick random_enhanced.png  -function Sinusoid 3,90    ripples_3e090.png
  magick random_enhanced.png  -function Sinusoid 3,180   ripples_3e180.png
  magick random_enhanced.png  -function Sinusoid 3,270   ripples_3e270.png

El color del gránulo 'blanco' dependerá tanto de la 'Fase ' como de la fracción de la 'Frecuencia ' que se aplique. Un valor entero de 'Frecuencia ' hará que tanto los gránulos blancos como los negros varíen de color a la vez (de acuerdo con la 'Fase '). Por ello, con una fase de '90' ambos serán blancos. Sin embargo, si se aplica un valor fraccionario de 'Frecuencia ' de, digamos, '0.5', el gránulo de 'fuente blanca' será el negativo del gránulo de 'fuente negra' (según lo determine la 'Fase '). |

  magick random_enhanced.png  -function Sinusoid 3.5,90    ripples_3.5e.png

Observe que, para los ángulos de 'Fase ' 'grises', uno de los gránulos está rodeado por un anillo blanco, mientras que el otro está rodeado por un anillo negro. Si se usa un valor de 'Frecuencia ' con una fracción de '0.5', la primera ondulación alrededor de cada punto será completamente blanca o completamente negra, dependiendo de la 'Fase ' usada. | _No se recomiendan otras 'Frecuencias' distintas de enteros o de '0.5', ya que los dos conjuntos de gránulos no estarán sincronizados de ninguna manera.

De forma similar, no se recomiendan fases distintas de un múltiplo de 90 grados, a menos que se genere una 'animación de ondulaciones' (véase más abajo).

Se recomienda un valor de Fase de '0' al generar 'Mapas de Dispersión' (véase más abajo), ya que esto causará distorsiones mínimas dentro de las áreas de 'gránulos' realzados.
---|---
Como antes en Flujo Aleatorio, puede modificar la '_Fase ' con el tiempo para generar una animación de las ondulaciones moviéndose de un conjunto de gránulos al otro. Esto funciona particularmente bien sin ningún realce de contraste. |

  for i in `seq 0 30 359`; do
    magick random_10_gray.png -function Sinusoid 3.5,${i} miff:-
  done |
    magick miff:- -set delay 15 -loop 0 ripples_anim.gif

NOTA AL MARGEN: la técnica usada en lo anterior se conoce como un "MIFF: encadenado" y es posible porque el formato de archivo "MIFF:" puede simplemente 'concatenar' imágenes para generar un archivo de imágenes múltiples. Un punto a destacar es que la animación parece cambiar mucho más lentamente que una Animación de Flujo que creamos antes. Esto se debe a que, a lo largo de un ciclo de animación, una ondulación solo recorrerá una distancia corta, mientras que en una animación de 'flujo' el cambio recorrerá desde los gránulos blancos a negros de gran escala en solo la mitad del ciclo, y de vuelta de nuevo. Ahora puede combinar la animación de ondulaciones anterior con una animación de 'flujo' subyacente de la misma fuente de imagen aleatoria para generar una forma mucho más dinámica y fluida, pero tenga cuidado con esa diferencia de velocidad de animación. Por ejemplo, aquí simplemente tomo la Animación de Flujo anterior creada arriba, y le añado ondulaciones. Las ondulaciones, en este caso, se moverán solo porque el degradado de la animación de flujo se mueve. |

  magick flux_anim.gif -function Sinusoid 3.5,0 flux_rippled_anim.gif

También puede animar las ondulaciones dentro de la animación. Aunque puede que necesite usar una 'tasa de ciclo de fase' mucho mayor (la expresión 'j = 5 * i') para las ondulaciones mismas. Además, como está generando un ciclo dentro de un ciclo, necesitará generar una animación mucho más larga, de 60 fotogramas en este caso. Sin embargo, eso tiene la ventaja de ralentizar también los movimientos de 'flujo' más grandes. |

  for i in `seq 0 10 359`; do
    j=`expr $i \* 5`
    magick random.png -channel G \
            -function Sinusoid 1,${i} \
            -virtual-pixel tile -blur 0x8 -auto-level \
            -function Sinusoid 2.5,${j} \
            -separate +channel miff:-
  done |
    magick miff:- -set delay 15 -loop 0 ripples_flux_anim.gif

Observe en la segunda imagen cómo las ondulaciones parecen primero salir de un punto, y luego empiezan a regresar al mismo punto, aunque nunca simplemente invierten la dirección. Un mejor generador de ciclos de flujo multiciclados debería eliminar esta ligera rareza al eliminar el efecto 'negativo' en la animación de flujo subyacente.
FUTURO: Uso de Imágenes Aleatorias Onduladas para Distorsiones Mapeadas por Dispersión.

Lienzos en Mosaico

Las imágenes de mosaico pueden ser muy grandes o muy pequeñas, están diseñadas para encajar entre sí en sentido horizontal y vertical para cubrir grandes áreas de espacio. Gracias a la World Wide Web, ha habido una explosión de imágenes de mosaico disponibles para usar (encontrar lo que se desea es otro asunto). A continuación hay un conjunto de imágenes en mosaico que copié de la Biblioteca de Iconos de Anthony para usarlas a lo largo de estas páginas de ejemplo.
bg.gif |
tile_aqua.jpg |
tile_water.jpg |
rings.jpg |
tile_disks.jpg |
tile_weave.gif
---|---|---|---|---|---
Actualmente hay bastantes maneras en las que se puede disponer una imagen en mosaico sobre un área grande. Se puede usar "[-tile](https://imagemagick.org/command-line-options/#tile)" en cualquier imagen para reemplazar por completo la imagen de fondo original (usando el operador de composición "Copy"). (Para más detalles, véase Composición en Mosaico). |

  magick composite -tile tile_weave.gif -size 60x60  xc:none   tile_copy.gif

Otra forma es leer la imagen de mosaico usando el codificador "tile:", y disponerla en mosaico de un tamaño específico. |

  magick -size 60x60 tile:bg.gif  tile_size.gif

| _Tenga en cuenta que el codificador "tile:" reemplazará cualquier transparencia de la imagen con el color de fondo actual. Esto es así porque internamente genera un lienzo del tamaño solicitado y 'superpone' la imagen en mosaico sobre ese lienzo.

Si desea preservar la transparencia, establezca bien "-background none" o "-compose SRC" (véase Método de Composición Src para más detalles)._
---|---
Puede usar esto para generar una imagen en mosaico mucho más grande de lo que necesita, y luego usar "[-composite](https://imagemagick.org/command-line-options/#composite)" para superponerla sobre la imagen original. Si la imagen de mosaico es parcialmente transparente, será necesario especificar un método "[-compose](https://imagemagick.org/command-line-options/#compose)" de '[Over](compose.html#over)'. Es un método de disposición en mosaico muy lento, particularmente para imágenes grandes, y se tiene el problema de determinar exactamente cuán grande debe ser la imagen que se necesita crear para la superposición. |

  magick test.png -size 200x200 tile:tile_disks.jpg \
          -composite  tile_over.gif

Al especificar un mosaico como 'patrón de relleno de mosaico' para el operador "[-draw](https://imagemagick.org/command-line-options/#draw)", puede dibujar la imagen de mosaico sobre otra imagen, para crear cualquier forma o figura que desee. Esto se debe a que el ajuste "[-tile](https://imagemagick.org/command-line-options/#tile)" anulará cualquiera de los ajustes de color "[-fill](https://imagemagick.org/command-line-options/#fill)" usados por draw. Véase Ajustes de Dibujo MVG. |

  magick -size 60x60 xc: -tile tile_aqua.jpg \
          -draw "circle 30,30 2,30"   tile_draw.gif

Esto solo funciona para "[-draw](https://imagemagick.org/command-line-options/#draw)" y operadores como "[-annotate](https://imagemagick.org/command-line-options/#annotate)" que también hacen uso de "[-draw](https://imagemagick.org/command-line-options/#draw)" para realizar su función. No funcionará para operadores de imagen que usan directamente el color "[-fill](https://imagemagick.org/command-line-options/#fill)", como "[label:](text.html#label)", "[caption:](text.html#caption)" y "[text:](text.html#text)". Sin embargo, "[-draw](https://imagemagick.org/command-line-options/#draw)" tiene incorporadas algunas primitivas de color especiales, como restablecer por completo todos los píxeles de la imagen al color de relleno o patrón de mosaico (si está establecido). |

  magick test.png   -tile tile_water.jpg  -draw "color 0,0 reset" \
          tile_reset.gif

Este es en realidad exactamente el mismo método que usan algunos métodos de Lienzos de Color Sólido que emplean un Color Específico. Solo que aquí usamos "[-tile](https://imagemagick.org/command-line-options/#tile)" en lugar de un color "[-fill](https://imagemagick.org/command-line-options/#fill)".
Un método más avanzado consiste en usar un Operador de Distorsión con un ajuste especial de Viewport de Distorsión, que se estableció al tamaño de la imagen original (usando un Artefacto Global Definido y Escapes de Porcentaje). Esto básicamente mapea los Píxeles Virtuales de los mosaicos más pequeños, que rodean la pequeña imagen de mosaico, para generar el lienzo en mosaico más grande. |

  magick rose: -set option:distort:viewport '%g' +delete  \
          tree.gif -virtual-pixel tile -filter point -distort SRT 0 \
          tile_distort_sized.gif

Véase Disposición en Mosaico mediante Distorsión (más abajo), donde examinaremos esta misma técnica para disponer en mosaico una imagen que ya está en memoria.

Lienzos en Mosaico con Desplazamiento

A veces se necesita un poco más de control sobre el posicionamiento exacto de una textura de fondo, ya sea para alinear un patrón de mosaico con alguna otra imagen, o para evitar una mala correlación con alguna otra parte de la imagen final. Para muchos de los métodos estándar de disposición en mosaico, esto se puede lograr usando el ajuste "[-tile-offset](https://imagemagick.org/command-line-options/#tile-offset)". Por ejemplo, aquí desplazo en bucle la imagen de mosaico usada para crear directamente una imagen de lienzo en mosaico usando "tile:" o "pattern:".

  magick -size 80x80 -tile-offset +30+30 tile:rose: offset_tile.gif
  magick -size 80x80 -tile-offset +20+20 \
                                 pattern:checkerboard offset_pattern.gif

| El ajuste de Desplazamiento de Mosaico estaba defectuoso antes de la versión 6.3.9-9 de IM, en el sentido de que el desplazamiento 'X' se usaba tanto para los valores de desplazamiento 'X' como 'Y' (el valor 'Y' dado se ignoraba). Esto significa que, aunque los ejemplos anteriores habrían funcionado (los desplazamientos X e Y son iguales), puede que no obtenga los resultados esperados cuando los dos valores difieran.
---|---
Esto también funciona para el ajuste "[-texture](https://imagemagick.org/command-line-options/#texture)" de fondo de "magick montage". |

  montage tree.gif     -geometry +24+24 \
          -tile-offset +30+30 -texture rose: offset_texture.gif

También puede usar el ajuste definiéndolo antes del ajuste "[-tile](https://imagemagick.org/command-line-options/#tile)" o "[-fill](https://imagemagick.org/command-line-options/#fill)". Por ejemplo... |

  magick -tile-offset +30+30  -tile rose: \
          -size 80x80 xc: -draw 'color 30,20 reset'    offset_tile_fill.gif

Asegúrese de que el ajuste "[-size](https://imagemagick.org/command-line-options/#size)" se restablezca antes de definir la imagen "[-tile](https://imagemagick.org/command-line-options/#tile)", pero después de que se haya leído cualquier otra imagen. |

  magick -size 80x80  xc: \
          -tile-offset +20+20 +size -tile pattern:checkerboard \
          -draw 'color 30,20 reset'  offset_pattern_good.gif

En cualquier caso, probablemente sea mejor definir el desplazamiento de mosaico y la imagen de mosaico justo antes de su primer uso, lo que da el mismo resultado que la solución anterior.

Disposición en Mosaico con una Imagen ya en Memoria

Disponer en mosaico una imagen que se tiene en memoria (creada o modificada) no es sencillo, y solo hay disponibles unos pocos métodos indirectos.

Clonar y Anexar la Imagen de Mosaico

Si no le preocupa el tamaño exacto de la imagen en mosaico, puede simplemente anexar la imagen junta varias veces. Por ejemplo, aquí disponemos la imagen en mosaico en una matriz de 3x3. |

  magick tree.gif \
          \( +clone +clone \) +append \
          \( +clone +clone \) -append \
          tile_clone.gif

Este método de disposición en mosaico tiene la ventaja de permitirle disponer el mosaico volteado (mosaico en espejo) de la imagen. |

  magick tree.gif \
          \( +clone -flop +clone \) +append \
          \( +clone -flip +clone \) -append \
          tile_clone_flip.gif

En general, este método solo es práctico cuando se tiene alguna idea de cuán grande es la imagen que se está disponiendo en mosaico. Además, como los clones son en realidad muy rápidos y eficientes, es un método de disposición en mosaico bastante simple y rápido, especialmente si usa los resultados para seguir disponiendo en mosaico la imagen más grande.

Disposición en Mosaico usando MPR: (Registro de Programa en Memoria)

Un método mejor consiste en guardar la imagen en un formato de archivo especial 'En Memoria' "[mpr:](files.html#mpr)", o 'registro de programa en memoria' (memory program register). Desde este registro puede luego usar bien un ajuste "[-tile](https://imagemagick.org/command-line-options/#tile)", o usar el lector especial de archivos de imagen "tile:", ambos de los cuales solo pueden establecerse a partir de un formato de archivo de imagen 'guardado'. Por ejemplo, usando "tile:" para crear una imagen en mosaico de un tamaño específico... |

  magick tree.gif   -write mpr:tile +delete \
          -size 100x100 tile:mpr:tile    tile_mpr.gif

| Recuerde que el codificador "tile:" reemplazará cualquier transparencia de la imagen con el color de fondo actual. (véase más arriba)
---|---
O disponer en mosaico sobre una imagen existente, estableciendo el patrón de relleno "[-tile](https://imagemagick.org/command-line-options/#tile)" o "[-fill](https://imagemagick.org/command-line-options/#fill)", y usando "[-draw](https://imagemagick.org/command-line-options/#draw)" para hacer un restablecimiento de color (véase Primitivas de Relleno de Color)... |

  magick tree.gif  -write mpr:tile +delete \
          granite: -fill mpr:tile  -draw 'color 0,0 reset' \
          tile_mpr_reset.gif

| Si dispone en mosaico con una imagen que contiene transparencia, asegúrese de que la imagen de destino también tenga transparencia usando "-alpha set". Si no lo hace, la imagen resultante mostrará el color de transparencia 'oculto' de los mosaicos.
---|---
O dibuje usando alguna otra Primitiva de Dibujo, como un círculo, usando el patrón de relleno. |

  magick tree.gif -write mpr:tile +delete \
          granite:  -tile mpr:tile  -draw 'circle 64,64 10,50' \
          tile_mpr_fill.gif

El nombre indicado después de "[mpr:](files.html#mpr)" puede ser cualquiera, solo es una etiqueta del nombre de registro 'mpr' usado para almacenar la imagen (en memoria). Puede ser incluso una etiqueta, un número, un color o incluso un nombre de archivo.

Mosaico mediante píxeles virtuales con Distort

En este método se usa la configuración de píxel virtual para generar un lienzo en mosaico de gran tamaño. Esta opción define cómo debe verse el área que rodea la imagen real (fuera de los límites normales de la imagen). La forma más sencilla de extraer píxeles virtuales es usar el operador Distort con una opción especial de viewport de Distort. |

  magick tree.gif -set option:distort:viewport 100x100+0+0 \
          -virtual-pixel tile -filter point  -distort SRT 0 \
          tile_distort.gif

También se dispone de otros estilos de configuración de mosaico de píxeles virtuales, como '[Mirror](misc.html#mirror)', o incluso '[CheckerTile](misc.html#checker_tile)', además de un buen control del desplazamiento del mosaico mediante la opción de viewport. |

  magick tree.gif -set option:distort:viewport 100x100-10-10 \
          -background firebrick  -virtual-pixel CheckerTile \
          -distort SRT 0 +repage    tile_distort_checks.gif

Al usar el operador de distorsión general de esta manera, se obtiene además la ventaja de distorsionar la imagen en mosaico de formas muy complejas. Pueden verse ejemplos de ello en mosaico afín con Distort. Como ejemplo más complejo, aquí se usa una distorsión Arc para disponer el árbol en mosaico alrededor del origen, que está centrado en el viewport. El '45' especifica el ángulo que abarca el ancho del árbol, mientras que el '50' define el radio para el borde superior del mosaico del árbol. El resto se deduce de esto. |

  magick tree.gif -set option:distort:viewport 100x100-50-50 \
          -virtual-pixel tile  -distort Arc '45 0 50' +repage \
          tile_distort_polar.gif

Modificación de patrones/mosaicos integrados de IM

Véase la lista completa de imágenes y patrones integrados de ImageMagick. Hay muchos patrones de este tipo, pero aquí solo se verán uno o dos. Los patrones integrados suelen ser imágenes muy muy pequeñas, que pueden disponerse en mosaico para cubrir áreas grandes. Sin embargo, por sí solos tienen un aspecto muy simple y resultan más bien inútiles. Por ejemplo, aquí se muestra uno de los patrones más grandes e interesantes que se proporcionan... |

  magick pattern:checkerboard  pattern_default.gif

Las imágenes de patrón suelen disponerse en mosaico sobre áreas más grandes, ya sea como parte de la creación del lienzo, estableciendo un "[-size](https://imagemagick.org/command-line-options/#size)", o como mosaico de relleno (véase Lienzos en mosaico más arriba). Sin una opción de tamaño se usará el tamaño de mosaico predeterminado del patrón, 30x30 píxeles en este caso. Probablemente se notará que todos los patrones que IM proporciona actualmente son en blanco y negro puro, con la única excepción del patrón 'checkerboard' usado en el ejemplo anterior. Aquí hay un patrón que me gusta especialmente usar como patrón de mosaico... |

  magick -size 60x60 pattern:hexagons  pattern_hexagons.gif

Si estos colores no resultan satisfactorios, pueden reemplazarse usando el operador de imagen "[-opaque](https://imagemagick.org/command-line-options/#opaque)". |

  magick -size 60x60 pattern:hexagons \
          -fill blue -opaque black   -fill skyblue -opaque white \
          pattern_colored.gif

Si se desea colorear el patrón "checkerboard", lo mejor es usar primero "[-auto-level](https://imagemagick.org/command-line-options/#auto-level)" para asignar los dos grises a blanco y negro antes de sustituir esos dos colores. Aquí, en lugar de usar "[-opaque](https://imagemagick.org/command-line-options/#opaque)" para reemplazar los colores, se usa un operador "[+level-colors](https://imagemagick.org/command-line-options/#level-colors)" (añadido en IM v6.2.4-1), que es un poco más sencillo de usar. |

  magick -size 60x60 pattern:checkerboard -auto-level \
          +level-colors red,blue     pattern_color_checks.gif

También se puede usar el operador "[-floodfill](https://imagemagick.org/command-line-options/#floodfill)" para colorear el patrón. Sin embargo, para que funcione correctamente hay que hacerlo antes de disponer en mosaico el patrón modificado. En este caso también es necesario expandir el mosaico tres veces para colorearlo con el patrón regular de colores deseado. |

  magick -size 30x54 pattern:hexagons \
          -fill tomato     -opaque white \
          -fill dodgerblue -draw 'color 10,10 floodfill' \
          -fill limegreen  -draw 'color 10,25 floodfill' \
          -roll +15+27 \
          -fill dodgerblue -draw 'color 10,10 floodfill' \
          -fill limegreen  -draw 'color 10,25 floodfill'   miff:- |\
    magick -size 100x100 tile:- pattern_color_hexagons.gif

En lo anterior se usó una tubería de dos comandos para separar la creación del patrón coloreado de su uso real. Si se prefiere hacerlo con un solo comando, véase Disposición en mosaico de una imagen en memoria más arriba. También se puede deformar y distorsionar un patrón de mosaico simple para producir variaciones interesantes. Por ejemplo, un efecto de 'arrugado' (técnica cortesía del efecto wrinkle de IM de Font Image Generator) sobre un patrón de hexágonos que me pareció particularmente interesante |

  magick -size 160x100 pattern:hexagons \
          -wave 3x100 -background white -rotate 90 -wave 4x66 -rotate -87 \
          -gravity center -crop 120x90+0+0 +repage   pattern_distorted.gif

Modificación de imágenes de mosaico

El mayor problema al modificar mosaicos, ya sea un mosaico existente o uno de los patrones integrados, es que muchas operaciones de imagen destruyen la 'capacidad de mosaico' de la imagen. Por ejemplo, aquí se ha tomado el patrón integrado 'hexagon' y se ha intentado modificarlo para producir un patrón sombreado en escala de grises de líneas hexagonales anchas. |

  magick pattern:hexagons  -rotate 90 \
          -blur 0x1  -edge 1  -negate  -shade 120x45 \
          miff:- |\
    magick -size 100x100 tile:-   tile_mod_failure.jpg

El primer comando genera la 'imagen de mosaico', mientras que el segundo dispone realmente la imagen en mosaico, para poder ver cómo encajan todas. Como puede verse, la imagen de mosaico resultante NO forma mosaico correctamente, con distorsiones artificiales en los bordes claramente visibles en la imagen en mosaico. Básicamente se perdió la uniformidad del mosaico original a lo largo de los bordes de la imagen. Una solución es usar una configuración especial de píxeles virtuales, que se usa para hacer que los operadores crean que la imagen se repite alrededor de los bordes, al buscar colores que están más allá de los límites de la imagen real. |

  magick pattern:hexagons  -rotate 90  -virtual-pixel tile \
          -blur 0x1  -edge 1  -negate  -shade 120x45 \
          miff:- |\
     magick -size 100x100 tile:-   tile_mod_vpixels.jpg

Aquí hay otro ejemplo donde se unen dos patrones de mosaico relacionados y se usan varios efectos para crear un mosaico de pared de ladrillos inusual. |

  magick pattern:leftshingle pattern:rightshingle +append \
          -virtual-pixel tile  -blur 0x0.75 -resize 150% -shade 100x45 \
          -fill Peru  -tint 100%   miff:- |\
    magick -size 100x100 tile:-   tile_slanted_bricks.jpg

Alternativa

Existe una alternativa a depender de los píxeles virtuales. Básicamente, se proporcionan nosotros mismos los 'píxeles virtuales del borde' antes de operar sobre la imagen, a fin de evitar cualquier efecto de borde que pueda estar presente. Y eso se hace disponiendo primero la imagen en mosaico sobre un área ligeramente mayor. Tras modificar la imagen, se puede volver a extraer el mosaico, evitando las distorsiones de borde que se introdujeron. No tiene que ser mucho mayor, según el alcance de las operaciones de imagen realizadas. He comprobado que de 15 a 40 píxeles deberían detener todos los efectos de borde en el resultado final. Para volver a extraer la imagen, se puede "[-shave](https://imagemagick.org/command-line-options/#shave)" quitar los píxeles adicionales, o "[-crop](https://imagemagick.org/command-line-options/#crop)" el tamaño original del mosaico desde el centro de la imagen procesada. Por ejemplo, aquí se crea un efecto "[-shade](https://imagemagick.org/command-line-options/#shade)" 3D usando el patrón integrado 'hexagons'. |

  magick -size 60x60 tile:pattern:hexagons  -rotate 90 \
          -blur 0x1  -edge 1  -negate  -shade 120x45 \
          -gravity center -crop 18x30+0+0 +repage miff:- |\
    magick -size 100x100 tile:-   tile_mod_success.jpg

Nótese que la posición exacta del mosaico extraído no importa. Una imagen apta para mosaico puede recortarse desde cualquier parte de la imagen en mosaico, siempre que esté alejada de los bordes distorsionados y se use el mismo tamaño original del mosaico. Aquí, en lugar de disponer la imagen en mosaico sobre un área más grande, se usa una técnica de 'doble clonado' para duplicar el área que cubre el mosaico. Al terminar, basta con recortar el 50% central de la imagen para recuperar el mosaico modificado. Esto significa que no es necesario conocer el tamaño exacto del mosaico que se procesa. |

  magick pattern:circles \( +clone \) +append \( +clone \) -append \
          -fill grey -opaque black  -blur 0x0.5 -shade 120x45 \
          -gravity center -crop 50%  +repage    miff:- |\
    magick -size 100x100 tile:-   tile_circles.jpg

Generación de imágenes de mosaico. El mayor problema al generar imágenes que pueden disponerse en mosaico juntas es intentar hacer coincidir los bordes y las esquinas de la imagen para que encajen sin costuras. Si no se hace esto, todo lo que se obtiene es un conjunto de cajas cuadradas, cada una con una copia repetida de la imagen. No es una tarea fácil y puede ser una experiencia muy frustrante y desesperante. Un objeto que aparece en un borde del mosaico debe volver a aparecer en el otro lado de la imagen para reconstruir el conjunto cuando la imagen se dispone en mosaico. Aunque esto se puede hacer con bastante facilidad con imágenes generadas por ordenador, es casi imposible producir una buena imagen de mosaico con fotografías del mundo real. El otro problema importante es intentar que el mosaico no parezca que se repite. La única solución verdadera a esto es hacer las imágenes de mosaico lo bastante grandes para que contengan suficientes elementos muy similares, pero aún diferentes, de modo que sea difícil ver un patrón repetido. Por esta razón, generar mosaicos pequeños que no parezcan repetirse es especialmente difícil.

FUTURE:  Ideas and suggestions for generating tile patterns?  Anyone?

Or roll, add element, roll, add element, etc...

Any and all suggestions and examples accepted.

Suggestions for generating tile from real photos of repeating patterns,
such as water, fallen leaves, clouds, stucco, brickwork, etc...

Generating Escher-like tile patterns.

Mosaico de ruido aleatorio

Dado que un lienzo de ruido aleatorio puro no tiene características de borde de partida (el color de cada píxel es completamente independiente del de cualquiera de sus vecinos), se puede disponer en mosaico sin preocuparse por las distorsiones de borde. Básicamente, es tan extremadamente aleatorio a nivel de píxel que ningún borde coincide de entrada, así que no se pierde nada al disponerlo en mosaico. Desafortunadamente, muy pocas situaciones usarían una imagen de ruido aleatorio puro, tal cual, para algún propósito real. Es simplemente tan horriblemente aleatoria que resulta inútil. Sin embargo, al modificar la imagen preservando su capacidad de mosaico inherente, se puede crear prácticamente cualquier patrón de mosaico aleatorizado que se desee. Por ejemplo, veamos un "[-blur](https://imagemagick.org/command-line-options/#blur)" básico del mosaico original, usando la misma técnica de 'modificación de un mosaico' que se usó en el ejemplo anterior. |

  magick -size 64x64 xc: +noise Random \
          -virtual-pixel tile -blur 0x6 -auto-level  tile_random.jpg

  magick -size 128x128   tile:tile_random.jpg   tiled_random.jpg

Usando esta técnica se puede aplicar prácticamente cualquier transformación a una imagen de ruido aleatorio puro. Por ejemplo... |

  magick -size 64x64 xc: +noise Random \
          -virtual-pixel tile  -blur 0x6  -edge 1  -fx G \
          -shade 280x45  -auto-level  tile_random_pits.jpg

  magick -size 128x128 tile:tile_random_pits.jpg tiled_random_pits.jpg

Como puede verse, es mucho más sencillo crear mosaicos aleatorizados usando la imagen de ruido aleatorio puro, y no se tendrán distorsiones de borde en los resultados. Esta transformación de imagen en particular figura en la página Imágenes de fondo y se titula "pits". Véase esa página para muchas otras transformaciones de imagen aleatorias y ejemplos de su aspecto.

Mosaico hexagonal

En lugar de disponer en mosaico de forma cuadrada, la imagen de 'ruido aleatorio' permite generar un tipo de mosaico muy diferente. Al duplicar las dimensiones de la imagen y volver a colocar el mosaico en el espacio adicional, pero desplazado a la mitad, se puede generar un patrón básico de mosaico hexagonal de ruido aleatorio. Este es el mismo tipo de efecto de mosaico que se obtiene al disponer en mosaico el patrón especial integrado "pattern:hexagons" de ImageMagick. |

  magick pattern:hexagons  tile_hexagons.gif

  magick -size 64x64  pattern:hexagons  tiled_hexagons.gif

Nótese, sin embargo, que para que este mosaico parezca 'hexagonal' no puede ser un cuadrado normal, ni siquiera un cuadrado duplicado. El tamaño final del mosaico debe ser un rectángulo. La proporción exacta de este rectángulo implica en realidad números irracionales, lo que no es muy adecuado para el trabajo de imagen con una matriz de píxeles. Sin embargo, una buena proporción de trabajo es 4:3, que es la que usan la mayoría de las imágenes de ordenador y de cámara digital. Aquí se superpone la misma imagen de 'ruido aleatorio' (un rectángulo con proporción 2:3) dos veces adicionales para generar el patrón básico de hexágonos (en un rectángulo 4:3). El mosaico de ruido aleatorio dispuesto en hexágonos se transforma luego usando la transformación "paint_3s" de la página Imágenes de fondo, para generar un patrón de mosaico hexagonal de aspecto bastante agradable. |

  magick -size 48x64 xc: +noise Random  -write mpr:rand \
          -extent 96x64  -page +48-32 mpr:rand  -page +48+32 mpr:rand \
          -flatten          tile_hex_random.jpg

  magick tile_hex_random.jpg -virtual-pixel tile -blur 0x10 -paint 3 \
          -shade 280x45 -auto-level  tile_hex_layered.jpg

  magick -size 160x160  tile:tile_hex_layered.jpg  tiled_hex_layered.jpg

Si se observa el patrón que produce el mosaico, se verá que cualquier característica específica tendrá 6 copias de esa misma característica rodeándola en un círculo. Este es el patrón 'hexagonal' que produce el mosaico, aunque siga estando dispuesto en el mismo patrón 'cuadrado' que todas las demás imágenes de mosaico. Una variante del patrón 'hextile' anterior consiste en duplicar la imagen del mosaico verticalmente, en lugar de horizontalmente como se ha hecho arriba. El resultado es que el patrón hexagonal quedará rotado noventa grados. Sigue siendo, no obstante, el mismo tipo de patrón. | _Matemáticamente, lo anterior no genera un nuevoWallpaper Group a partir de un mosaico existente. Tanto la imagen original 'no hexagonal' como la versión final pertenecen al mismo grupo de mosaico 'p1 '.

Lo que realmente se hace en lo anterior es convertir un patrón de mosaico con 'prototeselado' romboidal en un 'dominio fundamental' rectangular más grande, alineado ortogonalmente, del mismo patrón de mosaico. De esta manera se puede luego disponer la imagen en mosaico usando un método de mosaico estándar.
---|---
_Futuro: voltear la imagen adicional para generar un patrón de mosaico mayor (grupo de mosaico pmg). Futuro: cómo recortar (enmascarar) un hexágono de una imagen para que forme mosaico perfectamente, sin huecos ni solapamientos.

Mosaico hexagonal triple

Igual que se hizo al colorear el patrón integrado "hexagons" (véase Modificación de patrones/mosaicos integrados de IM más arriba), se pueden crear tres variantes diferentes del mosaico inicial (con rotaciones, por ejemplo) antes de reasignarlas para formar el mosaico mayor. Por supuesto, igual que se hizo al colorear el patrón "hexagons", la imagen final del mosaico deberá ampliarse al triple de tamaño, a fin de generar un patrón de mosaico rectangular repetido. Las variaciones entre los tres mosaicos generados no deben ser demasiado diferentes y deben sobrevivir a cualquier posprocesamiento, de lo contrario no se obtendrán los beneficios de la técnica. Esto significa que el mosaico inicial también debe ser razonablemente grande, para que se preserven las características distintivas presentes. Por ejemplo, aquí se toma un dibujo de líneas muy simple y se rota para producir 3 variaciones similares. Estas imágenes rotadas se disponen luego siete veces en mosaico sobre un lienzo mayor (6 veces más grande) para producir el patrón hexagonal de imagen triple. |

  magick -size 24x24 xc: -draw "rectangle 3,11 20,12" tile_line.gif

  magick tile_line.gif -gravity center \
    \( +clone -rotate    0 -crop 24x18+0+0 -write mpr:r1 +delete \) \
    \( +clone -rotate  120 -crop 24x18+0+0 -write mpr:r2 +delete \) \
              -rotate -120 -crop 24x18+0+0 -write mpr:r3 +repage \
              -extent 72x36 \( -page  +0+0 mpr:r3 \) \
    \( -page +24+0  mpr:r1 \) \( -page +48+0  mpr:r2 \) \
    \( -page -12+18 mpr:r1 \) \( -page +12+18 mpr:r2 \) \
    \( -page +36+18 mpr:r3 \) \( -page +60+18 mpr:r1 \) \
    -flatten tile_hex_lines.jpg

  magick -size 120x120  tile:tile_hex_lines.jpg  tiled_hex_lines.jpg

Sin embargo, lo anterior solo funciona para disponer en mosaico una forma pequeña en el centro de la imagen original. No funciona bien para una imagen general. Para un mosaico hexagonal de imagen general también es necesario enmascarar triángulos equiláteros. Las piezas se rotan entonces de modo que los bordes del triángulo equilátero queden reflejados. No es una tarea fácil.

Mosaico de espejo diagonal

Aquí hay una forma de tomar cualquier imagen cuadrada y, con magick, convertirla en 8 imágenes reflejadas alrededor de un punto central. En concreto, se genera un patrón de mosaico complejo 'p4m '. Primero se genera una imagen de tono aleatorio y, usando la mitad inferior izquierda de la imagen de origen, se refleja en diagonal, luego horizontal y verticalmente. |

  magick -size 50x50 xc: +noise Random -virtual-pixel Tile -blur 0x5 \
          -auto-level -separate -background white \
          -compose ModulusAdd -flatten -channel R -combine +channel \
          -set colorspace HSB -colorspace RGB   tile_diag_source.jpg

  magick tile_diag_source.jpg     \( +clone -transpose \) \
          \( +clone -sparse-color voronoi '%w,0 white 0,%h black' \) \
          -composite \
          \( +clone -flop -chop 1x0 \) +append \
          \( +clone -flip -chop 0x1 \) -append \
          tile_diag_mirror.jpg

El espejo diagonal se genera realizando un Transpose y usando luego una máscara generada con un Voronoi, color disperso. Nótese que este espejo diagonal comparte automáticamente una línea de píxeles a través del espejo de la misma manera, debido a la geometría de píxeles del cuadrado. También se elimina un conjunto de píxeles a lo largo del borde antes de crear los Flips y Flops verticales y horizontales. Se recomienda además eliminar otra fila y columna de píxeles a lo largo del borde superior e izquierdo, antes de usar esta imagen como 'mosaico'. No es necesario hacerlo, pero creo que se ve mejor. Sin eliminar una fila y columna de píxeles del borde, se obtienen feas 'costuras' de píxeles duplicados, donde las imágenes se unen. Una alternativa es disponer en mosaico primero la imagen aleatoria pura y luego hacer la conversión a patrón de fondo; así es menos probable obtener un 'aspecto recortado' a lo largo de las líneas del espejo, sino una transición más suave. |

  magick -size 51x51 xc: +noise Random   \( +clone -transpose \) \
          \( +clone -sparse-color voronoi '%w,0 white 0,%h black' \) \
          -composite \
          \( +clone -flop -chop 1x0 \) +append \
          \( +clone -flip -chop 0x1 \) -append \
          -chop 1x1 \
          \
          -virtual-pixel Tile -blur 0x5 -auto-level \
          -separate -background white \
          -compose ModulusAdd -flatten -channel R -combine +channel \
          -set colorspace HSB -colorspace RGB    tile_p4m.jpg

La primera parte es la generación del 'mosaico de los datos aleatorios'; en la segunda mitad se convierten con magick los datos aleatorios en una asignación de 'tonos'. También se añadió el píxel adicional a la imagen inicial, que más tarde se recortará según convenga para generar una imagen de mosaico.
Para una introducción más completa a las imágenes de mosaico y las matemáticas que hay tras ellas, véase Wikipedia: Wallpaper Group. Lo que se ha explorado arriba es solo unos pocos de los muchos patrones de mosaico que se pueden crear.
El 'p4g ' es casi exactamente igual que el mosaico 'p4m ' anterior, pero usa rotaciones de 180 grados de los cuadrados reflejados, en lugar de usar volteos, para generar la imagen de mosaico completa. Sin embargo, como las imágenes no se unen mediante espejos, no se puede usar una imagen existente como fuente del mosaico, ya que los bordes quedarán inconexos y discontinuos. No obstante, se pueden disponer en mosaico los datos aleatorios puros y luego procesar la imagen de mosaico resultante, para producir un resultado suave. |

  magick -size 50x50 xc: +noise Random   \( +clone -transpose \) \
          \( +clone -sparse-color voronoi '%w,0 white 0,%h black' \) \
          -composite \
          \( +clone -rotate -90 \) +append \
          \( +clone -rotate 180 \) -append \
          \
          -virtual-pixel Tile -blur 0x5 -auto-level \
          -separate -background white \
          -compose ModulusAdd -flatten -channel R -combine +channel \
          -set colorspace HSB -colorspace RGB    tile_p4g.jpg

Nótese que, debido a la naturaleza no especular del mosaico, no es necesario eliminar la fila o columna de píxeles duplicados de los bordes antes de hacer el append. Aunque no perjudica hacerlo, si se desea seguir el mismo tipo de proceso en ambos casos.