Ejemplos de ImageMagick -- Creación de miniaturas y enmarcado

Ejemplos de ImageMagick: prefacio e índice

Almacenamiento de las miniaturas

Elección del formato de imagen
Perfiles e imágenes JPEG

Creación de miniaturas en general

Miniaturas de altura específica
Redimensionar la miniatura para que ajuste
Rellenar la miniatura
Recortar la miniatura para que ajuste
Tamaño de miniatura por ajuste de área
Resumen del ajuste a un espacio dado
Relleno o recorte cuadrado
Recorte manual
Páginas HTML de miniaturas
Miniatura de enlace de página web (FavIcon)

Otras técnicas ajenas a IM |

Añadir adornos

Añadir etiquetas a la imagen
Botón en relieve
Botón burbuja
Añadir bordes
Marco simple
Enmarcado con montage
Bordes suaves y difuminados
Esquinas redondeadas y con formas
Borde de papel rasgado
Añadir una sombra
Añadir algo de grosor
Miniaturas estilo polaroid

Técnicas de enmarcado

Autoenmarcado (externo)
Autoenmarcado (interno)
Superposición de borde simple
Insignia con superposición
Técnica de máscara y pintura
Borde redondeado
Insignia con máscara y pintura
Técnica de pintura y máscara
Esquinas con vuelta de página
Superposición de esquina elaborada
Insignia con pintura y máscara
Técnica de máscara de iluminación
Burbuja de cristal
Insignia con máscara de iluminación

Enmarcado con imágenes de borde

Concatenación demasiado simplista
Enmarcado por superposición extendida
Uniones de esquina a 45 grados

Uno de los mayores usos que se le da a ImageMagick es la creación de miniaturas para álbumes de fotos familiares, páginas de deportes y aficiones, catálogos, etc. Normalmente para usarse en la World Wide Web o en CD de fotos. Esta página ofrece ejemplos y técnicas para generar miniaturas.

Almacenamiento de las miniaturas

Me gustaría empezar por un punto muy importante. La imagen original procedente de videocámaras y del escaneo de fotos debería conservarse en un lugar seguro en su formato original, preferiblemente un formato sin pérdidas (no el formato de imagen JPEG), sin ninguna modificación, redimensionado ni otro cambio, salvo quizá un cambio de nombre de archivo. Por supuesto, una imagen escaneada puede volver a escanearse, pero es mucho mejor reutilizar el original que rehacerlo más tarde a partir de una copia ya degradada. Esto es MUY importante, ya que cualquier forma de modificación supondrá la pérdida de parte de la información de la imagen, y además ofrece una fuente a partir de la cual reelaborar la imagen para otros usos. La imagen original no tiene por qué ser tu imagen de trabajo, que quizá esté redimensionada o ajustada de color para mostrarse; solo asegúrate de tener la imagen guardada y respaldada en algún lugar seguro para usos futuros. Lo siguiente que hay que hacer, incluso antes de crear ninguna miniatura, es decidir cómo quieres guardar la miniatura en relación con el formato de tu imagen de tamaño normal, y luego ceñirte a ese esquema. Esto es especialmente importante para las páginas web. Entre los esquemas están...

Guardar la imagen principal de la foto en el formato JPEG con pérdidas, al tamaño que quieras o necesites, y luego usar el mismo nombre para la miniatura generada pero con el formato de imagen GIF. Es decir, el mismo nombre de archivo pero con formato y sufijo distintos. Imagen principal: photo_name.jpg Miniatura: photo_name.gif
Guardar las miniaturas con el mismo nombre en un subdirectorio llamado, por ejemplo, «thumbs» o como te resulte cómodo. Imagen principal: photo_name.jpg Miniatura: thumbs/photo_name.jpg
Usar el mismo formato que la imagen original, pero añadiendo una cadena extra al nombre del archivo. Las cadenas que suelen añadirse son «_tn», «_small», «_thumb», etc. Imagen principal: photo_name.jpg Miniatura: photo_name_tn.jpg
Alguna combinación de lo anterior. ¡No hay razón por la que no puedas guardar las miniaturas en un formato de imagen distinto, con un sufijo extra añadido al nombre del archivo y guardadas en un subdirectorio! Imagen principal: images/photo_name.jpg Miniatura: thumbs/photo_name.jpg.gif Esto es en realidad bastante habitual en la WWW, ¡e incluso he visto los dos directorios almacenados en máquinas completamente distintas!

El primer esquema puede usar «magick mogrify» para generar todas tus miniaturas, sin destruir la imagen original, mediante un ajuste «[-format](https://imagemagick.org/command-line-options/#format)» que especifica el formato de imagen de salida. A partir de IM v3.2.0, el segundo esquema también es posible con «magick mogrify» gracias a la incorporación de un ajuste especial «[-path](https://imagemagick.org/command-line-options/#path)» que indica un directorio distinto en el que guardar las imágenes modificadas. Por ejemplo, esto convierte imágenes JPG en miniaturas GIF dentro de un subdirectorio «thumbs» que se acaba de crear.

  mkdir thumbs
  magick mogrify  -format gif -path thumbs -thumbnail 100x100 *.jpg

Los demás métodos requieren que, o bien hagas primero una copia de la imagen original antes de ejecutar «magick mogrify», crees un script especial para procesar las imágenes, o algún otro método casero. Varias de las técnicas ajenas a IM más sencillas se detallan al final de la sección de ejemplos sobre Procesamiento por lotes sin usar «magick mogrify». Sea cual sea el método que elijas, lo importante es elegir un esquema de almacenamiento de miniaturas y luego ceñirte a él. Al usar el mismo esquema para todas tus miniaturas, podrás escribir scripts de shell o Perl que faciliten la generación de miniaturas e incluso la generación de los enlaces HTML. Más sobre esto después.

Selección del formato de la miniatura

El formato en el que guardas una miniatura puede suponer una gran diferencia en su tamaño final en disco y en la velocidad de descarga de las páginas web. En este sentido, te recomiendo que estudies el resumen de los distintos formatos de archivo comunes. En concreto, conviene fijarse en lo siguiente...

**JPEG** comprime bien y tiene pérdidas, pero está diseñado para imágenes grandes del mundo real, no para miniaturas pequeñas. Además, NO admite ninguna forma de transparencia. En resumen, el formato es bueno para imágenes grandes y malo para miniaturas. Cuidado con los perfiles (véase la sección siguiente). Aunque no se recomienda JPG para miniaturas, para visualizar imágenes en la WWW se recomienda usar una imagen más pequeña de 800x600 píxeles, con un porcentaje de «`[-quality](https://imagemagick.org/command-line-options/#quality)`» mucho menor (digamos 50 o incluso 30%), aunque no se verá muy bien. También se ha sugerido que usar «`[-sampling-factor](https://imagemagick.org/command-line-options/#sampling-factor) 2x1`» produce además un tamaño de imagen JPEG menor. No recomiendo que la imagen original completa se coloque nunca directamente en la web, salvo de forma temporal (en una ubicación referenciada) para que un amigo la descargue. Recuerda no enlazarla (ni siquiera mediante la indexación de directorios) y nunca durante más de un día, o podría acabar en Google.
 **GIF** funciona para imágenes pequeñas y sencillas, y comprime aceptablemente. Tiene un límite de 256 colores, pero en imágenes pequeñas rara vez se nota. También puede hacer animaciones tipo dibujo animado de las imágenes, aunque eso no hace falta para las miniaturas, salvo que de verdad quieras complicarte. Lo que sí es un problema es que el formato solo tiene transparencia booleana (activada/desactivada), lo que da un aspecto horrible a los bordes de las imágenes con formas. Las soluciones a eso son diseñar la miniatura para que use solo transparencia booleana, o disponerla de modo que solo pueda usarse sobre un color de fondo concreto. Para más detalles, consulta los ejemplos sobre [GIF sobre un color o patrón de fondo](formats.html#bgnd). 
 **PNG** es el formato ideal y moderno para las miniaturas. Tiene buena compresión y estilos de formato internos. No tiene pérdidas, puede mostrar todos los colores y, hoy en día, lo entienden casi todos los navegadores (aunque para Microsoft Internet Explorer, antes de la v7, hace falta añadir algo de JavaScript a las páginas web). Lo más importante es que este formato entiende el color semitransparente, lo que permite que las sombras y los bordes sean nítidos y claros, o difuminados y borrosos, según prefieras. Sin embargo, este formato no admite animaciones, aunque el formato relacionado MNG sí. Con todo, parece que muy pocos navegadores admiten ese formato. Para las miniaturas puedes reducir el tamaño de la imagen final reduciendo la profundidad y el número de colores, así como estableciendo una mayor calidad de compresión «`bzip`» (el primer dígito de «`[-quality](https://imagemagick.org/command-line-options/#quality)`») para tu imagen de miniatura final. Por ejemplo, para miniaturas PNG pequeñas que no impliquen transparencia se sugiere lo siguiente.


        -strip  -quality 95  PNG8:thumbnail.png

Lo cual usa un formato PNG más pequeño, de 8 bits, es decir, limitado a 256 colores. También puedes reprocesar la imagen final con aplicaciones secundarias (véase Procesamiento PNG ajeno a IM), que pueden encontrar automáticamente la mejor compresión PNG para esa imagen concreta. También hay programas que hacen esa reducción de color al formato PNG interno más pequeño conservando los colores semitransparentes. Esto es algo que IM actualmente no maneja. . Una última palabra sobre los formatos... Sea cual sea el formato que uses para tus miniaturas, si tienes que guardar una imagen intermedia sin terminar, usa PNG (sin ninguna reducción de color) o el formato de imagen MIFF. Hacer esto conservará la mayor cantidad posible de información de color de la imagen en la etapa intermedia. Haz la reducción de color, o guarda en formato GIF o JPEG, solo como paso absolutamente final. Esto es importante, así que lo repito...

¡NO uses JPEG, PNG8 ni GIF para las imágenes de trabajo intermedias!
Es mejor usar PNG o MIFF.

Perfiles, eliminación y manejo de JPEG

Muchas imágenes procedentes de cámaras digitales, software de escaneo y algunos programas de pintura (Photoshop es famoso por esto) guardan información extra sobre la imagen en forma de perfiles. Esto incluye formatos de imagen como JPEG, PNG, TIFF y, a partir de IM v6.2.4-1, GIF. Por supuesto, el formato propio de IM, MIFF, también lo hace. (Véase Perfiles de imagen para información más detallada). Estos perfiles pueden llegar a ocupar 60 Kb, así que pueden suponer una gran diferencia en el tamaño de tu archivo y, por defecto, IM conservará esta información de perfil. Las miniaturas no necesitan estos datos, y a menudo ni siquiera la imagen principal los necesita. También puedes eliminar los perfiles de tus imágenes con los comandos de IM...

  magick input.jpg  -strip output.jpg

  magick mogrify -strip  *.jpg

También puedes usar la opción «[-profile](https://imagemagick.org/command-line-options/#profile) '*'» para eliminar los perfiles. No obstante, se recomienda que solo elimines los perfiles cuando modifiques una imagen, sobre todo si reduces su tamaño para mostrarla en la web o como miniatura. Eliminar perfiles al redimensionar, en particular al generar imágenes de miniatura más pequeñas, es tan habitual que tanto «[-resize](https://imagemagick.org/command-line-options/#resize)» como «[-strip](https://imagemagick.org/command-line-options/#strip)» se combinaron en una nueva operación, precisamente con este fin. Como es lógico, esta operación de redimensionado se llama «[-thumbnail](https://imagemagick.org/command-line-options/#thumbnail)». Por ejemplo...

  magick -define jpeg:size=240x180 image.jpg -thumbnail 120x90 thumbs/image.gif

  magick mogrify -path thumbs -format gif -define jpeg:size=240x180 -thumbnail 120x90 '*.jpg'

| Antes de IM v6.5.4-7, «[-thumbnail](https://imagemagick.org/command-line-options/#thumbnail)» eliminaba TODOS los perfiles de la imagen, incluidos los perfiles de color ICC. A partir de esta versión, los perfiles de color se conservan. Si no quieres el perfil de color, elimina todos los perfiles con «[-strip](https://imagemagick.org/command-line-options/#strip)».
---|---
El «[magick mogrify](basics.html#mogrify)» generará, por supuesto, miniaturas de todo un directorio de imágenes JPEG, pero ten cuidado de que no sobrescriba ninguna miniatura que quieras conservar. Para varios otros métodos ajenos a IM con los que recorrer un gran número de imágenes, consulta la sección de ejemplos sobre Procesamiento por lotes sin usar Mogrify. Para imágenes muy grandes, el operador de redimensionado «[-thumbnail](https://imagemagick.org/command-line-options/#thumbnail)» va más allá y primero reduce la imagen a 5 veces el tamaño final de la miniatura, antes de hacer la operación de redimensionado propiamente dicha. Esto acelera aún más la generación de miniaturas. Sin embargo, para miniaturizar imágenes JPEG puede usarse un método aún mejor para limitar el tamaño inicial de la imagen: simplemente no leer toda la imagen en memoria desde el principio. El ajuste «[-define](https://imagemagick.org/command-line-options/#define) jpeg:size=» (como se muestra en el ejemplo anterior) es una indicación especial para la biblioteca de imágenes JPEG que reduce la cantidad de datos que se leen de imágenes JPEG MUY GRANDES. Véase Lectura de archivos JPEG. | _Antes de IM v6.5.6-0, este ajuste de codificador se extraía del ajuste «[-size](https://imagemagick.org/command-line-options/#size)». Esto causaba problemas cuando los usuarios usaban «[-size](https://imagemagick.org/command-line-options/#size)» para la creación de imágenes pero luego la lectura JPEG producía resultados inesperados. Por eso se cambió para que fuera un ajuste de codificador especial.

En versiones más antiguas de IM puede que necesites restablecer el ajuste con «[+size](https://imagemagick.org/command-line-options/#size)» antes de leer imágenes JPEG, debido a este doble papel._
---|---
A partir de la versión 6.2.6-2 de IM se añadió un nuevo modificador de lectura de imagen que permite redimensionar la imagen de entrada inmediatamente después de leerla. Esta opción funciona con CUALQUIER formato de imagen, no solo con JPEG. No obstante, no sustituye al uso de un ajuste «[-define](https://imagemagick.org/command-line-options/#define) jpeg:size=» para imágenes JPEG. Por eso, la forma recomendada de redimensionar CUALQUIER formato de imagen de entrada es ahora la siguiente...

  magick -define jpeg:size=240x180 input.img'[120x90]' \
          -strip  output_thumbnail.gif

Bueno, sigamos con los ejemplos prácticos de miniaturas en IM...

Creación de miniaturas en general

Generar miniaturas en general (altura específica)

Vamos a convertir con magick una imagen JPEG de muestra grande en una miniatura GIF de 90 píxeles de alto, con el ancho ajustado automáticamente (dentro del límite de 250 píxeles de ancho) para conservar la relación de aspecto de la imagen. |

  magick -define jpeg:size=500x180  hatching_orig.jpg  -auto-orient \
          -thumbnail 250x90   -unsharp 0x.5  thumbnail.gif

Observa que arriba usé la opción «[-thumbnail](https://imagemagick.org/command-line-options/#thumbnail)». Esto no solo redimensiona la imagen, sino que también elimina todos los perfiles y la información de comentarios que pudiera haber en la imagen JPEG original. Además, como usa el operador de redimensionado «[-sample](https://imagemagick.org/command-line-options/#sample)» para la reducción inicial de la imagen, es más rápida, a la vez que produce resultados razonables para miniaturas pequeñas. También fijé un «[-define](https://imagemagick.org/command-line-options/#define) jpeg:size=» mínimo para la imagen que se lee. Esto se le pasa a la biblioteca JPEG, que devolverá una imagen de un tamaño entre este valor y el doble (si es posible), en lugar de la enorme imagen original completa. Básicamente, no desbordes la memoria del ordenador con una imagen enorme cuando no hace falta. La indicación de tamaño JPEG que uso es al menos el doble que la de la miniatura final, para que el redimensionado siga generando un resultado de aspecto razonable. El operador «[-auto-orient](https://imagemagick.org/command-line-options/#auto-orient)» garantiza que la imagen, si procede de una cámara digital, se rote correctamente según la orientación de la cámara. Esto no hace falta para la imagen de «escritorio» que estoy usando, pero la incluí arriba para los usuarios de cámaras digitales. No obstante, la orientación todavía puede salir mal, sobre todo en fotos tomadas justo hacia abajo o hacia arriba, como al fotografiar documentos. El resultado es una miniatura de altura específica, pero de ancho variable. Yo uso esta miniatura en mis propias páginas web para que una serie de imágenes en una fila queden todas alineadas en altura, dando un aspecto ordenado. El límite de 250 píxeles de ancho de arriba es importante. Si se deja sin establecer (p. ej., usando «-thumbnail x90»), IM podría tener problemas al generar miniaturas de imágenes muy largas y estrechas, como las que se muestran en Imágenes de línea para web. En ese caso, el resultado sería una ampliación muy muy larga de la imagen, en lugar de una miniatura pequeña. Algunas personas (yo incluido) consideran que, aunque el redimensionado de IM es una de las mejores implementaciones (véase Redimensionado de IM frente a otros programas), el resultado sigue siendo un poco borroso. Por eso puedes mejorar el resultado anterior afilando ligeramente la imagen (con «[-unsharp](https://imagemagick.org/command-line-options/#auto-orient)») después de la operación de redimensionado «[-thumbnail](https://imagemagick.org/command-line-options/#thumbnail)». Para más información, véase Afilar imágenes redimensionadas: técnica de redimensionado de Photoshop. Pero, en realidad, todo se reduce a una cuestión de gusto personal.
La versión con «magick mogrify» es igual que el comando «magick» (sin imágenes de entrada iniciales), pero generará miniaturas automáticas de cada imagen JPEG del directorio actual. El argumento de imagen va entrecomillado para que sea el propio IM, y no el shell de la línea de comandos, quien recorra el directorio. Esto evita los «errores de desbordamiento del límite de longitud de línea» en directorios que contienen un número enorme de imágenes.

  magick mogrify  -format gif -define jpeg:size=500x180 -auto-orient \
                -thumbnail 250x90 -unsharp 0x.5  '*.jpg'

| _Ten en cuenta que «magick mogrify» creará las miniaturas a ciegas, reemplazando cualquier imagen existente con el mismo nombre. En este caso, imágenes GIF. Se aconseja siempre extremar la precaución al usar este comando.

Siempre se recomienda hacer copias de seguridad antes de cualquier procesamiento.
---|---
| _En lugar de especificar un formato distinto (con «[-format](https://imagemagick.org/command-line-options/#format)») para impedir que «magick mogrify» sobrescriba las imágenes de origen originales, puedes usar un ajuste «[-path](https://imagemagick.org/command-line-options/#path)» para definir un directorio de miniaturas aparte. Puedes usar ambas opciones de salida.
---|---
Aunque «magick mogrify» puede generar las imágenes nuevas con un sufijo distinto («[-format](https://imagemagick.org/command-line-options/#format)») o en un directorio distinto («[-path](https://imagemagick.org/command-line-options/#path)»), esas son tus únicas opciones con este comando. Si además quieres cambiar el nombre de la imagen, por ejemplo añadiendo «_tn» o «_sm» para indicar versiones miniatura o pequeñas de la imagen, te recomiendo que crees un script de shell que haga el trabajo por ti, procesándolas de una en una con «magick». Yo escribí un script así que hacía esto a la vez que generaba índices HTML simultáneamente.

Redimensionar la miniatura para que ajuste

Otra forma de generación automática de miniaturas es encoger la imagen para que quepa en una caja de tamaño fijo, digamos «100x100», pero conservando su relación de aspecto. Bueno, ese es el significado por defecto de un ajuste de geometría de redimensionado. Sin embargo, yo prefiero no ampliar las imágenes que ya caben en esa caja. Para eso hay que añadir un «>» a la cadena de geometría. |

  magick -define jpeg:size=200x200 hatching_orig.jpg \
          -thumbnail '100x100>' rectangle.gif

Como antes, la relación de aspecto de la imagen se conserva, por lo que es poco probable que la miniatura sea exactamente de 100 píxeles cuadrados. No obstante, al menos una de las dimensiones de la imagen será de 100 píxeles.

Rellenar la miniatura

La siguiente petición más habitual es generar miniaturas que rellenen la imagen con bordes de un color concreto (normalmente «black» o «transparent», pero en estos ejemplos usaré «skyblue») para que la miniatura tenga exactamente el tamaño que querías. Por ejemplo: una imagen de 400x300 píxeles, encogida para caber en una caja de 100x100 píxeles, normalmente (con el método anterior) tendrá un tamaño de 100x75 píxeles. Queremos añadir algo de relleno arriba y abajo de la imagen (y a los lados, por si acaso) para que la miniatura final tenga siempre exactamente 100x100 píxeles. Hay varias maneras de hacerlo y, a partir de IM v6.3.2, la mejor es usar el operador Extent. |

  magick -define jpeg:size=200x200 hatching_orig.jpg -thumbnail '100x100>' \
          -background skyblue -gravity center -extent 100x100 pad_extent.gif

A partir de la versión 6.2.5 de IM, también puedes usar un recorte de ventana gráfica (viewport) y aplanar el resultado sobre un color de fondo. |

  magick -define jpeg:size=200x200 hatching_orig.jpg -thumbnail '100x100>' \
          -gravity center  -crop 120x120+0+0\! \
          -background skyblue  -flatten    pad_view.gif

La diferencia clave entre usar Extent y un recorte de ventana gráfica está en si quieres un lienzo virtual mínimo o tener toda el área «rellenada». Otro método para rellenar una imagen es superponer la miniatura sobre una imagen de fondo (una imagen real, un color sólido o un lienzo en mosaico) del tamaño adecuado; en este caso, la imagen integrada «granite:» de 128x128. |

  magick -define jpeg:size=200x200 hatching_orig.jpg -thumbnail '100x100>' \
          granite: +swap -gravity center -composite pad_compose.gif

Este método es probablemente el mejor para versiones antiguas de IM (como IM v5), aunque la operación «[-composite](https://imagemagick.org/command-line-options/#composite)» habría que hacerla con el comando «[composite](basics.html#composite)» aparte, en lugar del método de un solo comando anterior. Pero, desde el punto de vista del procesamiento de imágenes, todo lo anterior hace en realidad lo mismo.

Recortar la miniatura para que ajuste

Una alternativa, en lugar de rellenar la imagen para que encaje en el tamaño de miniatura concreto que queremos, es recortar las partes de la imagen que no caben en el tamaño final. Por supuesto, esto significa que pierdes de verdad algunas partes de la imagen original, sobre todo los bordes, pero el resultado es una miniatura ampliada de la parte central de la imagen. Esta suele ser (aunque no siempre) el sujeto principal de la imagen, así que es un método práctico de creación de miniaturas. A partir de IM v6.3.8-3 se añadió la opción especial de redimensionado «^» para facilitar esto. Simplemente redimensionamos con esta opción y luego recortamos las partes de la imagen que sobrepasan el tamaño deseado. |

  magick -define jpeg:size=200x200 hatching_orig.jpg  -thumbnail 100x100^ \
          -gravity center -extent 100x100  cut_to_fit.gif

Como puedes ver, la miniatura de la imagen es mucho más grande y detallada, pero a costa de recortar los lados de la imagen original. Para más información sobre esta opción, véase Redimensionar para llenar un área dada. | Antes de IM v6.3.8-3, cuando se añadió esta opción especial, habrías necesitado trucos muy complejos para lograr el mismo resultado. Para más detalles, véase Redimensionar para llenar un espacio dado.
---|---

Tamaño de miniatura por ajuste de área

Los dos últimos métodos a menudo dejan una imagen muy pequeña con mucho relleno extra, o bien recortan gran parte de la imagen para llenar el espacio por completo. Sin embargo, usando una opción de redimensionado distinta es posible obtener una miniatura intermedia entre estos dos extremos. Por ejemplo, una miniatura de 100x100 píxeles tiene 10.000 píxeles. Pues bien, si le pedimos al redimensionado que ajuste la imagen a un tamaño en torno a esa cantidad de píxeles (usando la opción '@' de redimensionado), obtendrás una imagen que necesitará tanto un poco de relleno como un poco de recorte. Esto maximiza el tamaño de la miniatura resultante sin recortar demasiado. Por ejemplo... |

  magick -define jpeg:size=200x200 hatching_orig.jpg  -thumbnail 10000@ \
          -gravity center -background skyblue -extent 100x100  area_fit.gif

Como puedes ver, la miniatura tiene algo de relleno y la imagen algo de recorte, pero el resultado es probablemente el mejor ajuste posible de la imagen a un espacio de miniatura dado.

Resumen del ajuste a un espacio dado

En resumen, aquí están los resultados de los tres métodos para miniaturizar una imagen a un área de tamaño específico. Los tres métodos usan exactamente el mismo código, con solo un ligero cambio en el argumento/opción de redimensionado usado.
Ajuste con relleno
redimensionar, sin opción |
Ajuste por área
redimensionar, opción '@' |
Recortar para ajustar
redimensionar, opción '^'
---|---|---

Relleno y recorte cuadrado

Los métodos de relleno y recorte anteriores dan por hecho que conoces el tamaño final del área en la que quieres que quepa la imagen. Pero no siempre es así. A veces simplemente quieres «hacer cuadrada una imagen», ya sea «rellenándola» (cuadrado externo) o «recortando» los bordes (cuadrado interno). A partir de los foros de discusión de IM sobre Hacer cuadradas las imágenes se desarrollaron varios métodos. El cuadrado externo puede hacerse usando Mosaic para crear un lienzo de fondo mayor con una copia rotada de la imagen. |

  magick thumbnail.gif \
          \( +clone -rotate 90 +clone -mosaic +level-colors white \) \
          +swap -gravity center -composite    square_padded.gif

El cuadrado interno, en cambio, es algo más difícil y requiere más trabajo. Este usa un manejo de máscaras bastante intenso para generar un lienzo más pequeño. |

  magick thumbnail.gif \
          \( +clone +level-colors white \
             \( +clone -rotate 90 +level-colors black \) \
             -composite -bordercolor white -border 1 -trim +repage \) \
          +swap -compose Src -gravity center -composite \
          square_cropped.gif

Otra forma es usar un distort sin efecto (no-op) que recorta/rellena la imagen mediante una ventana gráfica de distort (véase Recorte cuadrado centrado con ventana gráfica de Distort). En esencia, usa «escapes de porcentaje» para hacer los cálculos necesarios para una operación de tipo Extent. Cuadrado externo (relleno)... |

  magick thumbnail.gif  -virtual-pixel white -set option:distort:viewport \
     "%[fx:max(w,h)]x%[fx:max(w,h)]-%[fx:max((h-w)/2,0)]-%[fx:max((w-h)/2,0)]" \
     -filter point -distort SRT 0  +repage  square_external.gif

El ajuste de píxel virtual se usa para especificar el color de relleno. Cuadrado interno (recortado)... |

  magick thumbnail.gif   -set option:distort:viewport \
     "%[fx:min(w,h)]x%[fx:min(w,h)]+%[fx:max((w-h)/2,0)]+%[fx:max((h-w)/2,0)]" \
     -filter point -distort SRT 0  +repage  square_internal.gif

Cortesía de la página Tidbits de Fred Weinhaus. Esta es una versión más simple, pero perderá cualquier metadato (como cadenas de comentario o perfiles) que pueda tener la imagen. |

  magick thumbnail.gif -set option:size '%[fx:min(w,h)]x%[fx:min(w,h)]' \
          xc:none +swap -gravity center -composite square_internal_2.gif

| IMv7 te permitirá hacer los cálculos anteriores directamente como parte de un argumento de recorte o de extent, lo que evitará la pérdida de metadatos de la imagen.
---|---

Recorte manual

La forma normal en que genero imágenes de miniatura para mis páginas web es una mezcla de scripts automáticos y manuales. La configuración final de mis imágenes es la siguiente.

Uso un PNG o TIFF para el escaneo original, MUY grande, de la foto. O bien la imagen JPEG original descargada de una cámara digital. Básicamente, para la imagen de origen original sin modificar, para archivarla. Además, ahora me gusta incluir la cadena «_orig» en el nombre de archivo de esta imagen.
Un formato de imagen JPEG más pequeño para una imagen visualizable en la web cuando se hace clic en la miniatura o se selecciona. Esta imagen se redimensiona para caber en una caja de 800x800 píxeles, que es un tamaño adecuado para que la vean la mayoría de los usuarios web. Normalmente añado «_md» en el nombre de archivo, para imagen de tamaño medio.
Y por último, una miniatura GIF redimensionada a una altura fija de 90 píxeles y ancho variable. Esto permite que las filas centradas de miniaturas en las páginas web se vean razonablemente ordenadas y limpias, a la vez que llenan automáticamente el ancho de la ventana del navegador, sin importar el tamaño de navegador que usen. De nuevo, ahora normalmente incluyo «_tn» en el nombre de archivo de la imagen, para indicar que es una miniatura.

Primero genero las imágenes JPEG visualizables en la web (de tamaño medio) con «`magick mogrify`» a partir de la imagen escaneada original. Esto reduce el tiempo de descarga y el tamaño de visualización de la imagen a algo práctico para el usuario web típico (que podría estar conectado por módem). A partir de estas imágenes genero un conjunto inicial de miniaturas, de nuevo con «`magick mogrify`». Sin embargo, en las fotos típicas a menudo encuentro que el sujeto de las miniaturas queda demasiado pequeño para ser una miniatura eficaz al verse. Para corregirlo, examino las miniaturas generadas automáticamente y, en aproximadamente la mitad de los casos, creo manualmente mi propia miniatura «con zoom sobre el sujeto». Leo la imagen JPEG y la recorto hasta el sujeto principal, «acercándome» de forma efectiva a él y eliminando la mayor parte del contexto de fondo de la imagen. Luego se suaviza y se miniaturiza, ya sea con «`magick -thumbnail`» o, más a menudo, en el mismo programa gráfico con el que estoy viendo y recortando las imágenes (normalmente «`XV`», véase más abajo). Así, en lugar de una miniatura en la que las personas de la foto apenas se ven (izquierda), tengo una recortada manualmente alrededor del sujeto, que resalta el punto principal de la foto (derecha), antes de miniaturizar. Eso permite a los usuarios ver el contenido de la imagen con más claridad y, por tanto, decidir mejor si realmente quieren descargar y ver la versión JPEG más grande de la imagen. Queensland KiteFlyers, Ron and Val Field

Miniatura
generada
automáticamente | |
Miniatura recortada
manualmente y
redimensionada
(Haz clic en cualquiera de las imágenes para ver la foto escaneada original)
Esto, por supuesto, requiere más trabajo manual, pero solo hay que hacerlo una vez por imagen, y únicamente en imágenes con mucho espacio sobrante, como en el ejemplo anterior. Además, yo solo hago esto para las imágenes que voy a poner en la web. Por supuesto, como «magick mogrify» sobrescribirá cualquier miniatura existente, posiblemente generada a mano, no puedes volver a usarlo después de hacer cualquier generación manual de miniaturas. El comando «magick mogrify» es útil, pero también muy peligroso, porque sobrescribe muchísimas imágenes. Piénsalo siempre bien antes de ejecutar «magick mogrify» globalmente sobre todas tus imágenes.

Páginas HTML de miniaturas

Una vez que tengo todas las imágenes de miniatura organizadas en el directorio, uso un script de Perl especial llamado «thumblinks» que escribí, que busca las imágenes (fotos JPEG y miniaturas GIF) y genera enlaces HTML, e incluso páginas HTML completas de fotos. El script lee e incluye el tamaño de la miniatura GIF en el HTML, y añade alrededor de los enlaces de miniatura unos archivos de cabecera y pie preparados de antemano. El script también eliminará de la lista que genera cualquier enlace de miniatura si encuentra un enlace ya existente en el propio archivo de cabecera o de pie. Esto puede sonar complejo, pero hace que la generación de mis páginas HTML sea muy rápida y flexible, y garantiza que TODAS las imágenes miniaturizadas de un directorio se hayan añadido a la página de índice de ese directorio, a la vez que me permite comentar imágenes concretas en la cabecera del índice. También hace que la página sea independiente del tamaño de la ventana del usuario, ajustándose automáticamente. Para ver un ejemplo sencillo de la salida de mi script «thumblinks», consulta Tomb of Castle Artworks. Para un ejemplo rápido y un punto de partida para generar tales enlaces, mira los ejemplos del uso del comando identify.

Miniatura de enlace de página web (FavIcon)

El icono «favion.ico» es el que los navegadores web suelen buscar en la página de nivel superior de un sitio web, para todo el sitio. Esa imagen es un formato de imagen especial de múltiples resoluciones y puede crearse como sigue.

  magick image.png -alpha off -resize 256x256 \
          -define icon:auto-resize="256,128,96,64,48,32,16" \
          favicon.ico

La «image.png» puede ser lo que quieras, pero debería ser cuadrada. Si no lo es, ese debería ser también el primer paso de lo anterior. Puedes incluir resoluciones mayores, como 128 o 256 píxeles, pero pocos navegadores las usarían. Los tamaños de 16 y 32 píxeles se usan mucho más en estos archivos ICO, así que poner especial énfasis en ellos puede ser útil. Recuerda también que muchos navegadores reducirán el color de las imágenes para disminuir el espacio que ocupan al guardarlas en el archivo de marcadores del usuario. Esto nos lleva a otro punto. Como por lo general solo se usan las imágenes más pequeñas, con una reducción de color adicional, se recomienda mantener las imágenes lo más pequeñas y bien definidas posible. Aquí tienes un ejemplo de redimensionado manual de imágenes para un formato de archivo ICO.

  magick image.png  -background white \
          \( -clone 0 -resize 16x16 -extent 16x16 \) \
          \( -clone 0 -resize 32x32 -extent 32x32 \) \
          \( -clone 0 -resize 48x48 -extent 48x48 \) \
          \( -clone 0 -resize 64x64 -extent 64x64 \) \
          -delete 0 -alpha off -colors 256 favicon.ico

Como ya se ha dicho, por lo general solo se usa la imagen «favion.ico» que se encuentra en el directorio de nivel superior de un sitio web; no obstante, también puedes especificar la ubicación de la imagen de miniatura de enlace añadiendo la siguiente etiqueta HTML a las cabeceras de tus páginas...

  <LINK REL="icon" HREF="/path/to/favicon.ico" type="image/x-icon">
  <LINK REL="shortcut" HREF="/path/to/favicon.ico" type="image/x-icon">

El «/path/to/favicon.ico» puede ser una URL/URI absoluta o parcial a la ubicación de la que el navegador debe tomar la imagen de miniatura de la página web. El uso de «REL="shortcut"» es específico de Internet Explorer (antes de IE9) y no forma parte oficial de la especificación HTML. Es posible fusionar las dos etiquetas HTML en una con «REL="shortcut icon"», pero, al mantener las etiquetas separadas, puedes usar un formato de archivo de imagen distinto de ICO (como SVG) para navegadores que no sean IE, como Firefox. Recuerda que, si no se usa este elemento html, se usa en su lugar el archivo «favicon.ico» que se encuentra en el directorio de nivel superior del sitio web (si lo hay). El formato de imagen ICO lo entienden de forma universal todos los navegadores modernos. Todos, salvo Internet Explorer, pueden usar también los formatos de archivo de imagen JPEG, PNG y GIF para la miniatura de enlace. Unos pocos, como Firefox, pueden usar incluso GIF animados o el formato de archivo de imagen SVG. Sin embargo, como estos últimos formatos normalmente no pueden contener varias imágenes a distintas resoluciones y números de colores, probablemente sea más seguro seguir usando el formato de archivo ICO para la imagen «favion.ico».

Otras técnicas ajenas a IM

El programa «XV» que uso para el procesamiento manual de imágenes también genera imágenes de miniatura, en un subdirectorio llamado «.xvpics». El formato de las imágenes de este directorio es el formato de miniatura especial propio del programa (se ignora el sufijo del nombre de archivo en ese directorio). Estas miniaturas están limitadas a 80x60 píxeles, así que son de un tamaño un poco «pequeño» (a menos que modifiques «xv» para que use miniaturas más grandes; véase el enlace de abajo). IM entiende el formato de miniatura de «xv» (que se basa en el formato de imagen «NetPBM»), así que puedes generar todas las miniaturas rápidamente con XV y luego convertir con magick las miniaturas XV de las imágenes JPEG en imágenes GIF para su procesamiento posterior...

   xv -vsmap &               # generate thumbs with the "Update" button
   rm .xvpics/*.gif          # delete XV thumbs of existing "gif" thumbnails
   magick mogrify -format gif .xvpics/*.jpg
   mv .xvpics/*.gif .        # move the new "gif" thumbnails to original dir

Si estás harto del pequeño tamaño de las miniaturas de XV, sobre todo con las pantallas modernas más grandes, puedes modificar el código de XV. Consulta mis notas de modificación de XV, que te permiten hacer que XV use un tamaño de miniatura mayor. Yo mismo uso miniaturas de 120x90 píxeles.

Procesamiento adicional -- Añadir adornos

Lo anterior es solo el comienzo de lo que puedes hacer para que tus miniaturas resulten más interesantes. Más allá de la imagen de miniatura básica, puedes añadir bordes, rotaciones e incluso cierta selección aleatoria de estilo para hacer tu galería de miniaturas mucho más interesante. A estas adiciones a las miniaturas las llamo «adornos» (fluff), como la pelusa extra que encuentras cubriendo tu ropa después de lavarla. Es decir, añade extras innecesarios a la miniatura, pero que pueden hacer las páginas web y las imágenes de índice mucho más interesantes. Ten en cuenta que muchos de los métodos y procesos siguientes son muy complejos y pueden requerir un conocimiento más profundo de las diversas opciones de procesamiento de imágenes de ImageMagick.

Añadir etiquetas a la imagen

Durante la creación de tus miniaturas también puedes añadir etiquetas encima, debajo o incluso sobre la propia miniatura. No obstante, este tipo de procesamiento de imágenes se trata con más detalle en Anotar imágenes con etiquetas. Solo recuerda usar «[-thumbnail](https://imagemagick.org/command-line-options/#thumbnail)» o «[-strip](https://imagemagick.org/command-line-options/#strip)» en lugar de «[-resize](https://imagemagick.org/command-line-options/#resize)» en esos ejemplos. Por ejemplo... |

  magick thumbnail.gif \
          -background Lavender -fill navy -font Candice -pointsize 24 \
          label:Hatching   -gravity South -append \
          labeled.gif

Con el uso de fuentes compuestas puedes superponer etiquetas muy elaboradas sobre la propia imagen. Por ejemplo, aquí usé una técnica de fuente de contorno suave más densa para anotar la miniatura, oscureciendo la zona alrededor del texto para que siempre quede legible. |

  magick -define jpeg:size=400x400  hatching_orig.jpg  -resize '120x200>' \
      \( +clone -sample 1x1\! -alpha transparent -sample 1000x200\! \
         -font SheerBeauty -pointsize 72 -gravity Center \
         -strokewidth 8 -stroke black  -fill black  -annotate 0,0 '%c' \
         -channel RGBA -blur 0x8 \
         -strokewidth 1 -stroke white  -fill white  -annotate 0,0 '%c' \
         -fuzz 1% -trim +repage -resize 115x \
      \) -gravity North -composite           -strip annotated.gif

Observa que no uso la imagen «thumbnail.gif» ya generada, ni uso el operador de redimensionado Thumbnail para eliminar los perfiles y comentarios de la imagen. En su lugar usé «[+clone](https://imagemagick.org/command-line-options/#clone)», «[+sample](https://imagemagick.org/command-line-options/#sample)» y «[-alpha](https://imagemagick.org/command-line-options/#alpha)» para generar un lienzo de trabajo transparente más grande, que también contiene una copia de los metadatos de la imagen original. Esto me permite usar la cadena de «comentario» de la imagen con el operador de anotación «[-annotate](https://imagemagick.org/command-line-options/#annotate)» para aportar el texto que se superpone a la imagen. Solo al final, después de haber compuesto la superposición de texto, limpio y elimino esa información con «[-strip](https://imagemagick.org/command-line-options/#strip)».

Botón en relieve

El operador «[-raise](https://imagemagick.org/command-line-options/#raise)» se creó básicamente con el único propósito de resaltar los bordes de las imágenes rectangulares para formar un botón en relieve. Es una transformación de miniatura sencilla, rápida y eficaz. |

  magick thumbnail.gif  -raise 8   raised_button.gif

El mismo operador tiene una forma «más» (plus) que puede usarse para crear un efecto de resaltado hundido. |

  magick thumbnail.gif  +raise 8   sunken_button.gif

Botón burbuja

Con algo de astucia, el operador «[-raise](https://imagemagick.org/command-line-options/#raise)» puede usarse para producir un botón en relieve suave con aspecto de «burbuja».

  magick thumbnail.gif -fill gray50 -colorize 100% \
          -raise 8 -normalize -blur 0x8  bubble_overlay.png
  magick thumbnail.gif bubble_overlay.png \
          -compose hardlight -composite  bubble_button.png

Para más información sobre este tipo de técnica, véase Métodos de composición con luz. Para más efectos como este, consulta Autoenmarcado (interno) más abajo y, para llevarlo al siguiente nivel, consulta Máscara de efecto de iluminación más abajo.

Añadir bordes

El humilde y sencillo operador «[-border](https://imagemagick.org/command-line-options/#border)» puede usarse para generar un marco algo complejo alrededor de una imagen. |

  magick thumbnail.gif \
          -bordercolor black -border 3   -bordercolor white -border 2 \
          \( -background black -fill white -pointsize 24 \
             label:Hatching   -trim +repage \
             -bordercolor black -border 10 \
          \) -gravity South -append \
          -bordercolor black -border 10   -gravity South -chop 0x10 \
          border_framework.gif

Marco simple

De forma similar, el operador «[-frame](https://imagemagick.org/command-line-options/#frame)» facilita añadir un marco alrededor de la imagen. |

  magick thumbnail.gif   -mattecolor peru  -frame 9x9+3+3  framed.gif

Este operador también tiene muchas más opciones para crear una docena o así de estilos distintos de marcos. Puedes ver ejemplos de las posibilidades en Frame, añadir un borde tipo 3D.

Enmarcado con montage

El comando montage ofrece una forma mucho más fácil de hacer todo lo anterior, y mucho más. No solo puede generar miniaturas (o páginas enteras de miniaturas), sino que también puede etiquetarlas para incluir información como nombres de archivo, tamaño en disco y dimensiones, o una cadena especificada por el usuario. Aquí tienes un uso sencillo de «magick montage» para generar una miniatura enmarcada. |

  magick montage -define jpeg:size=240x200  -label '%c'  hatching_orig.jpg \
          -frame 6  -geometry '120x100>'  montage_simple.gif

La etiqueta procede del comentario del archivo de imagen JPEG, que se añadió hace tiempo a la imagen con el comando ajeno a IM «wrjpgcom». Para más detalles, véase Procesamiento JPEG ajeno a IM.
Incluso con solo «magick montage» puedes hacer que la generación de tus miniaturas sea realmente elaborada. |

  magick montage -define jpeg:size=400x180  -label '%c' hatching_orig.jpg \
          -thumbnail '200x90>' -geometry '130x100>'  -mattecolor peru \
          -frame 6  -bordercolor skyblue  -font LokiCola  -pointsize 18 \
          montage_fancy.gif

Para más detalles, véase «Montage, matrices de imágenes». Puede que te interese especialmente el ejemplo de Mapas de imagen de miniaturas HTML con Montage. Esto crea una página de índice HTML de miniaturas en la que, al hacer clic en la miniatura, aparece la imagen original, en el mismo directorio.

Bordes suaves y difuminados

El operador Vignette ofrece una forma sencilla de añadir un borde borroso alrededor de una imagen. |

  magick thumbnail.gif -alpha set \
          -background none  -vignette 0x4  vignette.png

Por supuesto, como esta miniatura usa color semitransparente, debe guardarse en formato PNG. El método Morphology Distance ofrece un verdadero «difuminado» (feathering) transparente de los bordes de una imagen. |

  magick thumbnail.gif -alpha set -virtual-pixel transparent -channel A \
          -morphology Distance Euclidean:1,10\! +channel feathered.png

La distancia máxima del área transparente se controla con la opción especial de escalado de distancia 10\!. Esto solo se añadió en IM v6.6.1-6. Tiene la ventaja añadida de funcionar también con imágenes con formas, aunque se necesita una inicialización más compleja para conservar correctamente los píxeles con suavizado de bordes en la fórmula de distancia. Para más detalles, véase Difuminar formas usando Distance. El difuminado aquí es un degradado puramente lineal, y puede ajustarse aún más con el operador de contraste de no linealidad sigmoidal para darle un aspecto más suave y gradual de varias maneras distintas. También puedes difuminar imágenes usando Blur, con el mismo método de añadir píxeles virtuales transparentes antes de difuminar solo el canal alfa. Esto genera un difuminado más suave de la imagen, además de redondear notablemente las esquinas. |

  magick thumbnail.gif -alpha set -virtual-pixel transparent \
          -channel A -blur 0x8  -level 50%,100% +channel  soft_edge.png

La operación adicional «[-level](https://imagemagick.org/command-line-options/#level)» (que ajusta solo el canal de transparencia) garantiza que el borde se vuelva totalmente transparente, en lugar de solo medio transparente. No obstante, sí cae bruscamente hacia cero en el borde real, debido a la curva de tipo sigmoidal que genera el difuminado. También tiene un efecto aditivo en las esquinas, lo que hace que se redondeen, mientras que en una imagen con forma y con una concavidad pronunciada puede provocar que píxeles totalmente transparentes pasen a ser semitransparentes. Por eso, para las formas puede que necesites enmascarar el resultado contra la imagen original (usando composición Dst-In). Sin embargo, para miniaturas rectangulares el resultado es satisfactorio. Puedes ver otro ejemplo de este tipo de difuminado en Miniaturas por capas. Si en lugar de hacer un ajuste de niveles sobre el difuminado, aplicas un umbral al canal alfa difuminado al «50%», puedes añadir esquinas pseudoredondeadas a la miniatura anterior. |

  magick thumbnail.gif -alpha set -virtual-pixel transparent -channel A \
          -blur 0x8  -threshold 50% +channel rounded_corner_blur.gif

Aunque muy simple, el resultado no es una forma realmente buena de redondear las esquinas de la imagen. Primero, las esquinas no son en realidad circulares, sino una curva «hiperbólica». Segundo, el resultado no es una curva suave con suavizado de bordes, sino que muestra «dientes de sierra» causados por el efecto de aliasing de la operación de umbral. No obstante, esta imagen puede guardarse en formato GIF. Para más detalles, véase Transparencia booleana de GIF. Ten en cuenta también que la operación «[-blur](https://imagemagick.org/command-line-options/#blur)» puede volverse muy lenta cuando trabajas con un argumento grande para generar una esquina redondeada mayor. Por eso, este método de redondear esquinas a gran escala no es nada recomendable. Para un efecto de borde difuminado más inusual, puedes usar un desenfoque radial solo sobre el canal alfa. |

  magick thumbnail.gif -alpha set -virtual-pixel transparent \
          -channel A -radial-blur 0x45 +channel  radial_blur_edge.png

Esto funciona mejor con imágenes perfectamente cuadradas. A medida que la cantidad de desenfoque angular aumenta, acabarás generando un borde de tipo viñeta circular. |

  magick thumbnail.gif -alpha set -virtual-pixel transparent \
          -channel A -radial-blur 0x100 +channel  radial_blur_vignette.png

Los dos artefactos en forma de escalón que pueden verse se deben a las dos dimensiones de tamaño de la imagen. En una imagen cuadrada no se verá ningún «escalón». Añadir un poco de desenfoque normal extra al último ejemplo también puede mejorar el problema del escalón.

Esquinas redondeadas y con formas

Aunque aplicar un umbral a un borde suave difuminado (véase arriba) genera una esquina redondeada apta para la transparencia booleana de GIF, no genera una esquina suave con «suavizado de bordes». La forma adecuada de generar una imagen con esquinas redondeadas, o de cualquier otra forma, es recortar de verdad cada esquina usando una máscara con la forma deseada. El siguiente método, de Leif Åstrand leif@sitelogic.fi, multiplica una máscara de imagen completa para generar el resultado apropiado. |

  magick thumbnail.gif \
     \( +clone  -alpha extract \
        -draw 'fill black polygon 0,0 0,15 15,0 fill white circle 15,15 15,0' \
        \( +clone -flip \) -compose Multiply -composite \
        \( +clone -flop \) -compose Multiply -composite \
     \) -alpha off -compose CopyOpacity -composite  rounded_corners.png

Básicamente extrae la máscara de transparencia blanca de la imagen original, con una sola esquina redondeada negra. Luego se voltea vertical y horizontalmente para producir una máscara con las cuatro esquinas redondeadas. Y, por último, esa máscara se aplica a la imagen original. Para imágenes mucho más grandes, puede que te convenga aplicar una máscara mucho más pequeña a cada esquina individual, para reducir la cantidad total de procesamiento necesario. Eso supone más pasos de procesamiento individuales, pero en conjunto menos procesamiento de los píxeles reales. Por ejemplo, aquí está lo mismo, pero recortando una forma triangular dibujada simple en cada esquina. Esto funcionará con imágenes mucho más grandes. |

  magick thumbnail.gif -alpha set  -compose DstOut \
      \( -size 20x15 xc:none -draw "polygon 0,0  0,14 19,0" \
         -write mpr:triangle  +delete \) \
      \( mpr:triangle             \) -gravity northwest -composite \
      \( mpr:triangle -flip       \) -gravity southwest -composite \
      \( mpr:triangle -flop       \) -gravity northeast -composite \
      \( mpr:triangle -rotate 180 \) -gravity southeast -composite \
      corner_cutoff.png

Si no quieres transparencia, sino otro color, puedes hacer lo anterior y luego eliminar la transparencia. Esto puede ser importante para las imágenes JPEG. No obstante, se ha encontrado una solución aún más simple (en términos de complejidad y uso de memoria) en una discusión del foro de IM. Esta superpone esquinas de color («Red» en este caso) en lugar de hacerlas transparentes. |

  magick thumbnail.gif \
    \( +clone -crop 16x16+0+0  -fill white -colorize 100% \
       -draw 'fill black circle 15,15 15,0' \
       -background Red  -alpha shape \
       \( +clone -flip \) \( +clone -flop \) \( +clone -flip \) \
     \) -flatten  rounded_corners_red.png

| El último ejemplo fallará en versiones de IM anteriores a la v6.6.6-5, debido a que ni el operador «[-flip](https://imagemagick.org/command-line-options/#flip)» ni el «[-flop](https://imagemagick.org/command-line-options/#flop)» manejan correctamente el desplazamiento del lienzo virtual.
---|---
Usando un truco de ciclo polar, podemos generar una máscara de círculo perfecta y con suavizado de bordes para una miniatura de cualquier tamaño. Por supuesto, solo usaremos la imagen distorsionada como máscara de la imagen original, para obtener el mejor resultado. |

  magick thumbnail.gif -alpha set \
    \( +clone -distort DePolar 0 \
       -virtual-pixel HorizontalTile -background None -distort Polar 0 \) \
    -compose Dst_In -composite -trim +repage circle_masked.png

Llevaremos este estilo de procesamiento de imágenes más lejos en Borde con esquinas redondeadas más abajo. Allí no solo recortamos esquinas, sino que también superponemos imágenes de enmarcado adecuadas.

Borde de papel rasgado

Leif Åstrand leif@sitelogic.fi aportó el siguiente código de IM para generar un borde que parece arrancado de un papel fibroso (como el periódico)... |

  magick thumbnail.gif \
          \( +clone -alpha extract -virtual-pixel black \
             -spread 10 -blur 0x3 -threshold 50% -spread 1 -blur 0x.7 \) \
          -alpha off -compose Copy_Opacity -composite torn_paper.png

Una posible mejora sería que pareciera que lo arrancaste de la esquina de un periódico. |

  magick thumbnail.gif -bordercolor linen -border 8x8 \
          -background Linen  -gravity SouthEast -splice 10x10+0+0 \
          \( +clone -alpha extract -virtual-pixel black \
             -spread 10 -blur 0x3 -threshold 50% -spread 1 -blur 0x.7 \) \
          -alpha off -compose Copy_Opacity -composite \
          -gravity SouthEast -chop 10x10   torn_paper_corner.png

Esto podría mejorarse añadiendo bordes de color «papel» y una máscara de forma curva, para que parezca que la imagen se arrancó de forma tosca a mano. Añadir una «sombra suave» (véase a continuación) también «despegará» la imagen resultante del fondo, haciendo que parezca una pieza independiente. Como siempre, las sugerencias y aportaciones son bienvenidas.

Añadir una sombra

El operador «[-shadow](https://imagemagick.org/command-line-options/#shadow)» facilita la generación de sombras de cualquier imagen con forma. Por ejemplo, aquí añado una sombra de color semitransparente a la miniatura. |

  magick thumbnail.gif -alpha set \
          \( +clone -background navy -shadow 60x0+4+4 \) +swap \
          -background none -mosaic   shadow_hard.gif

Pero también puedes crear con la misma facilidad sombras suaves y difusas. |

  magick -page +4+4 thumbnail.gif -alpha set \
          \( +clone -background navy -shadow 60x4+4+4 \) +swap \
          -background none -mosaic     shadow_soft.png

Observa que de nuevo usé una imagen en formato PNG para la salida de las miniaturas. Esto se debe a que la imagen con sombra contendrá muchos píxeles semitransparentes, que GIF no puede manejar. (Sí, me repito, pero es importante). Si piensas usar el formato GIF o JPG, necesitarás un color de «[-background](https://imagemagick.org/command-line-options/#background)» más adecuado para la página web o el lienzo mayor sobre el que vayas a mostrar tu miniatura, ya que estos formatos no manejan colores semitransparentes. Atención: aunque lo anterior funciona para miniaturas individuales, por lo general fallará cuando quieras superponer varias miniaturas unas sobre otras. La razón es que las sombras no se acumulan entre sí del mismo modo que lo hacen las imágenes normales. Para ver cómo manejar las sombras de varias imágenes superpuestas, consulta Capas de sombras.

Añadir algo de grosor

Añadir grosor a una imagen o a una forma se parece un poco a añadir una sombra dura (véase arriba), pero no es exactamente lo mismo y requiere algo de trabajo extra para hacerlo bien. En realidad es muy delicado, ya que creamos una máscara coloreada de la imagen que luego se replica varias veces y se coloca por debajo de la imagen original (usando composición «DstOver») con desplazamientos crecientes para dar grosor a la imagen. |

  magick thumbnail.gif -alpha set \
          \( +clone -fill DarkSlateGrey -colorize 100% -repage +0+1 \) \
          \( +clone -repage +1+2 \) \
          \( +clone -repage +1+3 \) \
          \( +clone -repage +2+4 \) \
          \( +clone -repage +2+5 \) \
          \( +clone -repage +3+6 \) \
          -background none -compose DstOver -mosaic  thickness.gif

Te haces a la idea. Cada línea «\( +clone ... \)» añade un píxel extra a la imagen en dirección sur-sureste. Además, como no hay píxeles semitransparentes implicados (al menos en una imagen rectangular), puedes usar el formato de imagen GIF para el resultado. El gran problema de esta técnica es que es difícil especificar un grosor como argumento variable o en distintos ángulos, a menos que escribas un script específico para añadir grosor. Además, el borde de las partes en ángulo del grosor no tiene suavizado de bordes, así que hay mucho margen de mejora.

Miniaturas estilo polaroid

Puedes hacer que tu imagen de miniatura parezca una foto polaroid, darle una sombra e incluso rotarla un poco para que parezca que está simplemente posada sobre una mesa. |

  magick thumbnail.gif \
          -bordercolor white  -border 6 \
          -bordercolor grey60 -border 1 \
          -background  none   -rotate 6 \
          -background  black  \( +clone -shadow 60x4+4+4 \) +swap \
          -background  none   -flatten \
          poloroid.png

A IM v6.3.1-6 se añadió una versión más compleja de lo anterior como operador de transformación «[-polaroid](https://imagemagick.org/command-line-options/#polaroid)». Por ejemplo... |

  magick thumbnail.gif -bordercolor snow -background black +polaroid \
          poloroid_operator.png

Observa que la imagen no solo tiene el marco polaroid, sino que además a la foto se le ha dado cierta «curvatura» con ajustes de sombra adecuados, lo que da más profundidad a la imagen resultante. La forma con más (+) usa un ángulo aleatorio, mientras que la forma normal con menos (-) te permite indicar el ángulo de rotación. Un agradecimiento especial a Timothy Hunter por la idea que hay detrás de esta técnica. Incluso puedes añadir un «[-caption](https://imagemagick.org/command-line-options/#caption)», establecer tu propio color de sombra e indicar tu propia rotación (o ninguna). |

  magick -caption '%c' hatching_orig.jpg -thumbnail '120x120>' \
          -font Ravie -gravity center -bordercolor Lavender \
          -background navy  -polaroid -0     poloroid_caption.png

Para más información sobre el uso de este operador, véase Transformación polaroid compleja. No obstante, para estos ejemplos seguiré usando un método de creación casero, ya que necesito un control más fino de los bordes y los efectos de sombra para demostrar un correcto «apilado» de fotos. Y allá vamos... Haciendo varias copias de la fotografía (o usando otras imágenes) y añadiendo bordes polaroid, puedes luego rotarlas y apilarlas al azar para producir una bonita pila de fotos. |

  magick thumbnail.gif \
     -bordercolor white  -border 6 \
     -bordercolor grey60 -border 1 \
     -bordercolor none  -background  none \
     \( -clone 0 -rotate `magick null: -format '%[fx:rand()*30-15]' info:` \) \
     \( -clone 0 -rotate `magick null: -format '%[fx:rand()*30-15]' info:` \) \
     \( -clone 0 -rotate `magick null: -format '%[fx:rand()*30-15]' info:` \) \
     \( -clone 0 -rotate `magick null: -format '%[fx:rand()*30-15]' info:` \) \
     -delete 0  -border 100x80  -gravity center \
     -crop 200x160+0+0  +repage  -flatten  -trim +repage \
     -background black \( +clone -shadow 60x4+4+4 \) +swap \
     -background none  -flatten \
     poloroid_stack.png

| El comando «magick ...» incrustado en el ejemplo anterior genera un número de coma flotante aleatorio entre -15 y +15. Para más información sobre el uso de IM como calculadora matemática, véase Expresiones FX. Una alternativa es asignar números aleatorios a variables de shell y sustituirlos en el comando anterior.
---|---
Por supuesto, podrías sustituir un conjunto de imágenes distintas en lugar de repetir la misma imagen al crear la pila. O elegir un conjunto de ángulos de rotación de modo que todos sean razonablemente distintos, o más agradables a la vista. Si eres muy bueno, puedes incluso desplazar las imágenes rotadas (variar un poco su posición) para que no queden todas apiladas perfectamente centradas. Pero ya te haces a la idea básica. Si de verdad quieres evitar el uso del formato PNG, debido a sus problemas actuales con algunos navegadores, puedes usar el formato de imagen GIF. Para ello debes estar dispuesto a aceptar algunas limitaciones de color y conocer el color de fondo exacto sobre el que se mostrará la imagen. El color «LightSteelBlue» en el caso de estas páginas. |

  magick thumbnail.gif \
          -bordercolor white  -border 6 \
          -bordercolor grey60 -border 1 \
          -background  none   -rotate -9 \
          -background  black  \( +clone -shadow 60x4+4+4 \) +swap \
          -background  LightSteelBlue  -flatten    poloroid.gif

Para más detalles sobre esta técnica (y más), véase Imágenes GIF sobre un fondo de color sólido. La técnica de «polaroid apilados» anterior fue cortésmente aportada por Ally de Ally's Trip y Stefan Nagtegaal para Muziekvereniging Sempre Crescendo, que usan miniaturas estilo polaroid de forma extensa en sus sitios web. En el foro de usuarios de IM, el usuario grazzman fue un poco más allá superponiendo imágenes sobre un lienzo en rotación para crear un despliegue de fotos. |

  magick -size 150x150 xc:none -background none \
          -fill white -stroke grey60 \
          -draw "rectangle 0,0 130,100" thumbnail.gif \
                -geometry +5+5 -composite -rotate -10 \
          -draw "rectangle 0,0 130,100" thumbnail.gif \
                -geometry +5+5 -composite -rotate -10 \
          -draw "rectangle 0,0 130,100" thumbnail.gif \
                -geometry +5+5 -composite -rotate +10 \
          -trim +repage -background LightSteelBlue -flatten \
          poloroid_spread.gif

Por supuesto, para un despliegue de fotos como este de verdad necesitas usar un conjunto de fotos distintas en lugar de usar la misma imagen una y otra vez como hice yo aquí. Hay algunas advertencias que quizá quieras tener en cuenta con esta técnica.

El enmarcado se ha codificado de forma fija en lo anterior, y depende del tamaño de la imagen de miniatura. En una aplicación real, el enmarcado podría trasladarse a la etapa de generación de la miniatura en lugar de al despliegue de fotos anterior.
Como «[-rotate](https://imagemagick.org/command-line-options/#rotate)» también expande el tamaño del lienzo, la posición en la que se añaden las imágenes va cambiando, a menos que las coloques usando un desplazamiento desde la posición «[-gravity](https://imagemagick.org/command-line-options/#gravity) center».
Y, por último, rotar constantemente el marco de fondo no es buena idea en cuanto a calidad. Rotar una imagen ya rotada añade más distorsiones a nivel de píxel al resultado que hacer una sola rotación por cada imagen separada antes de superponerla.

Para la fotografía de Stas Bekman se desarrolló un apilado aleatorio similar de fotos sobre un área mayor, pero con una técnica de bordeado distinta. En Ejemplos de superposición de imágenes por capas, así como en Fotos superpuestas, se muestra y describe un método más general para crear algún tipo de disposición ordenada o programada de fotos e imágenes.

Técnicas de enmarcado

Aquí veremos algunas técnicas de enmarcado avanzadas que usan un conocimiento muy avanzado del funcionamiento de IM para lograr los resultados deseados.

Autoenmarcado (externo)

El autoenmarcado es una técnica que puede usarse para enmarcar una imagen usando la propia imagen para generar los colores y patrones del marco. Es decir, el marco añadido no es fijo, sino que varía para coincidir aproximadamente con la imagen que se enmarca. Puedes hacerlo de dos maneras. Extender la imagen original para crear un marco externo, o usar parte de la propia imagen para crear un marco interno. Por ejemplo, si ampliamos la imagen y la atenuamos antes de superponer encima la imagen original, obtenemos un marco de muy buen aspecto. |

  magick thumbnail.gif \
          \( -clone 0 -resize 130% +level 20%x100% \) \
          \( -clone 0 -bordercolor black -border 1x1 \) \
          -delete 0 -gravity center -composite  self_bordered.gif

| En lugar de usar ajustes de niveles para aclarar (u oscurecer) la imagen del marco, una forma alternativa de hacer el borde de un color más claro o más oscuro es teñir de color el marco usando algo como...
«-fill white -colorize 30%»
---|---
Otra forma de teñir de color la imagen para generar el marco es simplemente hacer que IM superponga un marco semitransparente sobre la imagen ampliada. Sin embargo, esto requiere que conozcas el tamaño de la miniatura para redimensionarla exactamente la cantidad justa que acomode el marco generado. |

  magick thumbnail.gif \
          \( -clone 0 -resize 140x110\! \) \
          \( -clone 0 -bordercolor black -border 1x1 \
                      -mattecolor '#8884' -frame 9x9+0+9 \) \
          -delete 0 -composite  self_framed.gif

Una variación de lo anterior usa el control especial de ventana gráfica (viewport) y el ajuste por defecto de píxel virtual, Edge para extender el borde de una imagen difuminada y generar el marco externo. |

  magick thumbnail.gif \( +clone \
             -set option:distort:viewport 150x120-15-15 \
             -virtual-pixel Edge    -distort SRT 0  +repage \
             -blur 0x3 +level 20%,100% \) \
          \( -clone 0 -bordercolor white -border 1 \) \
          -delete 0 -gravity center -compose over -composite \
          self_blurred_edge.gif

Solo una advertencia. Un pequeño defecto de borde (como un árbol o una hoja) puede producir resultados indeseables en un marco generado usando solo el borde de la imagen. La ventana gráfica sí necesita conocer el tamaño de la imagen original para ampliarla y desplazarla la cantidad adecuada. No obstante, puedes usar expresiones de escape FX para calcular el tamaño de la ventana gráfica (véanse los ejemplos de abajo). Una alternativa es usar un píxel virtual, Dither difuminado en el ejemplo anterior. Esto extenderá más los colores y no quedará tan «marcado». Pero si añades difuminados antes y después de la expansión, usas el dithering para producir un efecto de tipo tela. |

  magick thumbnail.gif \( +clone  -blur 0x3 \
             -set option:distort:viewport '%[fx:w+30]x%[fx:h+30]-15-15' \
             -virtual-pixel Dither  -distort SRT 0  +repage \
             -blur 0x0.8  +level 20%,100% \) \
          \( -clone 0 -bordercolor white -border 1 \) \
          -delete 0 -gravity center -compose over -composite \
          self_blurred_dither.gif

El primer difuminado modula el color medio, mientras que el segundo ajusta lo «pixelado» o suave que es el patrón de dithering. Aquí tienes otro ejemplo, esta vez usando píxel virtual, Mirror, con un borde suave (ennegrecido) que resultó funcionar muy bien para esta imagen concreta. |

  magick thumbnail.gif  \( +clone \
             -set option:distort:viewport '%[fx:w+30]x%[fx:h+30]-15-15' \
             -virtual-pixel Mirror -distort SRT 0 +repage \
             -alpha set -virtual-pixel transparent \
                 -channel A -blur 0x8 +channel \
             -background Black -flatten \) \
          +swap -gravity center -compose over -composite \
          self_mirror.gif

En todos los casos anteriores, los marcos se generan a partir de la misma imagen, que luego se combina para producir un marco basado en los colores procedentes de la imagen original. Así, el borde del marco es único y coincide con cada imagen de miniatura que se enmarca. Fred Weinhaus ha creado un script, «[imageborder](http://www.fmwconcepts.com/imagemagick/imageborder/)», para facilitar el autoenmarcado de imágenes, con bordes generados a partir de ampliaciones difuminadas de la imagen original, o algún tipo de ajuste de píxel virtual que define el contenido.

Autoenmarcado (interno)

En lugar de ampliar la imagen para añadir el nuevo borde, podemos convertir con magick partes de la propia imagen en un borde. Ya hemos visto algunas técnicas para añadir un marco dentro de la propia imagen. Las técnicas de botón en relieve y botón burbuja hacen esto, usando el operador «[-raise](https://imagemagick.org/command-line-options/#raise)». Aquí generamos una versión más clara y difuminada de la imagen original, que luego se superpone usando una máscara generada también a partir de la imagen original. Después se añade un borde blanco para separar esa versión más clara y difuminada de la parte central no modificada de la imagen. |

  magick thumbnail.gif \( +clone -blur 0x3 +level 20%,100% \) \
          \( +clone -gamma 0 -shave 10x10 \
             -bordercolor white -border 10x10 \) \
          -composite \
          \( +clone -gamma 0 -shave 10x10 \
             -bordercolor white -border 1x1 \
             -bordercolor black -border 9x9 \) \
          -compose screen -composite \
          self_blurred_border.gif

También puedes usar el operador Frame para lograr algo un poco distinto de los efectos de botón vistos antes. El truco está en primero recortar (Shave) la imagen original antes de aplicarlo. Por ejemplo, aquí hago una copia de la imagen original, la recorto y la enmarco con un marco transparente, antes de superponerla sobre la imagen original. |

  magick thumbnail.gif \( +clone -shave 10x10 \
            -alpha set -mattecolor '#AAA6' -frame 10x10+3+4 \
          \) -composite  inside_frame_trans.gif

El problema de esto es que siempre «aclararás» u «oscurecerás» (reducirás el contraste de) las partes planas del marco alrededor de la imagen original. Para evitarlo podemos usar la misma técnica que la del botón burbuja. Generamos un marco sobre un lienzo gris perfecto y lo modificamos para generar una máscara de composición de efectos de iluminación, con la que ajustar los colores de la imagen original. Por ejemplo, aquí uso una composición «[VividLight](compose.html#vividlight)» con la imagen de máscara enmarcada para conservar mejor los colores primarios. |

  magick thumbnail.gif \
          \( +clone -shave 10x10 -fill gray50 -colorize 100% \
            -mattecolor gray50 -frame 10x10+3+4 \
          \) -compose VividLight -composite  inside_frame_light.gif

Como en el botón burbuja, también puedes difuminar la máscara de iluminación antes de aplicarla. Aquí usé una composición «[HardLight](compose.html#hardlight)» más normal, que no realza los colores primarios, con una máscara de iluminación de marco difuminada. |

  magick thumbnail.gif \
          \( +clone -shave 10x10 -fill gray50 -colorize 100% \
            -mattecolor gray50 -frame 10x10+3+4 -blur 0x2 \
          \) -compose HardLight -composite  inside_frame_blur.gif

| Algunos métodos de composición con luz pueden requerir que intercambies las imágenes antes de componerlas para obtener el efecto de iluminación correcto.
---|---
Para llevar este tipo de efecto aún más lejos, produciendo resultados mucho más complejos, véase la máscara de efecto de iluminación avanzada.

Superposición de borde simple

Un tipo simple de enmarcado consiste en crear un marco elaborado, o una imagen con forma, dentro del cual puedes colocar tu imagen, bajo el marco. Por ejemplo, aquí generamos un marco simple algo más grande que nuestra imagen con un agujero de forma elaborada. La forma se extrajo de la fuente «WebDings» (el carácter «Y»), pero hay muchas fuentes posibles de formas elaboradas que podrían usarse para enmarcar imágenes. |

  magick -size 120x140 -gravity center -font WebDings label:Y \
          -negate -channel A -combine +channel -fill LightCoral -colorize 100% \
          -background none -fill none -stroke firebrick -strokewidth 3 label:Y \
          -flatten +gravity -chop 0x10+0+0 -shave 0x10 +repage border_heart.png

Para otras formas de generar un borde en una imagen con forma ya existente, véase Edge Transform. También puedes, opcionalmente, dar al marco algo de profundidad usando un efecto de sombra. |

  magick border_heart.png  \( +clone -background black -shadow 60x3+3+3 \) \
          -background none -compose DstOver -flatten   border_overlay.png

Ahora que tenemos un marco de superposición simple, podemos colocar la imagen debajo, en el centro, bajo el marco, usando una composición «[DstOver](../static/img/compose/dstover)». |

  magick border_overlay.png  thumbnail.gif \
          -gravity center -compose DstOver -composite   border_overlaid.jpg

Ahora puedes generar una biblioteca de marcos preparados de antemano para usar con tus imágenes, como esta imagen de hojas de otoño.

    magick thumbnail.gif  autumn_leaves.png +swap \
            -gravity center -compose DstOver -composite \
            border_leaves.gif

Observa que intercambié el orden de las imágenes y usé «[DstOver](compose.html#dstover)» para colocar la segunda imagen principal «bajo» el marco. De ese modo, es el marco el que determina el tamaño final de la imagen, y no la imagen original. No obstante, hacer esto también perdería cualquier metadato que tenga la imagen principal (por la misma razón). Si de verdad quieres conservar los metadatos de la miniatura (como etiquetas y comentarios, por ejemplo un mensaje de copyright), lo mejor es rellenar la miniatura al mismo tamaño que el marco, y luego usar la composición «[Over](compose.html#over)» por defecto para superponer el marco. De ese modo, la miniatura es la imagen de «destino» y sus metadatos de imagen se conservan.

Ejemplo de superposición de insignia

Aquí tienes otro ejemplo de superposición preparada de antemano más complejo, esta vez usando una imagen de tamaño correcto (usando extent como método de recorte), de la discusión del foro de IM Composite Overlay and Masking.

    magick thumbnail.gif  -gravity center -extent 90x90 \
            badge_overlay.png -composite     badge.png

Observa que la propia imagen no se distorsiona, solo se aclara y oscurece ligeramente, se recorta un círculo y se añade una sombra, todo en una sola imagen de superposición. Si esto fuera una insignia real, o una «burbuja de cristal», entonces la imagen también debería distorsionarse un poco (quizá usando una distorsión de barril), pero funciona bien sin necesidad de tal distorsión. Para el siguiente paso del ejemplo de la «insignia», véase Insignia con máscara y pintura, que añade transparencia de fondo alrededor del exterior de la insignia.

Técnica de máscara y pintura

En muchos casos no solo quieres superponer un borde cuadrado alrededor de una imagen, sino que también quieres recortar los bordes de la imagen, hasta la transparencia. Para esto normalmente usarías al menos dos imágenes. Una es la superposición con máscara que contiene los colores, sombras y reflejos que quieres añadir a la imagen existente. Y una segunda imagen que contiene las partes que quieres eliminar de la imagen original. Las dos imágenes pueden aplicarse de dos maneras distintas. Puedes «enmascarar» primero para eliminar las partes no deseadas de la imagen y luego superponer el marco, o puedes superponer un marco y luego enmascarar a transparencia las partes no deseadas tanto de la imagen original como de los colores superpuestos. El método que uses es crítico, y las imágenes implicadas se diseñarán para una técnica concreta. No puedes usar las imágenes de un método en el orden equivocado, o las cosas no funcionarán bien. Por ejemplo, vamos a crear un borde con una forma más compleja, pero esta vez sin preocuparnos por establecer el fondo. |

  magick -size 120x100 xc:none -fill none -stroke black -strokewidth 3 \
          -draw 'ellipse 60,50 30,45 0,360  ellipse 60,50 55,30 0,360' \
          -strokewidth 3  -draw 'ellipse 60,50 57,47 0,360' \
          -channel RGBA  -blur 2x1    border_ellipse.png

Ahora hice este borde borroso a propósito, para que los componentes del borde sean mucho más semitransparentes. Incluso sin esa difuminación extra, un borde también contiene muchos píxeles semitransparentes con suavizado de bordes, que hacen que el borde se vea más suave y menos dentado. Es vital, al procesar imágenes, que tengas en cuenta estos píxeles semitransparentes, para conservarlos y establecerlos correctamente. Para hacerlo más interesante, dale a este borde «difuso» un poco de color aleatorio. |

  magick border_ellipse.png \
          \( -size 120x100 plasma:Tomato-FireBrick -alpha set -blur 0x1 \) \
          -compose SrcIn -composite     border_ellipse_red.png

Vale, tenemos un borde, pero todavía necesitamos alguna forma de definir qué debe representar el exterior y el interior del borde. Básicamente necesitamos una máscara para definir estas dos áreas. |

  magick -size 120x100  xc:none -fill black \
          -draw 'ellipse 60,50 30,45 0,360  ellipse 60,50 55,30 0,360' \
          border_ellipse_mask.png

El color de esta imagen «máscara» no importa, solo su forma, ya que básicamente define qué partes se clasificarán como interior y cuáles como exterior. La máscara puede ser una máscara en escala de grises, o puede ser una máscara de forma como la mostrada arriba. Aunque esta última suele ser más útil, e incluso puede ser una forma de las partes a borrar, o de las partes a conservar (como arriba). En este caso, las imágenes se diseñan como una técnica de «máscara y pintura», lo que significa que primero debes borrar las partes no deseadas y luego superponer los colores adicionales del borde (que también lleva implicada una máscara de transparencia). Por ejemplo...

  magick thumbnail.gif -alpha set  -gravity center -extent 120x100 \
          border_ellipse_mask.png  -compose DstIn -composite \
          border_ellipse_red.png   -compose Over  -composite \
          border_mask_paint.png

Siempre se necesitan dos operaciones de composición alfa de Duff-Porter. Una para hacer transparentes algunas partes, y otra para superponer los colores adicionales que perfilan el borde o marco. Se necesitan dos imágenes, así que deben mantenerse separadas. Algunos formatos como MIFF y GIF sí permiten guardar ambas imágenes en el mismo archivo, para un almacenamiento más sencillo. Por supuesto, puedes combinar las dos imágenes para crear una sola imagen de enmarcado de superposición simple, pero solo si quieres usar un color sin transparencia fijo para las partes exteriores del resultado. Por ejemplo, predefine el exterior como un color DodgerBlue... |

  magick border_ellipse_mask.png -alpha extract -negate \
          -background DodgerBlue -alpha shape \
          border_ellipse_red.png   -compose Over -composite \
          border_ellipse_overlay.png

Pero en ese caso podrías simplemente colocar un color sólido u otra imagen de fondo bajo la imagen de doble máscara generada anteriormente... |

  magick border_double_masked.png \
          \( -size 120x100 plasma:Green-Green -blur 0x1 \) \
          +swap  -compose Over  -composite     border_background.png

La cuestión es que con dos imágenes, una «máscara» y una «superposición», tienes mucha más libertad en cómo añades el borde a la imagen. Incluso podrías definir varias imágenes de «máscara» para definir las distintas «ventanas» de la imagen de borde «superpuesta». También puedes añadir reflejos y sombras opcionales, en lugar de codificarlos de forma fija en una sola imagen de enmarcado de superposición. Ahora, una advertencia importante. Los bordes de la imagen de máscara no deben coincidir con los bordes de la imagen de superposición. Si coinciden, no obtendrás el manejo correcto de los colores a lo largo de los bordes coincidentes, o generarás otros efectos de «halo» extraños. Por eso debes asegurarte de que los bordes de la máscara caigan en algún punto dentro de la región totalmente opaca de la imagen de superposición. Se necesita precaución y previsión con las dos operaciones de enmascarado.

Borde con esquinas redondeadas

Como viste arriba, la técnica de máscara y pintura puede usarse tanto para añadir colores extra o «adornos» a una imagen como para eliminar partes, dando forma a la imagen final. Esto nos presenta una forma alternativa de añadir esquinas redondeadas a una imagen. El operador «[-draw](https://imagemagick.org/command-line-options/#draw)» de IM viene con un método «roundrectangle» que puede usarse para crear un marco interesante alrededor de la imagen. Sin embargo, necesitas dimensionar este método de dibujo para que coincida con la imagen. IM sí ofrece métodos para extraer e incluso hacer cálculos matemáticos basados en el tamaño de la imagen. Las coordenadas en las que situar el rectángulo se refieren al «centro» exacto del grosor de trazo (stroke-width) usado para definir el rectángulo (puede ser un valor de coma flotante). Además, se da en términos de «coordenadas de píxel» (véase Coordenadas de píxel frente a coordenadas de imagen), lo que significa que un valor de 1,1 se refiere al segundo píxel desde los bordes superior e izquierdo, pero, lo que es más importante, se refiere al «centro» del píxel, que en realidad está a 1,5 unidades de los bordes superior e izquierdo reales. Ahora usaremos un grosor de trazo (SW) de 3, lo que hace la imagen 3 píxeles más grande por todos los lados. Eso significa entonces que el rectángulo se situará a SW/2 - 0.5, o sea 1,0 píxeles desde la esquina superior izquierda, y a ImageSize + SW*1.5 - 0.5, o sea el tamaño de la imagen + 4 píxeles, en la esquina inferior derecha. Aquí usamos el propio IM para hacer estos cálculos, generando el comando de dibujo exacto que se necesita usando escapes FX elaborados. Esto se guarda como un archivo de gráficos vectoriales Magick (MVG) que puede usarse directamente con draw en comandos posteriores.

  magick thumbnail.gif \
          -format 'roundrectangle 1,1 %[fx:w+4],%[fx:h+4] 15,15'\
          info: > rounded_corner.mvg

| Si puedes averiguar el tamaño de la imagen de otra forma (usando el shell, u otro lenguaje envoltorio de la API), puedes sustituir los parámetros de dibujo apropiados directamente en los siguientes ejemplos, en lugar de usar una expresión matemática FX. Básicamente, lo anterior hace que todo este proceso sea independiente del tamaño real de la miniatura. Cualquier otra forma, incluida la codificación directa, también es aceptable.
---|---
Ahora podemos usar esto para generar una imagen de superposición y una de máscara. Como parte de esto, creamos un lienzo transparente usando la imagen original (que primero se amplía según el grosor de trazo), para acertar con el tamaño.

  magick thumbnail.gif -border 3 -alpha transparent \
          -background none -fill white -stroke none -strokewidth 0 \
          -draw "@rounded_corner.mvg"    rounded_corner_mask.png
  magick thumbnail.gif -border 3 -alpha transparent \
          -background none -fill none -stroke black -strokewidth 3 \
          -draw "@rounded_corner.mvg"    rounded_corner_overlay.png

Y ahí tenemos la imagen de borde de superposición y la imagen de máscara de transparencia que necesitamos para la técnica de doble enmascarado. Observa que las máscaras son para una imagen que es un grosor de trazo mayor que la imagen original, y que la máscara de forma de borrado (en blanco) no cubre toda el área ampliada, ya que hay un hueco de 1 píxel a su alrededor. Así que vamos a aplicarla usando la técnica de doble enmascarado... |

  magick thumbnail.gif -alpha set -bordercolor none -border 3  \
          rounded_corner_mask.png -compose DstIn -composite \
          rounded_corner_overlay.png -compose Over -composite \
          rounded_border.png

Y ahí tenemos nuestra imagen con un borde de esquinas redondeadas. Lo siguiente es cómo puedes hacer todo lo anterior en un solo comando con un poco más de elaboración. No obstante, este comando todo en uno seguirá generando un archivo temporal que contiene los comandos de dibujo generados, necesarios para una imagen del tamaño dado. |

  magick thumbnail.gif \
      -format 'roundrectangle 1,1 %[fx:w+4],%[fx:h+4] 15,15' \
      -write info:tmp.mvg \
      -alpha set -bordercolor none -border 3 \
      \( +clone -alpha transparent -background none \
         -fill white -stroke none -strokewidth 0 -draw @tmp.mvg \) \
      -compose DstIn -composite \
      \( +clone -alpha transparent -background none \
         -fill none -stroke black -strokewidth 3 -draw @tmp.mvg \
         -fill none -stroke white -strokewidth 1 -draw @tmp.mvg \) \
      -compose Over -composite               rounded_border_in_one.png
  rm -f tmp.mvg      # Limpieza del archivo temporal

Una forma mejor de hacer esquinas redondeadas, sobre todo con imágenes muy grandes, será usar una técnica de imagen de máscara de esquina separada, que veremos más abajo en Superposiciones de esquina elaboradas. En muchos sentidos, esto es una extensión del método anterior, pero usando un enmascarado separado para cada esquina de la imagen, para mantener pequeñas las imágenes de trabajo.

Insignia con máscara y pintura

Aquí tienes un ejemplo de «máscara y pintura» mucho más complejo, desarrollado a partir de la imagen usada antes en el ejemplo de superposición de insignia anterior. La generación de las dos imágenes fue «improvisada» y se discutió en los foros de IM Composite Overlay and Masking. Idealmente, las dos imágenes se habrían desarrollado juntas.

  magick thumbnail.gif -alpha set -gravity center -extent 90x90 \
          badge_mask.png -compose DstIn -composite \
          badge_shading.png -compose Over -composite \
          badge_trans_bg.png

Observa que arriba dije que debes evitar intentar alinear los bordes de transparencia con los bordes de la máscara. En el ejemplo anterior hice justo eso, y los bordes de la imagen resultante no serán del todo correctos. No obstante, como el coloreado es en realidad solo un sombreado sutil y no un borde marcado, parece funcionar bien en este ejemplo. Conviene, sin embargo, tener precaución. Para el siguiente paso de los ejemplos de la «insignia», véase Insignia con pintura y máscara, que invierte el orden de las dos operaciones de composición, lo que requiere un conjunto de imágenes distinto.

Técnica de pintura y máscara

En lugar de «enmascarar y luego pintar», puedes usar un conjunto de imágenes distinto y superponer primero los colores adicionales, antes de enmascarar el fondo. Es decir, puedes realizar un «pintar y luego enmascarar». O sea, tomarías tu imagen y superpondrías el borde, que establece no solo todos los colores finales del borde, sino que también enmascara y colorea algunas o todas las partes exteriores a la imagen original. Luego usas una máscara «exterior» o «de recorte» separada para eliminar todas las partes no deseadas de la imagen resultante. Observa también que tanto la imagen de «superposición» como la de «máscara» definen el borde interior por separado del borde exterior del marco. Como resultado, una sola imagen no define por completo todo el borde en una única imagen, lo que puede hacerla un poco más difícil de usar. No obstante, puede ser más simple de implementar. Por ejemplo...

  magick -size 120x90 xc:none -fill black -stroke black -strokewidth 0 \
          -draw 'ellipse 45,45 55,37 0,360' \
          -channel RGBA -negate -blur 0x3  +channel \
          \( granite: -auto-level -blur 0,0.7 \) \
          -compose ATop -composite border_paint.png

  magick -size 120x90 xc:none -fill black -stroke black -strokewidth 5 \
          -draw 'ellipse 59,45 56,40 0,360' border_mask.png

  magick thumbnail.gif -alpha set \
          border_paint.png -compose Over  -composite \
          border_mask.png  -compose DstIn -composite \
          border_paint_mask.png

Observa cómo se eliminan algunas partes de los colores superpuestos. Esta es la característica clave de la técnica de pintura y máscara, que te permite usar una superposición más simple, que luego se ajusta con la máscara. Este método de enmascarado de imágenes es el que se usa en el siguiente conjunto de ejemplos de esquinas con vuelta de página, y de nuevo más adelante en Bordes de esquina elaborados más abajo.

Esquinas con vuelta de página

Fred Weinhaus creó un script de shell especial llamado PageCurl que añade una simple vuelta de página a una imagen existente, usando matemáticas muy complejas (en shell). Por ejemplo... |

  pagecurl thumbnail.gif  pagecurl.png

Internamente, en realidad usa la técnica de pintura y máscara. Es decir, primero superpone una «superposición de vuelta» ligeramente demasiado grande, luego borra (enmascara) el resto de la imagen, incluida una pequeña parte de la superposición, que se convertirá en la esquina transparente. Sin embargo, si quieres aplicar una vuelta de página a muchas imágenes, usar el script completo (de arriba) es una técnica bastante lenta. Al fin y al cabo, hace una enorme cantidad de procesamiento matemático (usando el propio IM como calculadora de coma flotante) para calcular y generar de verdad las imágenes de superposición y máscara apropiadas. Para aplicar una vuelta de página a muchas imágenes, es mejor usar el script una vez para generar la imagen de superposición y de máscara de transparencia una sola vez. Así que vamos a extraer esas dos imágenes para imágenes más pequeñas de 64x64 píxeles (usando una opción especial «-i "pagecurl"» añadida al script con este fin). |

  magick -size 64x64 xc: miff:- | pagecurl -e 0.3 -i "pagecurl" - null:

El comando anterior crea dos archivos de imagen: «pagecurl_overlay.png» y «pagecurl_mask.png», mostrados. La propia imagen de entrada no importa, ya que son las imágenes de máscara lo que queremos. El resultado de la «vuelta de página» simplemente se descarta usando el formato de archivo de imagen especial «[null:](files.html#null)». |

  magick thumbnail.gif -alpha set -gravity SouthEast \
          -define compose:outside-overlay=false \
          pagecurl_overlay.png -composite \
          pagecurl_mask.png  -compose DstIn -composite \
          pagecurl_thumbnail.png

Por supuesto, estas imágenes no tienen el mismo tamaño que nuestra miniatura ni, probablemente, que ninguna imagen a la que quieras aplicarla, pero eso no importa, ya que podemos usar un par de opciones extra para asegurarnos de que funcionen como se espera. En concreto, el ajuste «[-gravity](https://imagemagick.org/command-line-options/#gravity)» garantiza que las dos imágenes de superposición se sitúen en la esquina inferior derecha. Y el ajuste Define especial «compose:outside-overlay=false» evitará que la imagen de máscara borre las partes de la imagen no cubiertas por la imagen más pequeña. Véase Ajuste Outside-Overlay para una descripción completa. Si quieres aplicar esto a muchas imágenes, puedes usar «magick mogrify», con una técnica especial que implica usar «[-draw](https://imagemagick.org/command-line-options/#draw)» para hacer la composición alfa con Mogrify. Sin embargo, este método de composición no entiende el ajuste define especial, así que solo funcionará con imágenes, superposiciones y máscaras que tengan todas el mismo tamaño.

  pagecurl -e 0.5 -i /tmp/pagecurl  {_una imagen_} null:
  magick mogrify {_opciones -format y -path de magick mogrify_} -alpha set \
          -draw 'image Over 0,0 0,0 "/tmp/pagecurl_overlay.png"' \
          -draw 'image DstIn 0,0 0,0 "/tmp/pagecurl_mask.png"' \
          {_todas las imágenes a las que aplicar la vuelta de página_}...

Superposición de esquina elaborada

Aquí profundizamos un poco más en el uso de esta técnica de «doble enmascarado» para modificar una imagen de distintas maneras en distintas áreas, en lugar de aplicar una sola máscara o marco grande a toda la imagen. En este caso solo aplicaremos doble máscara a las esquinas. El resto del borde (para que combine) se añade por separado. Las imágenes de esquina que usaré se generaron a partir de la fuente original (mostrada a la derecha), que encontré en la sección de marcos caseros (DIY Frames) de la biblioteca de iconos de Anthony. Hay otras en esta sección, así que quizá quieras echar un vistazo. Si encuentras algo en la red, házmelo saber, ya que me gusta coleccionar esquinas y técnicas de bordeado interesantes. A partir de esa imagen inicial se generó una imagen de superposición de color y de máscara, para poder usar una técnica de pintura y máscara para superponer la esquina sobre la imagen. Observa que estas imágenes no usaron en realidad ningún píxel semitransparente, ni siquiera ningún sombreado de colores. Por eso, este borde elaborado puede usarse para producir miniaturas «GIF» de aspecto limpio para páginas web. La complicación de usar máscaras de esquina es que solo enmascaran las esquinas de la imagen original. Por eso, a la imagen original primero hay que darle el conjunto adecuado de colores de borde extra. Después, las dos máscaras de esquina deben componerse sobre cada una de las esquinas de la imagen ampliada. |

  magick thumbnail.gif   -alpha set  -compose Copy \
          -bordercolor Black  -border 2 \
          -bordercolor Sienna -border 3 \
          -bordercolor Black  -border 1 \
          -bordercolor None   -border 2 \
          -bordercolor Black  -border 2 \
          -bordercolor Peru   -border 3 \
          -bordercolor Black  -border 1 \
          \
          -compose Over \
          \( fancy_add.gif             \) -gravity NorthWest -composite \
          \( fancy_add.gif -flip       \) -gravity SouthWest -composite \
          \( fancy_add.gif       -flop \) -gravity NorthEast -composite \
          \( fancy_add.gif -flip -flop \) -gravity SouthEast -composite \
          -compose DstOut \
          \( fancy_sub.gif             \) -gravity NorthWest -composite \
          \( fancy_sub.gif -flip       \) -gravity SouthWest -composite \
          \( fancy_sub.gif       -flop \) -gravity NorthEast -composite \
          \( fancy_sub.gif -flip -flop \) -gravity SouthEast -composite \
          fancy_border.gif

| Observa que, para conservar el borde transparente que se está añadiendo, debes establecer el ajuste «[-compose](https://imagemagick.org/command-line-options/#compose)» en «Copy» en lugar del valor por defecto «Over». Si no lo haces, la transparencia se rellenará con el siguiente color de borde añadido, en este caso «Black». Véase el operador Border para más detalles.
---|---
La ventaja de usar solo máscaras de esquina es que cualquier imagen de cualquier tamaño puede enmarcarse con esta técnica, siempre que sea lo bastante grande para las máscaras de esquina que se añaden. Es decir, no estás limitado por el tamaño de las imágenes de enmarcado que tengas disponibles. Por supuesto, cada una de las cuatro imágenes de esquina y los bordes son iguales por todo el contorno de la imagen, solo que rotados. Es decir, el efecto de sombra o grosor es todo «hacia dentro». Para arreglarlo, necesitarías generar una pieza de esquina distinta para cada una de las esquinas, y la adición de los bordes extra alrededor de la imagen original tendría que ser asimétrica. Básicamente, se vuelve mucho más complejo, para producir verdaderos efectos de sombra. Una solución mejor sería eliminar el efecto de sombra de la pieza de esquina, aplicarla como antes y luego añadir los efectos de sombra de forma global. Se necesita precaución.

Insignia con pintura y máscara

El mismo procesamiento de imagen de insignia visto antes en Superposición de insignia y Insignia con máscara y pintura también puede realizarse pintando y luego enmascarando. Aquí primero pintamos todos los colores y sombras sobre la imagen y luego enmascaramos la transparencia final de la imagen.

  magick thumbnail.gif -alpha set -gravity center -extent 90x90 \
          badge_paint.png -composite badge_shape.png -compose DstIn -composite \
          badge_paint_mask.png

Si esto parece engorroso para esta imagen concreta, tienes razón, lo es. La razón es que no solo necesitamos sombrear y resaltar la imagen original, sino que también necesitamos rellenar de negro cualquier área que vaya a contener efectos de sombra. En concreto, cualquier parte que vaya a quedar totalmente transparente (y solo los píxeles que realmente sean totalmente transparentes) tendrá que pintarse de negro. Por otro lado, los píxeles semitransparentes con efectos de sombra tendrán tanto un efecto de sombreado parcial como una máscara de transparencia parcial. En otras palabras, las sombras hacen engorrosa una técnica de pintura y máscara que de otro modo sería simple, en la división de los efectos de pintura y enmascarado. Por eso una técnica de pintura y máscara no suele usarse al tratar con adiciones semitransparentes a una imagen, como al añadir sombras o estrellas de destello. Si la imagen no contuviera ningún efecto de transparencia, el proceso de pintura no resulta tan horrible, y en muchos casos puede ser más simple que otras técnicas, ya que puedes «recortar» las superposiciones pintadas con la máscara al terminar. El ejemplo de vuelta de página era un caso así, ya que usamos la máscara para recortar la superposición de la vuelta y hacer un conjunto sin costuras. Observa también el hueco entre la región negra dura y los efectos de sombreado en la imagen de pintura. Este hueco refleja la advertencia que mencioné antes sobre asegurarte de no solapar los resultados de cualquier enmascarado interno con los bordes de cualquier máscara externa de pintura/superposición. Solo en este caso concreto este hueco necesario se vuelve tan evidente. Para el siguiente paso de los ejemplos de la «insignia», véase Insignia con efectos de iluminación, que fusiona las dos imágenes de máscara en una sola imagen de máscara/sombreado.

Técnica de máscara de iluminación

Botón de burbuja de cristal

El siguiente nivel de complejidad en el procesamiento de miniaturas es la aplicación de efectos de iluminación muy complejos. Lo delicado aquí no es tanto la aplicación de un efecto de iluminación a una imagen, sino la generación del efecto de sombreado apropiado. Por ejemplo, usando un efecto Aqua puedes dar a una miniatura un efecto de sombreado muy complejo que hace que parezca encerrada en una «burbuja» de cristal. Además, esto funciona mejor con una miniatura que tenga esquinas redondeadas. Vamos a generar una máscara de esquinas redondeadas para nuestra imagen de miniatura, usando un color gris puro. |

  magick thumbnail.gif -alpha off -fill white -colorize 100% \
     -draw 'fill black polygon 0,0 0,15 15,0 fill white circle 15,15 15,0' \
     \( +clone -flip \) -compose Multiply -composite \
     \( +clone -flop \) -compose Multiply -composite \
     -background Gray50 -alpha Shape    thumbnail_mask.png

Ahora que tenemos una «máscara de forma» gris pura que queremos usar, puedo aplicar el efecto Aqua para generar una superposición de iluminación para esta forma. |

  magick thumbnail_mask.png -bordercolor None -border 1x1 \
          -alpha Extract -blur 0x10  -shade 130x30 -alpha On \
          -background gray50 -alpha background -auto-level \
          -function polynomial  3.5,-5.05,2.05,0.3 \
          \( +clone -alpha extract  -blur 0x2 \) \
          -channel RGB -compose multiply -composite \
          +channel +compose -chop 1x1 \
          thumbnail_lighting.png

Con una imagen de superposición final de luz/sombra como la anterior, podemos aplicarla fácilmente a cualquier imagen de miniatura del tamaño adecuado. |

  magick thumbnail.gif -alpha Set thumbnail_lighting.png \
          \( -clone 0,1 -alpha Opaque -compose Hardlight -composite \) \
          -delete 0 -compose In -composite \
          glass_bubble.png

Esto no solo añade los efectos de sombreado apropiados a cualquier miniatura de este tamaño, sino que la misma imagen de iluminación enmascara la miniatura para darle la forma adecuada. Es importante señalar que solo se usan los canales de color para aplicar el efecto de iluminación; el canal alfa no se usa en este proceso. De forma similar, al enmascarar solo se usa el canal alfa, no los canales de color. Sin esta separación de canales para distintos efectos, no obtendrás el resultado correcto. Para una discusión sobre cómo extraer un efecto de iluminación de las imágenes, véase el tema del foro de usuarios de IM Extracting light layer from two images.
Sin embargo, esto puede llevarse mucho más lejos, ya que también podemos añadir efectos de sombra directamente a esta máscara de iluminación. No obstante, el color añadido debe ser negro puro, y debes asegurarte de que la composición del efecto de iluminación elegida produzca una imagen perfectamente negra si la máscara de iluminación es negra. Pero, en realidad, así es como se añaden normalmente los efectos de sombra a una imagen, de modo que puedes simplemente añadir sombras directamente a la «máscara de efecto de iluminación», ¡y todo irá bien! Lo mismo ocurre con añadir «destellos» de luz, pero usando solo píxeles blancos para la superposición de destello. En esencia, una «imagen de efecto de iluminación» puede volver a fusionar las dos imágenes de máscara y pintura en una sola imagen. Como verás en el siguiente ejemplo.

Insignia con efectos de iluminación

Usando las imágenes de la técnica de Insignia con máscara y pintura, las apliqué a una imagen de lienzo gris puro, para generar rápidamente una imagen de «efecto de iluminación enmascarado». En realidad, también podría haber usado igual de fácilmente el otro estilo de enmascarado (Insignia con pintura y máscara). Luego aplico la única imagen de máscara a la miniatura, reproduciendo el resultado deseado.

  # fusionar las imágenes de «máscara y pintura» con una imagen gris,
  # para crear una «máscara de iluminación»
  magick -size 90x90 xc:gray50 -alpha set \
          badge_mask.png -compose DstIn -composite \
          badge_shading.png -compose Over -composite \
          badge_lighting.png

  # Aplicar la única «máscara de iluminación»
  magick thumbnail.gif -alpha set -gravity center -extent 90x90 \
          badge_lighting.png \
          \( -clone 0,1 -alpha Opaque -compose Hardlight -composite \) \
          -delete 0 -compose In -composite \
          badge_final.png

En realidad, me gusta bastante esta forma de enmascarado, ya que la propia imagen de máscara se ve casi idéntica a la imagen que buscas, solo que faltan los colores. Eso es, al fin y al cabo, cómo se crea una máscara de iluminación: simplemente aplica los efectos a una imagen gris perfecta y obtienes una imagen de «máscara de iluminación». Solo recuerda que, con esta técnica concreta, la sombra semitransparente debe ser negro puro para que funcione bien. No puedes usar un color gris para ningún píxel que no contenga al menos parte de la imagen original. Todas las áreas transparentes y semitransparentes deben ser de color blanco o negro puro, con el nivel adecuado de transparencia alfa. ¿Por qué funciona una sola imagen? ¡Antes necesitábamos dos imágenes! La respuesta es que la imagen de máscara se limita solo a añadir tonos de color negro o blanco puro. Al hacerlo, el efecto de sombreado (iluminación) y su máscara quedan esencialmente fusionados en el componente de color de la «máscara de efecto de iluminación». Como resultado, el canal alfa queda libre para contener la máscara de transparencia, antes separada, de la imagen final. La limitación de esto, sin embargo, es que solo puedes añadir tonos blancos y negros a la imagen. No puedes añadir, por ejemplo, un color gris a la imagen que se enmascara. No obstante, ten en cuenta que es posible añadir algunos tintes de colores primarios y secundarios de algún espacio de color, pero solo de forma limitada, y nunca lo he visto usar. En resumen, no puedes añadir colores específicos ni bordes elaborados a la imagen, solo tonos y sombras, reflejos y destellos, o texto simple en blanco o negro. Sin embargo, no deberías intentar mezclar o solapar efectos blancos y negros añadidos, ya que los píxeles grises de suavizado de bordes resultantes entre ambos producen un color sombreado a partir de la imagen subyacente, y no el color gris esperado. ¡Ese es, en definitiva, el inconveniente de esta técnica!

Enmascarar imágenes con distorsiones...

Lo que es aún más increíble es que, como los colores de sombreado son solo una imagen en escala de grises, puedes comprimir los efectos de iluminación a un solo canal de color y la máscara del canal alfa. ¡Esto puede usarse luego para liberar dos canales de color de la imagen para otros efectos de procesamiento de imágenes! Es decir, puedes almacenar otras cosas en la única «imagen de máscara». En concreto, ¡puedes añadir efectos de distorsión en la misma imagen de máscara! Para más información sobre esto, véase Imagen de distorsión unificada, que hace exactamente eso. Una especie de imagen de máscara definitiva.

Enmarcado con imágenes de borde

Una forma habitual de añadir un borde complejo a una imagen es usar imágenes de enmarcado preparadas de antemano, para producir un marco como el del ejemplo mostrado (a la derecha). No obstante, también debes tener cuidado al generar marcos. Si miras con atención el ejemplo dado, notarás que no está del todo bien. El sombreado del marco generado es en realidad incorrecto. Los bordes izquierdo e inferior del marco deberían intercambiarse para producir un marco correctamente sombreado para una fuente de luz típica en la parte superior izquierda. Por eso, antes incluso de empezar, me gustaría subrayar la importancia de usar la imagen correcta, o la imagen correctamente modificada, para cada borde al enmarcar tu miniatura o foto. Es muy fácil equivocarse, así que comprueba dos veces tus resultados cuando creas que lo tienes bien.

Las imágenes de borde del marco

Hay muchos tipos de imágenes que pueden usarse para enmarcar una imagen. Por ejemplo, aquí tienes un marco «negro fino con ribete dorado» que se modificó a partir de imágenes proporcionadas por Michael Slate .

Hay dos imágenes, para proporcionar dos efectos de iluminación distintos, una para los bordes superior e izquierdo, la otra para los bordes inferior y derecho. Sin embargo, los colores a lo largo de la imagen no varían. Por eso puedes embaldosar o estirar este marco para producir la longitud necesaria. Un conjunto similar de piezas de enmarcado son estas imágenes de borde embaldosable «dorado ornamentado fino».

Como estas imágenes tienen algo de detalle fino, no puedes simplemente estirar la imagen a la longitud deseada. Tampoco puedes simplemente rotar de forma rectangular estas piezas para producir las otras piezas de borde, ya que al hacerlo el sombreado del detalle fino quedaría mal. No obstante, una distorsión de transposición diagonal sí debería dar el sombreado correcto para los otros bordes. Se aconseja precaución extra al revisar tus resultados, para asegurarte de que tanto el sombreado general como el del detalle fino sean correctos en los cuatro lados de la imagen. Por último, una imagen de enmarcado puede consistir en una sola imagen que puede usarse para generar todos los bordes del marco, como esta imagen de marco embaldosable de «bambú».

La razón por la que solo se necesita una imagen es que el marco no tiene un «interior» o «exterior» específico. Aunque el marco sí tiene efectos de iluminación tanto generales como de detalle fino que requieren que de nuevo tengas cuidado con cómo rotas/volteas/transpones la imagen para los otros bordes. El mayor problema de este marco es que, si simplemente lo embaldosas tal cual, el macrodetalle se vuelve muy regular, y por eso quizá necesites aleatorizar el desplazamiento de baldosa, o incluso aleatorizar las longitudes de las piezas que se concatenan, para darle un aspecto más natural. Más sobre esto después. Como puedes ver, las imágenes de enmarcado pueden venir en una variedad de estilos, y hay que tener cuidado de manejar las imágenes de borde elegidas de la forma correcta (respecto a la imagen de iluminación) al generar las otras imágenes de borde que faltan.

Alargar las piezas de enmarcado

Ahora bien, en cualquier uso de estas imágenes de enmarcado, necesitaremos crear piezas más largas que cubran la longitud de las dimensiones de la imagen. Solo hay dos formas básicas de hacerlo. Puedes simplemente estirar la imagen del marco usando redimensionado (sin conservar la relación de aspecto) para obtener las longitudes correctas. Esto funciona para el primer conjunto de piezas mostrado arriba, que no tienen detalle interno, pero no es apropiado para ninguna de las otras imágenes de enmarcado presentadas. Básicamente, distorsionará el detalle interno y puede convertirse en una distracción para el aspecto de la imagen final. No obstante, el otro método de alargamiento, el embaldosado, puede usarse para cualquier imagen de enmarcado que tenga un patrón o detalle repetitivo, que es el caso de todas las imágenes presentadas arriba. Si estás creando tus propias piezas de enmarcado, ten cuidado de que las baldosas encajen bien, y en un límite de píxel, para asegurarte de tener un color uniforme y un ciclado adecuado del detalle en tus imágenes de enmarcado. Si no lo haces, puedes obtener una unión de aspecto artificial entre las baldosas, que se hace evidente por la repetición de las baldosas. En el mundo real, los enmarcadores de cuadros también tienen el mismo problema al unir piezas para hacer piezas más largas. Básicamente, es muy fácil obtener dos tonos distintos de madera, o un patrón de veta muy distinto, que, al unirse «a cola de milano», hace la unión muy evidente. Así que de verdad no estás solo en este problema. Las imágenes de enmarcado de «bambú» necesitarán embaldosarse. Aunque, como el detalle se restringe a una pequeña área de la imagen, puedes obtener algunos efectos de embaldosado aleatorio interesantes, que quizá necesiten algo de alargamiento y acortamiento aleatorio de las piezas para eliminarse. No obstante, no entraré en esto, y lo dejaré como ejercicio para quienes quieran. Para nuestros ejemplos, y porque funciona para casi todas las imágenes de enmarcado, usaré un método de embaldosado constante simple para generar las longitudes de borde más largas necesarias.

Concatenación demasiado simplista

Podemos simplemente alargar el marco «bambú» simple de arriba, embaldosándolo a la longitud correcta y luego concatenando las imágenes juntas. El embaldosado se hace simplemente con el generador de imágenes especial lienzo embaldosado «[tile:](canvas.html#tile)» para embaldosar una imagen que se está leyendo. |

  magick thumbnail.gif \
          \( -size 90x14  tile:bamboo.gif -transpose \) \
          \( -size 90x14  tile:bamboo.gif -transpose \) -swap 0,1 +append \
          \( -size 148x14 tile:bamboo.gif \) \
          \( -size 148x14 tile:bamboo.gif \) -swap 0,1 -append \
          frame_append.gif

Observa que los tamaños usados en los dos ejemplos anteriores se calcularon a partir del ancho conocido (10 píxeles) de la imagen de enmarcado y del tamaño de la imagen que se enmarca (120x100 píxeles). Tendrás que ajustar los argumentos de redimensionado adecuadamente para tus imágenes. Un problema con el embaldosado de piezas de enmarcado (como el bambú) es que todos los bordes parecen copias exactas unos de otros. Es decir, el enmarcado parece artificial. En la vida real, el marco se habría cortado con desplazamientos prácticamente aleatorios, a partir de piezas más largas de madera real o, en este caso, de bambú. Para arreglarlo, también tendrás que dar a esas baldosas un desplazamiento de baldosa ligeramente distinto para cada borde de la imagen. |

  magick thumbnail.gif \
          \( -size 90x14  -tile-offset +50+0 tile:bamboo.gif -transpose \) \
          \( -size 90x14  -tile-offset +0+0  tile:bamboo.gif -transpose \) \
          -swap 0,1 +append \
          \( -size 148x14 -tile-offset +70+0 tile:bamboo.gif \) \
          \( -size 148x14 -tile-offset +25+0 tile:bamboo.gif \) \
          -swap 0,1 -append       frame_tile_offset.gif

Este método de enmarcado no está mal para este tipo concreto de imagen de borde, aunque para otros tipos de marcos puede quedar muy ridículo. Básicamente, las esquinas no son correctas, y para la mayoría de los marcos de verdad quieres que las imágenes de borde se encuentren en una unión en ángulo de 45 grados, igual que tendrías en un marco de cuadro real. Una solución a esto es pregenerar a mano imágenes de esquina apropiadas que podamos superponer sobre esta imagen para corregirla. Esto funciona bien para una imagen de enmarcado estirable simple (como la imagen de enmarcado «negro fino»), pero fallará bastante mal para una imagen embaldosable como el «bambú», ya que la imagen de esquina probablemente no encajará bien con la imagen de baldosa. La mejor forma es generar las uniones de esquina directamente a partir de las imágenes de borde embaldosadas. Y te mostraré métodos para hacer esto más adelante.

Enmarcado por superposición extendida

Además, puedes hacer que este tipo de enmarcado de borde quede aún mejor extendiendo los marcos más allá de los límites de la imagen original. Esto se ve a menudo en cuadros de tipo «Hogar, dulce hogar». Para hacerlo, primero tendrás que ampliar la imagen original con mucho espacio extra en el que se superponen las piezas de marco más largas.

  magick thumbnail.gif -alpha set -bordercolor none -border 34 \
          \( -size 144x14 -tile-offset +30+0 tile:bamboo.gif -transpose \) \
          -geometry +20+10 -composite \
          \( -size 144x14 -tile-offset +45+0 tile:bamboo.gif -transpose \) \
          -geometry +154+0 -composite \
          \( -size 178x14 -tile-offset +60+0 tile:bamboo.gif \) \
          -geometry +0+20 -composite \
          \( -size 178x14 -tile-offset +0+0  tile:bamboo.gif \) \
          -geometry +10+124 -composite \
          frame_overlaid.gif

Observa que las medidas y el posicionamiento para este tipo de enmarcado no son simples, y podrían usar algo de aleatorización, como la que codifiqué de forma fija en el ejemplo anterior. Además, puedes mejorar aún más el aspecto redondeando los extremos de las longitudes de marco, con algo de sombreado adicional y apropiado. Una forma mucho mejor de enmarcar imágenes de esta manera es generar la imagen de enmarcado como una unidad completa, y simplemente superponerla sobre una imagen de tamaño fijo (véase Superposición de borde simple). No obstante, hacer esto significa que ya no puedes aleatorizar ligeramente las longitudes y posiciones de cada pieza de enmarcado.

Uniones de esquina a 45 grados

La mejor solución es añadir de algún modo las imágenes de enmarcado alrededor de la miniatura de forma que se cree de verdad una unión de 45 grados en cada una de las esquinas del marco. Esto no es fácil, y pasé por varios métodos de dibujo y enmascarado hasta que redescubrí un operador mágico llamado Frame, bordes tipo 3D. La solución entonces fue simple. Lee la imagen y «enmárcala» con «[-frame](https://imagemagick.org/command-line-options/#frame)», para crear una plantilla de las áreas a enmarcar. |

  magick thumbnail.gif -alpha set -bordercolor none \
          -compose Dst_Out -frame 15x15+15  frame_template.gif

Ahora observa que esta plantilla tiene algunas características interesantes. Primero, es transparente en el centro, donde se situará la imagen principal. Segundo, tiene cuatro y solo cuatro colores distintos que definen cada área en la que queremos colocar nuestras imágenes de enmarcado. No genera píxeles de «suavizado de bordes» de colores variables en las esquinas. Observa que, para facilitar las cosas, el ancho de esas áreas (15 píxeles) es el ancho de las piezas de enmarcado que añadiremos a la imagen. Si los bordes verticales tuvieran un grosor distinto al de los bordes horizontales, esta técnica no funcionaría muy bien. De hecho, pocos métodos funcionarían bien en tal situación. Esta imagen es la plantilla de enmarcado y, embaldosando cada una de nuestras piezas de enmarcado en las cuatro áreas de distinto color usando primitivas de relleno de color, obtendremos nuestras uniones de esquina a 45 grados, de forma muy simple y fácil. Por ejemplo... |

  magick frame_template.gif \
          -tile blackthin_top.gif -draw 'color 1,0 floodfill' \
          frame_top_filled.gif

Puedes repetir este proceso para los otros tres bordes. Usando transposiciones para asegurarte de que los reflejos y las sombras del detalle interno sigan siendo correctos. |

  magick frame_template.gif \
          -tile blackthin_top.gif   -draw 'color 1,0 floodfill' \
          -tile-offset +0+105 -tile blackthin_btm.gif \
                                       -draw 'color 15,105 floodfill' \
          -transpose \
          -tile blackthin_top.gif      -draw 'color 1,0 floodfill' \
          -tile-offset +0+135 -tile blackthin_btm.gif \
                                       -draw 'color 15,135 floodfill' \
          -transpose \
          -gravity center thumbnail.gif -composite frame_filled.gif

A partir de una discusión del foro de IM 45 degree frame joints se encontró una solución más simple, que implica rotar de antemano el borde inferior. Aquí está el ejemplo completo usando el registro en memoria para guardar las imágenes intermedias. |

  magick thumbnail.gif                -write mpr:image    +delete \
          goldthin_top.png             -write mpr:edge_top +delete \
          goldthin_btm.png -rotate 180 -write mpr:edge_btm +delete \
          \
          mpr:image -alpha set -bordercolor none \
          -compose Dst -frame 25x25+25  -compose over \
          \
          -tile mpr:edge_btm \
          -transverse -draw 'color 1,0 floodfill' \
          -transpose  -draw 'color 1,0 floodfill' \
          -tile mpr:edge_top \
          -transverse -draw 'color 1,0 floodfill' \
          -transpose  -draw 'color 1,0 floodfill' \
          \
          mpr:image -gravity center -composite    frame_gold.png

Como puedes ver, todavía tenemos un problema: queda muy artificial en la esquina superior izquierda e inferior derecha, debido a un efecto de espejo diagonal que resulta del embaldosado. Para arreglarlo, necesitamos añadir un «[-tile-offset](https://imagemagick.org/command-line-options/#tile-offset)» aleatorizado, para eliminar este efecto de espejo. | El ajuste Tile Offset estaba roto antes de la versión 6.3.9-9 de IM, en que el desplazamiento «X» se usaba para los valores de desplazamiento tanto «X» como «Y» (el valor «Y» dado se ignoraba). Esto significa que el ejemplo anterior probablemente embaldose de forma incorrecta los bordes inferior y derecho en versiones más antiguas de IM.
---|---
Versión con scriptEsto necesita reescribirse usando el último ejemplo como plantilla Por supuesto, puedes hacer todo lo anterior en un solo comando. No obstante, hagámoslo de forma programada. Esta versión usa algo de código en línea para generar imágenes de borde apropiadas a partir de las imágenes base proporcionadas usando distorsiones simples y algunos desplazamientos de imagen (rolls) aleatorizados para mejorar el aspecto general de la imagen embaldosada. Estos pueden ajustarse según el tipo de imagen de borde de enmarcado proporcionada. Las imágenes de borde procesadas se embaldosan luego usando una técnica de imagen de baldosa en memoria y la plantilla de marco (generada) se usa para enmascarar esas imágenes, como hicimos antes.

  image=thumbnail.gif
     image_w=`magick $image -format %w info:`
     image_h=`magick $image -format %h info:`

  top=goldthin_top.png
  btm=goldthin_btm.png

     width=`magick $top -format %h info:`
     length=`magick $top -format %w info:`

  # Tamaño de la imagen nueva (usando aritmética de enteros de BASH)
  new_size=$(($image_w+$width*2))x$(($image_h+$width*2))

  # Opciones de IM para leer una versión 'desplazada al azar' de las piezas de borde
  lft="( $top -roll +$(($RANDOM % $length))+0  -transpose )"
  rht="( $btm -roll +$(($RANDOM % $length))+0  -transpose )"

  # Opciones de IM para 'desplazar al azar' las piezas superior e inferior
  top="( $top -roll +$(($RANDOM % $length))+0 )"
  btm="( $btm -roll +$(($RANDOM % $length))+0 )"

  # Enmarcar la imagen en un solo comando de IM....
  magick -page +$width+$width  $image  +page -alpha set \
    \( +clone -compose Dst -bordercolor none -frame ${width}x$width+$width \
       -fill none -draw "matte 0,0 replace" \
          -flip   -draw "matte 0,0 replace"   -flip \) \
    \( $top $btm -append -background none -splice 0x${image_h}+0+$width \
       -write mpr:horz +delete -size $new_size tile:mpr:horz +size \
       -clone 1  -compose DstOut -composite \) \
    \( $lft $rht +append -background none -splice ${image_w}x0+$width+0 \
       -write mpr:vert +delete -size $new_size tile:mpr:vert +size \
       -clone 1  -compose DstIn -composite \) \
    -delete 1  -compose Over  -mosaic   framed_script.png

Y ahí tenemos una imagen perfectamente enmarcada con uniones de esquina a 45 grados, con desplazamientos de embaldosado aleatorizados. Sí, es un ejemplo complejo. Pero eso es para permitir el uso de imágenes de baldosa en memoria, de modo que podamos preprocesar las imágenes de enmarcado, todo en un solo comando. Esto lo hace más complejo, pero también más versátil. El código anterior se ha integrado en un script de shell, que puedes descargar («[frame_edges.tar.gz](../static/img/scripts/frame_edges.tar.gz)» del directorio de scripts de ejemplo de IM). Este archivo tar incluye el script y un conjunto de imágenes de enmarcado, que el script sabe cómo procesar y usar. También añade un borde de «cartón» entre el marco y la imagen propiamente dicha.

Ejemplo futuro

Usar bordes embaldosados con piezas de esquina que combinen. Las imágenes de borde tendrán que encajar con piezas de esquina preparadas de antemano, pero también embaldosarse limpiamente a lo largo de la longitud fija de la imagen. Eso significa que toda la baldosa del borde puede necesitar algo de estiramiento o compresión para alinear las baldosas de borde con sus piezas de esquina. Para funcionar bien, las baldosas de borde deben repetirse al menos 3 o 4 veces a lo largo del borde más pequeño de la imagen. Un ejemplo de este tipo de borde/esquina embaldosado es la implementación de un borde de efectos de «hojas» o «flor de lis».