Ejemplos de ImageMagick -- Manejo de Archivos de Imagen

Prefacio e Índice de los Ejemplos de ImageMagick

Resumen de Formatos de Imagen

Lectura de Imágenes

• Modificadores de Lectura
• Manejo de Metacaracteres en Nombres de Archivo de Entrada

• Imágenes Comprimidas

  Guardado de Imágenes

• Escapes de Porcentaje en Nombres de Archivo

• Imágenes Comprimidas con GZip
• Atributos Guardados
• Imágenes Cifradas
• Escritura de Múltiples Imágenes (adjoin)
• Número Inicial de Secuencia (Escena)

• Escritura de una Imagen, Múltiples Veces

  Formatos de Archivo de Salida Especiales (Específicos de IM)

  miff: info: null: txt: sparse-color: histogram: mpr: mpc: fd: inline: clipboard: -- Leer/Escribir desde/hacia el portapapeles de windows ephemeral: -- Autoeliminar tras la lectura show:, win: y x: -- Mostrar Imágenes Directamente x: (como entrada) -- Capturar Pantalla y Redibujar Delegados y Codificadores para Formatos de Imagen

• Ejemplo de Delegado de Entrada

• Ejemplo de Delegado de Salida
• Listado de Delegados y Archivos Fuente
• Delegado de Impresión
• Lanzamiento de Comandos Externos
• Delegados de Postscript y PDF
• Conversión Directa de Formato por Delegado (taint)

• Otros Ejemplos de Delegados

  Manejo de Imágenes Realmente Enormes Largos Flujos de Muchas Imágenes, secuencias de Vídeo Para procesar una imagen, no solo necesitas operadores que trabajen sobre las imágenes, sino que también necesitas formas de leer y escribir la imagen en tantos formatos de archivo diferentes como sea posible. En esta sección examinamos los formatos de archivo de IM en general.

Resumen de Formatos de Imagen

Uno de los usos más comunes de ImageMagick no es modificar imágenes en absoluto, sino solo convertir (magick) una imagen de un formato de imagen a otro. De hecho esta fue la razón original de la creación de IM: este tipo de conversión de formato de imagen. Es por eso que el comando principal de IM se llama "magick". Con este fin, ImageMagick puede manejar una desconcertante variedad de formatos de imagen y de archivo. Añadido a esta variedad hay un gran número de formatos especiales de entrada y salida para imágenes de prueba integradas, creación simple de imágenes, y formatos de imagen específicos para programar scripts de shell, y programas. Para una lista completa, consulta la Página de Formatos de Imagen de IM en el sitio web de IM. Todo esto puede resultar abrumador para un nuevo usuario de ImageMagick. Mi mejor consejo es ignorar la mayoría de los formatos de archivo, ya que probablemente nunca los necesitarás. En su lugar concéntrate en lo que quieres hacer, e intenta hacerlo. Si no sabes cómo, intenta buscar un ejemplo en estas páginas y en la web. Para los formatos de imagen demostrados en los Ejemplos de IM, consulta Índice de Referencia, Formatos de Archivo.

Lectura de Imágenes

IM por defecto intentará determinar el tipo de formato de imagen mediante los códigos 'mágicos' de identificación de archivo que están dentro del propio archivo. Si esto falla sin embargo necesitarás especificar el formato del archivo de imagen usando el sufijo del archivo, o añadiendo un prefijo de formato. Algunos formatos no leerán ningún archivo e ignoran cualquier nombre de archivo dado. Estas son algunas de las imágenes integradas comunes...

  logo:      granite:     rose:

Algunas de ellas generarán imágenes basándose en argumentos dados como nombre de archivo y quizás una "[-size](https://imagemagick.org/command-line-options/#size)" extra que controla el tamaño final de la imagen...

  -size 30x30  canvas:red
  -size 30x30  gradient:yellow-lime
  -size 30x30  pattern:fishscales
  magick import:

En algunos casos incluso puedes usar múltiples formatos...

  -size 30x30  tile:pattern:gray95

Esto sin embargo es excesivo en este caso ya que el codificador de formato 'pattern:' tiene el codificador 'tile:' incorporado en él. Pero deja claro lo que pretendías hacer. IM también puede descargar una imagen que esté publicada en la 'world wide web' especificando la URL de esa imagen. Esto básicamente proporciona un codificador de imagen 'http:', que es por lo que funciona. |

  magick http://www.ict.griffith.edu.au/anthony/images/anthony_castle.gif \
          -resize 100x100 castle_logo.png

Como puedes ver este comando lee la imagen desde la WWW y la redimensiona antes de finalmente guardar el resultado en disco. | Cuando se da un prefijo de formato de archivo, cualquier sufijo dado como parte del nombre de archivo no tiene ninguna relevancia en la forma en que se lee el archivo. Esto de hecho es vital al leer algunos formatos de archivo como el manejo del formato de archivo "[text:](text.html#text)" frente al "[txt:](#txt)". Por supuesto si un generador de imágenes realmente lee un archivo de imagen para procesarlo de una forma especial (por ejemplo "[tile:](canvas.html#tile)") entonces los formatos de archivo del sufijo (o prefijo) volverán a ser importantes, como lo fueron en el último ejemplo
---|---
Se puede usar un prefijo especial de codificador "implicit::" para 'desactivar' cualquier uso de codificadores, permitiendo el uso de ':' en el nombre de archivo. Los nombres de archivo pueden tener los 'metacaracteres de archivo' especiales, como '*' y '?' incrustados en ellos. IM expandirá estos caracteres para generar una lista de nombres de archivo a leer, evitando la necesidad de un shell externo que lo haga, o problemas con los límites de longitud de la línea de comandos. Por ejemplo...

  magick montage  '*.jpg' -geometry 50x50+2+2  image_index.gif

Esto producirá una única imagen de índice de montaje de todos los archivos JPEG en el directorio actual. Sin embargo nota que necesité entrecomillar el argumento para evitar que mi shell de UNIX expandiera los nombres de archivo en lugar de ImageMagick. Consulta más abajo para una especificación más completa de "magick montage". Por supuesto los shells de linux también pueden expandir los caracteres '*' y '?' que se les pasan sin comillas. Sin embargo en algunos casos puedes encontrarte alcanzando los 'límites de la línea de comandos' si la lista de archivos se expande a un número muy grande de nombres de archivo. Aquí hay otros ejemplos de uso de un shell de linux para expandir el nombre de archivo...

  magick image_[0-9].gif  image_[1-9][0-9].gif  animation.gif
  magick image_?.gif  image_??.gif  image_???.gif  animation.gif
  magick image_(?|??|???|????).gif  animation.gif

Consulta también los Read Frames, Modificador de Lectura más abajo, para un número incremental con formato en el nombre de archivo. Si el nombre de archivo es simplemente la cadena de un solo carácter '-' IM lee la imagen desde la entrada estándar. |

  cat tree.gif | magick - -frame 5x5+2+2 read_stdin.gif

Nota que algunos formatos de archivo de imagen te permiten simplemente concatenar múltiples archivos de imagen juntos en un largo flujo multiimagen. Estos formatos incluyen los formatos de imagen simples PbmPlus/NetPBM, así como el propio formato de archivo especial de IM MIFF: |

  for image in eye.gif news.gif storm.gif
  do
    magick $image  miff:-
  done |
    magick - -frame 5x5+2+2 +append read_multiple_stdin.gif

El carácter especial '@' al inicio de un nombre de archivo, significa reemplazar el nombre de archivo, con el contenido del archivo dado. Es decir, ¡puedes leer un archivo que contiene una lista de archivos! |

  echo "eye.gif news.gif storm.gif" > filelist.txt
  magick @filelist.txt  -frame 5x5+2+2 +append filelist.gif

También puedes usar '@' con el nombre de archivo especial '-' para leer los nombres de archivo desde la entrada estándar. |

  echo "eye.gif news.gif storm.gif" |\
    magick @- -frame 5x5+2+2 +append filelist_stdin.gif

| La lectura de una lista de nombres de archivo desde un archivo usando la sintaxis '@' se añadió en IM v6.5.2-1.
---|---
| Como precaución de seguridad esto solo funciona con archivos de imagen reales. No funciona con generadores de imágenes como "rose:" o "label:string". Tampoco se puede usar para 'incluir' opciones de la línea de comandos desde un archivo.
---|---

Modificadores de Lectura o Ajuste de Extracción

Las imágenes se pueden modificar inmediatamente después de haber sido leídas en memoria, pero antes de que la(s) imagen(es) sean realmente añadidas a la secuencia de imágenes actual. Puedes especificar un ajuste "[-extract](https://imagemagick.org/command-line-options/#extract)". Por ejemplo, aquí recorto la imagen rose... |

  magick -extract 32x32+20+5 rose: +repage rose_extract.gif

O puedes añadir un modificador de lectura al final del nombre de archivo usando corchetes '[...]'. Por ejemplo... |

  magick 'rose:[32x32+20+5]' +repage  rose_read_modifier.gif

Nota sin embargo que los caracteres '[]' normalmente también son metacaracteres especiales del shell, así que si los usas es una buena idea entrecomillar el modificador adicional, para evitar que los shells de UNIX lo interpreten. Tanto el ajuste "[-extract](https://imagemagick.org/command-line-options/#extract)" como el modificador de lectura hacen el mismo trabajo, aunque el segundo anulará al primero. Además cuando usas un modificador, debes dejar que IM maneje cualquier metacarácter especial de expansión de archivos, como '*' y '?', ya que un shell de UNIX no 'encontrará' los archivos solicitados debido al modificador. Lo que en realidad hace en ese caso depende del shell. Por ello el nombre de archivo completo debe entrecomillarse al usar modificadores de lectura. El verdadero propósito de estos modificadores de lectura es limitar la cantidad de memoria necesaria, eliminando imágenes no deseadas o haciendo las imágenes más pequeñas, mientras las imágenes aún se están leyendo en memoria. Por ejemplo al leer un directorio completo de imágenes JPEG grandes. Aquí está la lista de todos los modificadores de lectura especiales (y ajustes "[-extract](https://imagemagick.org/command-line-options/#extract)") y sus efectos. Un '#' representa algún número.

'[#]' '[#-#]' '[#,#,#]' [#,#-#,#]'. Read Frames

Seleccionará subfotogramas específicos de un formato de archivo multiimagen a partir de la imagen que ha sido leída. El índice del número '#' dado especifica el número de fotograma a leer. Se pueden especificar múltiples índices ya sea en orden separado por comas o como un rango de índices. El índice de imagen comienza en cero para la primera imagen, 1 para la segunda y así sucesivamente. Si especificas un índice negativo entonces el conteo es desde el final de la secuencia de imágenes, en orden inverso, -1 para la última imagen, -2 para la penúltima imagen. Esta es exactamente la misma convención usada para los Operadores de Listas de Imágenes. Por ejemplo

magick document.pdf'[0]' first_page_of_pdf.gif magick animation.gif'[1-3]' second_to_fourth_frames.gif magick animation.gif'[-1,2]' last_then_the_third_frame.gif

También puedes hacer que IM lea imágenes basándose en una lista de números. Por ejemplo..

  magick 'image_%03d.png[5-7]' ...

leerá los archivos "image_005.png", "image_006.png", e "image_007.png". Con este método no puedes usar un índice negativo.

'[#x#]' Read Resize

A partir de la versión 6.2.6-2 de IM se añadió un nuevo modificador para ayudar a los usuarios de IM a manejar imágenes muy muy grandes. Este modificador redimensionará la imagen que se acaba de leer, inmediatamente antes de que esa imagen se añada a las otras imágenes ya en memoria. Esto puede tanto reducir imágenes, como ampliar imágenes. Por ejemplo... |

magick pattern:gray95'[60x60]' enlarged_dots.gif

Advertencia, el modificador de lectura actualmente no usa ninguno de los indicadores de redimensionado, como '!' (no preservar la relación de aspecto) o '>' (solo reducir imágenes más grandes). (¿quizás si lo solicitas?) También puedes usarlo como una forma alternativa de especificar el tamaño de un lienzo de color sólido. En realidad lo que ocurre es que está redimensionando la imagen por defecto de un solo píxel. Por ejemplo... |

      magick 'canvas:DodgerBlue[50x50]'  canvas_size.gif

El modificador es más importante cuando estás intentando leer muchísimas imágenes muy muy grandes, ya que cada imagen se redimensionará antes de leer la siguiente, produciendo un ahorro sustancial en la memoria total necesaria para manejar esas imágenes. Por ejemplo en lugar de...

  magick montage '*.tiff'  -geometry 100x100+5+5 -frame 4  index.jpg

que lee primero todos los archivos tiff, y luego los redimensiona. Puedes en su lugar hacer...

  magick montage '*.tiff[100x100]'  -geometry 100x100+5+5 -frame 4  index.jpg

Esto leerá cada imagen, y la redimensionará, antes de continuar con la siguiente imagen. Resultando en un uso de memoria mucho menor, y posiblemente evitando el intercambio a disco (thrashing), cuando se alcanzan los límites de memoria. Para imágenes JPEG también recomiendo que uses en su lugar el ajuste especial "[-define](https://imagemagick.org/command-line-options/#define)", produciendo algo como...

  magick montage -define jpeg:size=200x200 '*.jpg[100x100]' -strip \
          -geometry 100x100+5+5 -frame 4  index.png

El ajuste especial se pasa a la biblioteca JPEG y se usa para limitar el tamaño de la imagen JPEG durante el proceso de lectura. Sin embargo no es exacto, siendo la imagen resultante de algún tamaño entre ese tamaño o el doble de ese tamaño con la relación de aspecto preservada. Consulta Lectura de Imágenes JPEG para más detalles. El resultado de la combinación es una lectura mucho más rápida y un uso de memoria aún más bajo para imágenes JPEG. Especialmente al generar muchas miniaturas pequeñas. Consulta Creación General de Miniaturas.

'[#x#+#+#]' Read Crop

A partir de IM v6.3.1 si además añades un desplazamiento lo anterior se convierte en un recorte de la imagen que se está leyendo. Por ejemplo, para obtener una subsección más pequeña de 600x400 píxeles de una imagen mucho más grande.

magick 'image.png[600x400+1900+2900]' tileimage.png

Esto sin embargo leerá la imagen completa en memoria y luego la recortará antes de que finalmente se añada a la secuencia de imágenes actual. Si quieres manejar imágenes realmente grandes sugiero que examines el comando "[stream](basics.html#stream)" y canalices tu imagen al comando "magick" para procesamiento adicional. Consulta Manejo de Imágenes Enormes más abajo. Si la imagen está comprimida con "gzip", IM la descomprimirá automáticamente, en un archivo temporal antes de intentar averiguar el formato de imagen y decodificar el formato del archivo de imagen. De este modo no solo puedes guardar imágenes en formato comprimido con gzip, sino usarlas directamente en procesamiento posterior de IM. Para imágenes grandes basadas en texto esto puede resultar en enormes ahorros de espacio en disco. | El formato PNG incluye compresión "gzip" como parte de su especificación de formato. En este caso el primer dígito del ajuste de dos dígitos "[-quality](https://imagemagick.org/command-line-options/#quality)" de PNG define el nivel de compresión. Para más detalle consulta los ejemplos de Formato de Archivo de Imagen PNG.
---|---
Lo anterior es solo un breve resumen de las opciones de entrada especiales disponibles al leer imágenes en ImageMagick. Un resumen completo se da en la página La Anatomía de la Línea de Comandos en el Sitio Web de ImageMagick.
Como se mostró anteriormente la entrada de imagen puede ser modificada por algunos ajustes de IM como "[-size](https://imagemagick.org/command-line-options/#size)" para creación de imágenes y "[-define](https://imagemagick.org/command-line-options/#define) jpeg:size=??" para lectura de JPEG. Otras opciones también afectan la creación de la entrada de imagen, incluyendo, "[-page](https://imagemagick.org/command-line-options/#page)", "[-type](https://imagemagick.org/command-line-options/#type)", "[-dispose](https://imagemagick.org/command-line-options/#dispose)", "[-delay](https://imagemagick.org/command-line-options/#delay)". Consulta Establecimiento/Cambio de Metadatos de Imagen. | Ten mucho cuidado al pasar un argumento provisto por el usuario a IM en un script, asegurándote de que el argumento es lo que esperas. No quieres dejar que un script de procesamiento de imágenes web devuelva una imagen del archivo de contraseñas del sistema por ejemplo.
---|---

Manejo de Metacaracteres en Nombres de Archivo de Entrada

En Construcción

No solo el shell maneja metacaracteres (a menos que ese argumento esté
entrecomillado) sino que IM también hace su propia forma de manejo de metacaracteres en nombres de archivo.

Por ejemplo
  magick *.jpg ....

es expandido por el shell ANTES de pasar los nombres de archivo a IM, mientras que

  magick '*.jpg' ....

hará que el shell pase "*.jpg" a ImageMagick, que entonces lo expande en
una lista interna de nombres de archivo.  Esto fue provisto para soporte de Windows Dos, y
como un método para prevenir desbordamientos del límite de la línea de comandos en comandos como
"magick mogrify" y "magick montage", que típicamente procesan largas listas de imágenes.

Por ello para realmente conseguir que IM lea un archivo literalmente nombrado en disco como
'*.jpg'  necesitas usar cualquiera de las siguientes formas...

  magick '\*.jpg' ....
  magick "\*.jpg" ....
  magick "\\*.jpg" ....
  magick \\\*.jpg ....

NOTA; la segunda línea NO es recomendada ya que algunos shells (no bash) y algunas
APIs (programas en C, posiblemente PHP) pueden realmente eliminar la barra invertida simple, y
pasar '*.jpg' a IM que de nuevo lo expandirá.

Además de '?' y '*',  IM también añade el manejo de metacaracteres de  ':', '%'
y '[...]' para el manejo de modificadores de lectura.  Estos sin embargo tienen un
significado diferente  (especificación de códec, inclusión de número de escena, y modificadores de lectura) al
de la sintaxis normal del shell para esos metacaracteres.

Por ejemplo los usuarios de DOS necesitarán escapar una 'letra de unidad' en las rutas de nombre de archivo
que se pasan a ImageMagick.  Por ejemplo...

  magick C\:\path\to\image.jpg ....

Otro ejemplo es al cargar una imagen que contiene un código de tiempo.  Por ejemplo..

  magick "time_10\:30.jpg" ....

leerá el nombre de archivo "time_10:30.jpg" desde disco.  Sin la barra invertida, IM
puede pensar que la imagen debería leerse con un formato de archivo de imagen inexistente
(o delegado) "time_10:", y fallar de una forma inesperada.

Una alternativa es usar un signo de interrogación...

  magick "time_10?30.jpg" ...

¡Sin embargo eso también puede coincidir con otro archivo como "time_10_30.jpg"!

Compresión de Imágenes

En Construcción

IM también leerá archivos que han sido comprimidos, y dado el sufijo
apropiado, o especificación de formato de imagen.

Es decir, una imagen guardada como "image.gif.gz"  primero será descomprimida, antes de
ser decodificada desde su formato de imagen GIF.

Las imágenes XPixmap (xpm) y NetPbm/PbmPlus (ppm) comprimidas con gzip también se manejan
automáticamente, tanto por Imagemagick, como por la biblioteca delegada normal del formato.  Por
ello puedes usar las formas comprimidas directamente ya sea en IM, o en otros
programas que entiendan estos formatos de archivo.

Consulta  [Guardado de Imágenes Comprimidas](#save_gzip) más abajo.

Guardado de Imágenes

Procesar imágenes está muy bien pero puede ser igual de importante guardar los resultados de la forma correcta. El último argumento de "magick", "magick montage" y "magick composite" define un nombre de archivo, y un formato de imagen para una escritura final de la imagen (salida de imagen por defecto). Aunque también puedes guardar una imagen en medio de una secuencia de imágenes usando "[-write](https://imagemagick.org/command-line-options/#write)" (ver más abajo). Para especificar en qué formato de archivo quieres guardar tu imagen, o imágenes, puedes ya sea usar un sufijo de nombre de archivo, como uso en casi todos estos ejemplos, o prefijar el nombre de archivo con la cadena "{format}:". Por ejemplo... |

  magick tree.gif    GIF:tree_image

Si compruebas la imagen resultante verás que de hecho se creó un archivo de imagen GIF, aunque el propio nombre de archivo no tenga un sufijo ".gif". El formato no distingue entre mayúsculas y minúsculas, así que puedes usar minúsculas o mayúsculas. Esta especificación de formato de imagen se vuelve particularmente importante cuando quieres guardar la imagen en la salida estándar del comando (usando un nombre de archivo "-"). Este nombre de archivo especial no tiene un sufijo, así que debes decirle a ImageMagick qué formato usar. Si no lo haces, la imagen se predeterminará al formato de imagen original del que provino la imagen (si se conoce). Por ejemplo, aquí escribimos una enumeración de píxeles de IM a la pantalla usando un "-" para enviar el resultado a la salida estándar.

  magick tree.gif  -resize 1x3\!  txt:-

También se usa para pasar la imagen, a otro comando como "magick identify" a través de una 'tubería' (pipeline) del shell, sin guardarla en un archivo temporal.

  magick tree.gif -resize 200% miff:- | identify -

En este caso también puedes ver que el nombre de archivo especial "-" también se usa para denotar la lectura de una imagen desde la entrada estándar por el comando "magick identify". Para más información consulta la guía oficial en La Anatomía de la Línea de Comandos, Nombres de Archivo de Salida.

Escapes de Porcentaje en Nombres de Archivo

El nombre de archivo de guardado puede contener algunas secuencias de escape de porcentaje (%) especiales. Específicamente, '%d', '%x', y '%o'. Estas insertan el 'número de escena' de la imagen en el nombre de archivo usando los formatos de 'printf()' de C. Para más información consulta Escritura de una Secuencia Multiimagen más abajo. Por supuesto esto significa que si quieres insertar un carácter de porcentaje en el nombre de archivo necesitarás duplicarlo ('%%'). A partir de IM v6.4.8-4 ahora también puedes insertar un ajuste especial preparado de antemano (debe comenzar con 'filename:') en el nombre de archivo final. Por ejemplo... |

  magick rose: -set filename:mysize "%wx%h" 'rose_%[filename:mysize].png'

Esto guarda la imagen integrada rose en un archivo que contiene el tamaño de esa imagen en píxeles. Específicamente, el nombre de archivo "rose_70x46.gif". Esto te permitirá (con un poco de indirección) usar cualquier Escape de Porcentaje de Propiedad de Imagen como parte de tu nombre de archivo de salida. Nota que solo una Propiedad de imagen '%[filename:_label_]' puede usarse dentro del nombre de archivo de salida (junto con el escape '%d' normal). Esta restricción es por razones de seguridad y por el hecho de que nombres de archivo de imagen legítimos podrían incluir '% y '[]'. Advertencia, ¡no incluyas el sufijo de archivo en el ajuste filename! IM no lo verá, y guardará la imagen usando el formato de archivo original, en lugar del que se incluyó en el ajuste filename. Es decir, el nombre de archivo tendrá el sufijo que especifiques, ¡pero el formato de imagen puede ser diferente! El ajuste 'filename:' no necesita ser el mismo para cada imagen. Puedes generar o incluso calcular o establecer un ajuste diferente para cada imagen que se use. Aquí hay otro ejemplo donde modifico una imagen, y la escribo a un nuevo nombre de archivo, que se construyó usando el nombre de archivo original de cada imagen individual.

  magick eye.gif news.gif storm.gif    -scale 200% \
          -set filename:f '%t_magnify.%e' +adjoin '%[filename:f]'

Esto amplía cada imagen como "eye.gif" y la guarda en el archivo "eye_magnify.gif" en el directorio actual. Sin embargo las tres imágenes se leen en memoria, y luego se modifican por el único comando. Esta no es una solución recomendada para un número de imágenes grandes, o cantidades muy grandes de imágenes, debido a la posibilidad de alcanzar los límites de memoria y así pasar al intercambio a disco (thrashing). Nota que el "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)" en este caso es vital para evitar que IM guarde todas las imágenes en una animación GIF multiimagen, usando solo el nombre de archivo de la primera imagen. También me aseguré de preservar el sufijo original del nombre de archivo usando la secuencia de escape "%e". Normalmente incluir el sufijo en el ajuste filename es una mala idea, ya que IM no lo ve cuando viene de una secuencia de escape, para determinar el formato del archivo de salida. En este caso sin embargo el formato no está cambiando así que no hay problema. Se necesita cautela. Para obtener el nombre de archivo original exacto de la imagen usa '%d/%f' o '%d/%t.%e'. También puedes usar '%m' en lugar de '%e' que es el formato real (en mayúsculas) que IM encontró en el archivo original de las imágenes (que puede no coincidir con el sufijo del nombre de archivo original de las imágenes). Nota que para imágenes integradas, muchas de estas cadenas de secuencia de escape están en blanco. Además si no hay directorio el '%d estará en blanco. Este es un problema conocido para IMv7. Otro ejemplo de uso de la 'Secuencia de Escape de Nombre de Archivo' está en Recorte de Imágenes en Mosaico, donde la técnica se usa para generar un nombre de archivo basado en una posición de mosaico calculada para cada una de las imágenes resultantes. Consulta también el ejemplo en Uso de Convert en Lugar de Mogrify.

Sufijo GZip Automático

IM también comprimirá automáticamente las imágenes con "gzip" si se da un sufijo ".gz". Por ejemplo, aquí guardo la imagen integrada "rose:" como un archivo GIF sin comprimir, comprimido con "gzip". Desactivo la compresión LZW normal de GIF, ya que evitaría que la compresión "gzip" alcance su mejor compresión. |

  magick rose: -compress none  rose.gif.gz

Cómo manejan los navegadores una imagen comprimida con gzip depende del tipo de archivo devuelto por el servidor web y de cómo tu navegador maneja las imágenes comprimidas. Debido a esto no mostré directamente la imagen anterior. Haz clic en el icono de 'arte' para ver qué hace tu navegador, con una imagen así desde este servidor web. Compara el tamaño de esto con una imagen GIF comprimida con LZW guardada normalmente... |

  magick rose: rose.gif

La rose comprimida con "gzip" ocupa bytes de tamaño, mientras que una rose comprimida con LZW normal ocupa bytes. Como puedes ver la compresión GZIP es en realidad ligeramente mejor que la compresión LZW que usa el formato GIF, así que puede ser mejor para propósitos de archivado. Los archivos de imagen comprimidos con GZip se usan más comúnmente para almacenamiento a largo plazo de formatos de archivo de imagen que no tienen ninguna compresión por defecto. Esto incluye el formato de archivo de IM "MIFF:" y los formatos de archivo de imagen más simples NetPBM.

Atributos Guardados

En Construcción

Otros ajustes específicos de la escritura de imágenes....
    -depth  -quality  -compress -type  -loop
    -set label   -set comment
Consulta también [Profundidad de Imagen](basics.html#depth),
[Tipo de Imagen](basics.html#type),
[Calidad JPEG](formats.html#jpg_write),
[Calidad PNG](formats.html#png_quality).
[Bucle GIF](anim_basics.html#loop).

Hablar sobre las compresiones de archivo, que son parte de varios formatos de imagen.

Se usan diferentes compresiones para diferentes formatos de imagen.

Especialmente el cambio de compresión de JPEG a TIFF necesario.

Usando o "[-compress](https://imagemagick.org/command-line-options/#compress)
None" y la selección de formato de texto/binario NetPBM de "[-compress](https://imagemagick.org/command-line-options/#compress)".

La compresión GIF y la patente de copyright.

Aparte de usar IM para reducir -quality o cambiar el formato a otra
cosa, la opción -compression raramente se usa.  A menudo solo se usa internamente
por IM para guardar imágenes usando la misma compresión con la que se leyó la imagen.

Imágenes Cifradas

IM también te permite guardar imágenes sensibles cifradas con una frase de contraseña usando las opciones "[-encipher](https://imagemagick.org/command-line-options/#encipher)" y "[-decipher](https://imagemagick.org/command-line-options/#decipher)". Consulta Cifrado de Imágenes

Escritura de Múltiples Imágenes - Técnicas de Adjoin

Un problema importante al guardar imágenes, es que ImageMagick trabaja con una secuencia (lista) ordenada de imágenes, no solo una imagen a la vez. Debido a esto IM intentará escribir TODAS las imágenes en la secuencia de imágenes actual en el nombre de archivo dado. Si el formato de archivo permite múltiples imágenes IM por defecto guardará todas las imágenes en la secuencia de imágenes actual en ese archivo de imagen. Por ejemplo si miras la página de ejemplos Conceptos Básicos de Animación GIF verás que guardará múltiples fotogramas de imagen en un único formato de archivo de imagen para producir una animación. Si el formato de salida no te permite guardar múltiples imágenes en un solo archivo, IM en su lugar generará múltiples archivos. Por ejemplo, al guardar en formatos de imagen como JPEG y PNG y así sucesivamente. También puedes forzar este comportamiento en formatos de imagen que sí permiten múltiples imágenes por archivo, como GIF y PS usando el ajuste de manejo de archivo de salida "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)".

  magick eye.gif news.gif storm.gif  +adjoin  image.gif

  magick eye.gif news.gif storm.gif  +adjoin  image_%d.gif

Aquí generamos las imágenes "image_0.gif" a "image_2.gif", usando un guion bajo en lugar del guion por defecto de IM. | _No solo puedes usar '%d' para un número decimal, sino que puedes usar '%x' para un número hexadecimal (minúsculas), '%X' para un número hexadecimal (mayúsculas), o '%o' para un número octal.

_
---|---
| _Si realmente quieres un carácter de porcentaje que sea seguido por una de estas letras, entonces necesitarás duplicar el carácter de porcentaje para escapar su significado. Es decir, necesitarás usar '%%' para asegurar que realmente generas un símbolo de porcentaje.

---|---
| _El '%d' en el nombre de archivo de salida en realidad habilita el ajuste "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)" de ImageMagick, automáticamente.
Sin embargo aunque en realidad no necesito el "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)" en lo anterior, es probablemente una buena idea proporcionarlo de todos modos, solo para que quede claro que estás generando imágenes separadas.
---|---
Esto funciona bien para un número pequeño de imágenes, pero si tienes más de diez imágenes obtendrás una mezcla de imágenes con números de un dígito y de dos dígitos. Y si tienes más de cien, obtienes números de tres dígitos también. Cuando eso ocurre, los listados de directorio ya no listarán las imágenes guardadas en secuencia, ya que "image_15.gif" aparecería alfabéticamente antes de "image_5.gif". Por supuesto hay formas de arreglar esto. Por ejemplo usando expresiones del shell de la línea de comandos como..

  magick image_[0-9].gif  image_[1-9][0-9].gif  animation.gif
  magick image_?.gif  image_??.gif  image_???.gif  animation.gif
  magick image_(?|??|???|????).gif  animation.gif
  magick 'image_%d.gif[0-123]'  animation.gif

El último método es la forma correcta de IM de manejar una secuencia de archivos, aunque necesitas conocer el rango de números que quieres usar. El '%d' formatea cada número para que coincida con el nombre de archivo (ver siguiente). En cualquier caso, esto es engorroso y propenso a errores, puede producir errores si faltan archivos, y puede depender del tipo de sistema informático que estés usando. Mejor evitar este problema por completo. Si estás familiarizado con el lenguaje 'C' (consulta la página man del sistema UNIX para 'printf') entonces probablemente sabrás que si usas algo como "%03d" siempre obtendrás números de 3 dígitos (con ceros a la izquierda) para el número de fotograma de la secuencia de imágenes. Los nombres de imagen en ese caso serían "images_000.gif", "images_001.gif" y así sucesivamente.

  magick eye.gif news.gif storm.gif  +adjoin  image_%03d.gif

Usando este método, las imágenes no solo serán numeradas, sino que también se listarán alfabéticamente de forma correcta, haciendo el manejo de archivos de imagen mucho más fácil. Por ello recomiendo que añadas un '%03d' o lo que sea apropiado, al nombre de archivo de salida siempre que planees escribir múltiples imágenes, como archivos de imagen separados.

Números de Escena Escritos

Si quieres que la secuencia de imágenes comience en '1', en lugar de '0', y no quieres renombrar todos los archivos de imagen resultantes, la solución más simple es anteponer una imagen 'basura' al frente de la secuencia que se va a escribir.

  magick null:  eye.gif news.gif storm.gif  +adjoin  image_%01d_of_3.gif
  rm image_0_of_3.gif

Puedes, por supuesto, usar "[+insert](https://imagemagick.org/command-line-options/#insert)" para hacer esto después de tu procesamiento de imágenes. Esta no es una solución particularmente buena, pero funciona, y es simple, y compatible con versiones anteriores de las versiones principales más antiguas de IM. A partir de la versión 6.2 de IM puedes usar el ajuste "[-scene](https://imagemagick.org/command-line-options/#scene)" para establecer el número inicial de la secuencia de imágenes actual.

  magick eye.gif news.gif storm.gif  +adjoin -scene 101 image_%03d.gif

Lo que produjo los archivos de imagen "image_101.gif" a "image_103.gif".

Escritura de una Imagen, Múltiples Veces

Mientras estamos en el tema de escribir imágenes, es posible escribir una imagen desde el medio de una secuencia de operaciones de imagen, usando el operador especial de imagen "[-write](https://imagemagick.org/command-line-options/#write)". Esto es muy útil cuando te gustaría sacar una imagen múltiples veces en varios puntos durante el procesamiento de imágenes. Por ejemplo, consulta Procesamiento Complejo de Imágenes con Depuración. Aquí hay un ejemplo donde tengo una Foto de unos Loros, cortesía del Kodak Lossless True Color Image Suite (imagen 23), pero quiero guardarlos en un rango de diferentes tamaños, usando un solo comando...

  magick parrots_orig.png \
          \( +clone -resize x128  -write  parrots_lrg.jpg +delete \) \
          \( +clone -resize x96   -write  parrots_big.jpg +delete \) \
          \( +clone -resize x64   -write  parrots_med.jpg +delete \) \
                    -resize x32           parrots_sml.jpg

Como puedes ver podemos usar los Operadores de Lista de Imágenes para procesar un 'clon' de una imagen, escribir el resultado, luego eliminar y retroceder de vuelta a la imagen fuente original, repitiendo el proceso tantas veces como necesites. En este caso particular significa que no terminé redimensionando la misma imagen una y otra vez, y así acumulando errores de redimensionado. También significó que podría haber generado igualmente las imágenes más pequeñas primero, y luego las imágenes más grandes después de eso, sin problemas, o modificar la imagen de muchas formas diferentes para cada archivo de imagen generado. Es decir, ¡el orden y la modificación de cada imagen es irrelevante! Nota que "[+clone](https://imagemagick.org/command-line-options/#clone)" en realidad no duplica los datos de imagen. IM usa un proceso de clonación con conteo de referencias que solo copia los píxeles de la imagen cuando se actualizan. Por ello solo se usa realmente la memoria suficiente para contener la imagen original y la nueva imagen que se genera, en el proceso anterior. También hace que "[+clone](https://imagemagick.org/command-line-options/#clone)" sea muy rápido, y eficiente en memoria.
Aquí hay otra técnica para hacer lo mismo, pero guardando la imagen original en un registro de imagen nombrado usando "[MPR:](#mpr)" (ver abajo), en lugar de "[-clone](https://imagemagick.org/command-line-options/#clone)".

  magick scroll.gif  -background lightsteelblue -flatten  -alpha off \
          -write mpr:scroll  -resize x128  -write scroll_lrg.jpg +delete \
                 mpr:scroll  -resize x96   -write scroll_big.jpg +delete \
                 mpr:scroll  -resize x64   -write scroll_med.jpg +delete \
                 mpr:scroll  -resize x32          scroll_sml.jpg

Aquí guardamos una copia de la imagen original en el registro de imagen "mpr:scroll", antes de modificar la imagen que aún está en memoria después de la escritura. Nota que un registro MPR en realidad puede contener una secuencia completa de imágenes. Una vez que los resultados de esa operación se escriben y se eliminan de memoria, la imagen original (o secuencia de imágenes) se recupera, y el proceso se repite tantas veces como se necesite. Por supuesto como antes no hay necesidad de usar "[-write](https://imagemagick.org/command-line-options/#write)" en la imagen final, ya que podemos simplemente sacarla como de costumbre. Si usaste un "[-write](https://imagemagick.org/command-line-options/#write)", puedes en su lugar simplemente desechar la imagen final usando otro formato de archivo especial "[NULL:](#null)" (ver abajo).Una palabra de advertencia sobre "[-write](https://imagemagick.org/command-line-options/#write)": Debido a que algunos formatos de archivo requieren que las imágenes estén en un formato especial para la escritura, el operador "[-write](https://imagemagick.org/command-line-options/#write)" podría modificar imágenes. Las imágenes GIF por ejemplo pueden ser reducidas en color (consulta Cuantización y Difuminado). Sin embargo otros formatos dejarán la imagen fuente tal cual (consulta MIFF y MPC más abajo). Si necesitas protegerte de estos cambios (ya que no estás simplemente eliminando la imagen después), puedes usar "[+write](https://imagemagick.org/command-line-options/#write)" que hará un clon interno de la imagen para la escritura, luego lo eliminará después. Sin embargo recuerda que esto puede resultar en una duplicación del uso de memoria para contener la copia modificada para la escritura de la imagen. Al menos por un momento.

Formatos de Archivo Especiales (específicos de IM)

Como viste arriba (y explorarás en la siguiente sección Formatos de Archivo de Imagen Comunes), ImageMagick entiende un enorme número de formatos de archivo de imagen bien conocidos. También incluye un buen número de generadores de imágenes especiales (como se ejemplifica en Creación de Lienzos). Además de estos también hay algunos formatos de archivo muy especiales, que permiten un manejo muy especial de las imágenes.

miff:

Es el Formato de Archivo de ImageMagick. La secuencia de imágenes completa y todos los atributos asociados con las imágenes se guardan en este formato de archivo. Por supuesto solo los comandos de ImageMagick leerán este formato, así que no es adecuado para transferir entre diferentes paquetes de procesamiento de imágenes. El propósito principal del formato de archivo "miff:" es como un formato de guardado intermedio, al procesar imágenes de formas largas y complejas. También es adecuado para 'canalizar' una imagen de un comando de IM a otro, mientras se pasan los metadatos de imagen y otros atributos asociados con la imagen. Recomiendo que al escribir "miff:" incluyas una opción "[+depth](https://imagemagick.org/command-line-options/#depth)". Esto reiniciará la 'profundidad de entrada' de la imagen a la calidad de memoria de IM para usar la mejor calidad posible para el guardado de imagen intermedia. Por supuesto puedes 'recortar' la profundidad de la imagen guardada usando "-depth 8" para reducir el tamaño de la imagen en disco, sin embargo eso también forzará efectos de Redondeo de Quantum (a menos que también esté habilitado el guardado de punto flotante HDRI). Para aquellos interesados en analizar este formato, comienza con una cabecera de texto plano de todos los atributos de la imagen. La cabecera termina en una línea que contiene un único carácter de salto de página (formfeed). Esta cabecera es en sí misma una forma útil de extraer información básica de imagen en varios scripts de procesamiento de imágenes. Por ejemplo, aquí uso un comando GNU-sed para listar la cabecera "miff:" hasta el separador de salto de página, mostrando todos los atributos de la imagen integrada "rose:".

magick rose: miff:- | sed -n '/^\f$/q; p'

Esto es en realidad bastante útil ya que revela todos los indicadores de ajustes actuales y los metadatos que IM conoce sobre la imagen. Sin embargo también hay estadísticas, ya que estas son generadas ya sea por el comando "magick identify", el operador "[-identify](https://imagemagick.org/command-line-options/#identify)" o el formato especial "info:"; si se solicita con una opción "[-verbose](https://imagemagick.org/command-line-options/#verbose)". (ver siguiente) El formato de archivo de imagen tiene requisitos de análisis muy bajos, y aunque no está comprimido, puede manejar CUALQUIER tipo de imagen que IM conozca. Es casi el formato más ideal para usar para imágenes temporales, y comandos de imagen canalizados que puedas usar, aunque los programas de ImageMagick son los únicos que pueden leerlo. Consulta también el registro de memoria de imagen "[MPR](#mpr)", y los formatos de mapeo de memoria en disco "[MPC](#mpc)" más abajo. | _Los datos de imagen sin procesar (binarios) en realidad están precedidos por la secuencia de cuatro caracteres "\n\f\n:", (salto de página en una línea por sí solo, y dos puntos). Cómo deben leerse estos datos está codificado en los datos de la cabecera, pero típicamente consiste en enteros binarios en tuplas RGB. Pero puede tener más canales, e incluso podría consistir en valores de datos float o incluso double.

En muchos sentidos es prácticamente idéntico a un formato de archivo de imagen PbmPlus binario, con una cabecera enormemente expandida para contener los metadatos de imagen, y más variaciones en el número de canales y tipos de datos._
---|---

Transmisión de Imágenes MIFF

El formato "miff:" es un formato de archivo de imagen de 'transmisión' (streaming). Es decir, múltiples imágenes se manejan simplemente añadiendo o concatenando las imágenes juntas, una tras otra. Esto significa que puedes generar un 'flujo' de múltiples imágenes, simplemente escribiendo las imágenes al mismo destino, como una tubería. Incluso si las imágenes individuales fueron generadas por diferentes comandos. Por ejemplo puedes tener un bucle de comandos de procesamiento de imágenes, cada comando simplemente saca una imagen MIFF de 'transmisión'. Después del bucle puedes canalizar el 'flujo' de imágenes en un único comando para generar montajes, collages, animaciones, u otra cosa. Por ejemplo lo siguiente genera una lista de colores que comienzan con la letra 'b', luego usa un bucle de comandos "magick" para generar un parche de color etiquetado, un color a la vez. Estos luego se 'canalizan' a un "magick montage" para generar una tabla de colores simple.

magick -list color | egrep '^b' | \ while read color junk; do \ magick -label $color -size 70x20 xc:$color +depth miff:-; \ done |\ magick montage - -frame 5 -tile 6x -geometry +2+2 \ -background none color_table.png

El ejemplo específico anterior fue programado en un script "show_colors " que puedes usar para buscar, encontrar y mostrar colores, para usar en tu procesamiento de imágenes. Lo anterior es un ejemplo de una 'Tubería de Imágenes en Transmisión que es muy útil para generar secuencias multiimagen. Otros ejemplos de esta técnica incluyen Posicionamiento Programado de Imágenes en Capas, Alfileres en un Mapa, la 'Imagen de Colores con Nombre' en Colores por Nombre, y las animaciones como las mostradas en Ondas Aleatorias. Esta técnica también puede usarse con operaciones como "-write miff:-", para sacar una imagen en formato miff desde múltiples lugares en un solo comando. Cada imagen será automáticamente añadida junta en el flujo de salida final. Esto puede ser especialmente útil para depurar comandos complejos de procesamiento de imágenes. El método alternativo (comúnmente usado en scripts PHP) es usar una técnica de 'comando generado', que usa un script de shell para generar un largo comando "magick" para ser ejecutado. Los scripts en Animaciones de Deformación de Imágenes usan esta técnica.

info:

El formato de archivo "info:" (añadido en IM v6.2.4) ¡NO saca una imagen real! Este formato básicamente saca la misma información que sacará el comando "magick identify" de ImageMagick. Como "magick identify" este formato de salida está controlado por las opciones "[-format](https://imagemagick.org/command-line-options/#format)" y "[-verbose](https://imagemagick.org/command-line-options/#verbose)" permitiéndote sacar solo la información específica en la que estás interesado, como se define en la página de Escapes de Propiedad de Imagen. Por ejemplo en lugar de canalizar una imagen MIFF a "magick identify" como hicimos arriba (consulta Guardado de Imágenes), podríamos haber usado lo siguiente, para recuperar la identificación de una sola línea del formato de imagen resultante.

magick granite: info:-

Por supuesto puedes usar un ajuste "[-format](https://imagemagick.org/command-line-options/#format)" para sacar la información deseada de una forma específica y más analizable. Lo que es tan útil sobre "info:" es que ahora puedes producir tu imagen, mientras extraes información extra sobre ella, al mismo tiempo. Esto se hace usando el operador "[-write](https://imagemagick.org/command-line-options/#write)" para guardar este formato de imagen especial en un archivo (o la salida estándar normal de los comandos). | |

  magick rose: -shave 12x0 -repage 64x64+9+9 \
          -format '%wx%h %g'  -write info:info_paged.txt    paged.gif

| |

También hay un operador "[-identify](https://imagemagick.org/command-line-options/#identify)" que es equivalente a usar "[-write](https://imagemagick.org/command-line-options/#write) info:" para sacar información de identificación de imagen a la salida estándar. Esto hace aún más fácil monitorizar qué está ocurriendo con tus imágenes al depurar tus comandos de IM. Por ejemplo... | |

  magick logo:           -identify \
          -trim           -identify \
          +repage         -identify \
          -resize 80x80\! -identify \
          logo_thumbnail.gif

| |

Aquí puedes ver cómo "[-trim](https://imagemagick.org/command-line-options/#trim)" redujo el tamaño de la imagen pero preserva la información de 'recorte' de qué parte de la imagen fue recortada, luego el "[+repage](https://imagemagick.org/command-line-options/#repage)" eliminando esa información extra de 'lienzo' o 'página'. Y así sucesivamente. Además como el comando "magick identify", tanto "[info:](#info)" como "[-identify](https://imagemagick.org/command-line-options/#identify)", se volverán mucho más detallados si el ajuste "[-verbose](https://imagemagick.org/command-line-options/#verbose)" está activado. Aquí limito la larga salida a solo las primeras líneas, solo para que puedas hacerte una idea de ella.

  magick rose: -verbose  info:  | head

| _El ajuste "[-verbose](https://imagemagick.org/command-line-options/#verbose)" también provocará que se imprima información extra sobre las imágenes que se leen o escriben, en el error estándar (con la excepción del formato "info:"). También provoca que algunos operadores como "[-colors](https://imagemagick.org/command-line-options/#colors)" saquen información adicional. Por ello puede que quieras desactivarlo de nuevo después de usarlo con "[-identify](https://imagemagick.org/command-line-options/#identify)" o el formato "info:".

Por ejemplo _ "-verbose -write info:image_info.txt +verbose" o "-verbose -identify +verbose" .
---|---
| La lectura mediante script de la salida de cualquier forma de "[identify](basics.html#identify)", debe hacerse de forma que no distinga entre mayúsculas y minúsculas. Esto asegura una mejor compatibilidad hacia atrás entre diferentes versiones de ImageMagick.
---|---
NOTA: "info:" (y "[-identify](https://imagemagick.org/command-line-options/#identify)") es solo un formato de salida, que produce la misma salida que el comando "[identify](basics.html#identify)". No puedes leer, ni crear una imagen usando el formato de archivo "info:". También puedes usar "[-print](https://imagemagick.org/command-line-options/#print)" para imprimir información, pero eso se aplica solo una vez contra toda la secuencia de imágenes. Eso significa que puedes usar este operador para calcular expresiones '%[fx:...]' mucho más complejas que involucran múltiples imágenes. Pero recuerda que a diferencia de los otros métodos anteriores, solo se aplica una vez a través de todas las imágenes.

null:

Como formato de salida, esto simplemente 'desechará' los resultados de imagen. Por ello si se usa como el argumento final en un comando "magick", "magick montage", o "magick composite" ¡el resultado final no se guardará! ¿Por qué? Bueno puede ser que estés más interesado en imágenes específicas, generadas durante el procesamiento de imágenes en lugar del resultado global, especialmente al depurar. Por ejemplo, aquí extraemos y guardamos una imagen, de una secuencia de imágenes, luego desechamos todas las demás imágenes usando "null:". |

magick eye.gif news.gif storm.gif tree.gif rose: logo: \ ( -clone 2 -write write_storm.gif ) null:

Esto es mucho más simple que intentar eliminar todas las demás imágenes una a la vez. Como formato de imagen de entrada sin embargo, "null:" generará una imagen marcador de posición especial de un solo píxel transparente, con un indicador especial de 'fuente nula', en la secuencia de imágenes actual. Esta imagen especial es especialmente importante para Dejar Huecos en un Montaje, y como separador de lista para Composición de Capas multiimagen. Está estrechamente relacionada con otro formato de imagen especial conocido como una 'imagen fallida', que puede generarse para operaciones como "[-crop](https://imagemagick.org/command-line-options/#crop)". Este formato de imagen se produce cuando una operación produce un resultado vacío o sin sentido. Ambas imágenes son un solo píxel transparente, y por ello las imágenes "null:" también serán tratadas como si fueran una 'imagen fallida'. En este momento no hay método para eliminar ninguna imagen "null:" o incluso 'imagen fallida', de la secuencia de imágenes actual. Sin embargo se ha propuesto un método así. Escríbeme si descubres que necesitas un método así.

txt:

Este es un archivo de texto ASCII simple, que básicamente lista cada píxel de la imagen, uno por línea. No es un conversor general de texto a imagen, para eso consulta Ejemplos de Archivos de Texto Multilínea. Si la 'enumeración de píxeles' no se reconoce, la imagen se pasará al codificador de formato "[text:](text.html#text)", para renderizarla como un archivo de texto plano. Por ejemplo, aquí hay una imagen "netscape:" escalada a una imagen de 2x2 píxeles, luego listada usando un formato de imagen "txt:".

magick netscape: -scale 2x2! txt_netscape.txt

La primera línea (cabecera) de la imagen está repleta de la información básica sobre la imagen. La información consiste en... Magic del Archivo: La cabecera de la imagen define este archivo como el formato de imagen de texto especial de IM (por ej. un archivo "ImageMagick pixel enumeration"), esto se conoce en los círculos informáticos como el 'magic' del archivo o la cadena de código que identifica este archivo como siendo de este formato de archivo específico. Tamaño de la Imagen: Los siguientes dos números definen el tamaño de la imagen contenida en este archivo. Multiplicar estos números juntos también te dirá cuántas líneas deberían seguir a la cabecera para definir completamente la imagen. IM siempre sacará esta cantidad de líneas, aunque como verás más adelante al leer NO necesitas definir TODOS los píxeles. MaxValue: El último número en la cabecera define el 'valor máximo' de los datos de imagen que es posible. En los ejemplos anteriores esto fue '255' que es resultado de usar una profundidad de 8 bits. La razón por la que sacó la imagen integrada "netscape:" a esta profundidad es porque se definió internamente usando valores de 8 bits, y por ello IM preservó este nivel de profundidad para la imagen. Consulta la sección sobre el Ajuste de Profundidad para más información. Pero puedes anular el ajuste de profundidad (hasta el límite del ajuste Q o Calidad en Tiempo de Compilación de tu IM, cambiando el "[-depth](https://imagemagick.org/command-line-options/#depth)" de las imágenes. Por ejemplo, aquí saco los valores de color como valores de 16 bits (de 0 a 65535)...

  magick netscape: -scale 2x2\! -depth 16 txt_netscape_16.txt

| En este momento no puedes establecer un 'Valor Máximo' específico para usar en el formato de archivo de salida. Solo puedes definir un valor diferente en términos del ajuste "[-depth](https://imagemagick.org/command-line-options/#depth)" actual, haciendo que el valor máximo sea igual a 2^depth-1.
---|---
Espacio de color: El último elemento en la cabecera define el espacio de color de los datos que siguen. Si la imagen contenía alguna transparencia, también se añade una letra final 'a' (de alfa) al nombre del espacio de color, y una columna extra de números añadida entre paréntesis. Las imágenes en escala de grises sacarán una imagen como 'grey', pero definirán al menos tres números, que serán el mismo valor para cada píxel. Por ejemplo, ¡aquí está la misma imagen usando un espacio de color de 'LAB' con un canal alfa añadido!

  magick netscape: -scale 2x2\! -colorspace LAB -alpha set txt_cspace_lab.txt

  magick rose: -resize 3x2\! -depth 8 -colorspace RGB -alpha off txt:- |
    tail -n +2 | tr -cs '0-9.\n'  ' ' |
      while read x y r g b junk; do
        echo "$x,$y = rgb($r,$g,$b)"
      done

La lectura de imágenes TXT también es válida. No necesitas definir TODOS los píxeles de la imagen. ¡De hecho ni siquiera necesitas tener los píxeles en el orden correcto! ImageMagick simplemente leerá cada línea que defina un píxel por turno, y lo 'dibujará' sobre un lienzo de imagen en blanco. Solo se usan los números entre paréntesis en cada línea para esto, no los nombres de color. El lienzo en blanco inicial, se limpia y se establece al color de fondo actual. Por ello cualquier píxel no proporcionado por una imagen "txt:", se dejará con este color. Para un uso interesante de las imágenes "txt:", echa un vistazo a Mapeo Directo de Píxeles donde saco una Imagen de Píxeles Enumerados, luego cambio cada una de las ubicaciones de los píxeles para rotar (distorsionar) la imagen, antes de leer la Imagen de Píxeles Enumerados, de nuevo en IM. En la imagen resultante algunas ubicaciones de píxeles no se definieron, mientras que otras ubicaciones tenían múltiples píxeles añadidos. IM manejó esto sin problemas.
El formato "txt:" es especialmente útil con el operador "[-unique-colors](https://imagemagick.org/command-line-options/#unique-colors)", que reemplaza cada imagen en la secuencia de imágenes actual con una nueva imagen que contiene un píxel por cada color único encontrado. Cuando esto se saca a un archivo de formato "txt:", obtienes un resumen básico de los colores contenidos en una imagen (aunque no sus conteos, o histograma). Por ejemplo, aquí están los colores usados por la imagen tree. Como GIF solo puede usar números de 8 bits, los colores también se sacan a la misma Profundidad. | |

  magick tree.gif -unique-colors txt:-

|

Hay otra alternativa al uso del formato "txt:" de IM usando los diversos formatos de archivo de imagen NetPBM. IM por defecto saca este formato como binario, pero puedes desactivar "[-compress](https://imagemagick.org/command-line-options/#compress)" para sacar una versión de texto ASCII del formato NetPBM. Por ejemplo.

    magick tree.gif -unique-colors -compress None -depth 8 tree_netpbm.ppm

Puede que notes que los números en lo anterior coinciden con los números en el formato de Píxeles Enumerados ("txt:") de IM. Consulta Gradiente Redimensionado para algunos ejemplos de generación de una imagen en formato NetPBM para que IM la lea. Si solo quieres el color de un píxel específico puedes recortar la imagen a un píxel, y sacarla como una imagen "txt:".

  magick rose: -crop 1x1+12+26 txt:

O puedes usar un Formato de Escape FX especial para sacar el color en una forma directamente utilizable por IM.

  magick rose: -format '%[pixel:u.p{12,26}]' info:

Consulta también Extracción de Colores de Imagen.

sparse-color:

Este es un formato de imagen de salida especial que devolverá una simple lista separada por comas de coordenadas y colores para cada píxel que no sea transparente. La cadena de salida es adecuada para entrada directa en el Operador Sparse Color. Por ejemplo esto encuentra los pocos píxeles 'más cercanos' a un color rojo puro en la imagen "rose:".

magick rose: -alpha set -fuzz 13% +transparent red sparse-color:

En muchos sentidos esto es más útil que el formato "[txt:](#txt)" mostrado arriba, pero solo si están involucrados un par de píxeles. Ten en cuenta sin embargo que en el momento de escribir esto, la salida es toda una línea. A los scripts de shell les puede convenir convertir (magick) los espacios en la salida a saltos de línea.

histogram:

Este es en realidad el formato de imagen "[miff:](#miff)", pero con un comentario de imagen muy grande que contiene un conteo completo de todos los colores dentro de la imagen. Es decir, en el atributo 'Comment={...}' de la cabecera de texto "[miff:](#miff)". Por ejemplo, aquí de nuevo listamos los colores presentes en la imagen "tree", pero esta vez incluyendo el conteo de píxeles para cada color. El comentario de texto del histograma se extrae de la imagen "histogram:" usando un magick identify formateado con "[info:](#info)" secundario. | |

magick tree.gif -define histogram:unique-colors=true \ -format %c histogram:info:-

|

| El formato de salida "info:" se añadió a IM v6.2.4. Para versiones de IM anteriores a esta usa.. |

  magick tree.gif histogram:- | identify -format %c -

  magick rose: \
          -define histogram:unique-colors=false \
          histogram:histogram.gif

Una imagen que es muy oscura estará fuertemente ponderada hacia la izquierda, mientras que una imagen clara estará fuertemente ponderada hacia la derecha. Los tonos medios, igualmente, se representan en el medio. Para ver esto mejor aquí separo los histogramas para cada uno de los canales de color. También elimino el comentario de texto del histograma (si aún está presente), y redimensiono la imagen para mostrarla.

  magick histogram.gif -strip -resize 50% -separate  histogram-%d.gif

---

Rojo |
Verde |
Azul

Para la imagen "rose:" anterior verás que el rojo está más extendido mostrando su importancia vital en la imagen. Por otro lado el verde y el azul tienen picos a la izquierda, mostrando que tienen muy poca influencia en la imagen en absoluto. Si estás más interesado en el brillo de una imagen en lugar de sus colores, convierte (magick) la imagen a escala de grises antes de generar una imagen "histogram:". |

  magick rose: -colorspace Gray \
          -define histogram:unique-colors=false \
          histogram:histogram_gray.gif

Como puedes ver el histograma de una imagen en escala de grises es un poco diferente. Como el color rojo predominante se vuelve más un color gris de tono medio, produciendo un pico en el centro del histograma. Además la pequeña área de blanco roto en la imagen ahora produce un pico distintivo en el extremo derecho del gráfico. El espacio completamente vacío en el extremo izquierdo también muestra que no hay parches oscuros en la imagen en absoluto. Por otro lado se puede generar un mejor histograma 'global' simplemente separando todos los canales de color en la imagen original y concatenando. El histograma resultante es una representación de todos los valores de color independientemente de qué canal provenga ese valor. |

  magick rose: -separate -append \
          -define histogram:unique-colors=false \
          histogram:histogram_values.gif

Desafortunadamente como "histogram:" es un formato de salida, necesitarás ya sea 'canalizar' la imagen a otro comando, guardarla en disco, o usar el guardado/lectura especial "[mpr:](#mpr)", si quieres procesar la imagen más. Consulta el ejemplo en "[mpr:](#mpr)" más abajo. Sería bueno si algún método de generación de histogramas (y otros gráficos) estuviera disponible como operadores en lugar de un formato de salida especial.

mpr:_{label}_

(Memory Program Register) guardará la secuencia de imágenes completa en un registro de memoria nombrado, desde el cual puedes leer posteriormente los datos de imagen. Por ello si quieres guardar una imagen para usarla más tarde, en una operación de imagen compleja puedes hacerlo. Escribir en un "mpr:" al final del procesamiento es inútil, ya que la memoria del programa se devuelve al sistema cuando el programa termina. Por ello querrás usar una operación de Escritura para guardar las imágenes en un archivo en medio de tus pasos de procesamiento, si la necesitas en un proceso diferente. La 'etiqueta ' dada a "mpr:" puede ser cualquier cosa que quieras, es solo una etiqueta de dónde se guardó la imagen en memoria. Incluso puede ser solo un número simple para personas que hacen scripting y no quieren lidiar con nombres, aunque los nombres podrían hacer tu script más fácil de seguir. Después de que hayas guardado una imagen (ver abajo), puedes entonces leer la imagen de nuevo, desde la misma ubicación de memoria 'etiquetada', tantas veces como quieras. Por ejemplo... |

magick tree.gif -write mpr:tree +delete \ \ mpr:tree mpr:tree mpr:tree +append mpr.gif

Nota el uso de "[+delete](https://imagemagick.org/command-line-options/#delete)" en el procesamiento de imágenes anterior. En lo anterior no es necesario (solo vuelve a leer el "mpr:tree" dos veces en lugar de tres), pero es muy común Eliminar todas las imágenes de la secuencia de imágenes actual después de guardar las imágenes en un registro "mpr:". Básicamente las dos líneas en lo anterior pueden considerarse como dos comandos "magick" completamente separados, pero usando un registro de memoria nombrado para la imagen intermedia en lugar de espacio en disco. En muchos sentidos usar "mpr:" es como usar Clone o Duplicate (que podríamos haber usado en el ejemplo anterior), pero usar "mpr:" nos permite eliminar completamente todas las imágenes, para limpiar la lista de imágenes actual para otro trabajo. La mejor característica de este método es que también te permite usar ajustes y operaciones que solo funcionan con la entrada de imagen. Por ejemplo, usándolo con el operador de imagen de entrada "[tile:](canvas.html#tile)" para teselar una imagen sobre un área más grande. |

  magick tree.gif -flip   -write mpr:tree  +delete \
          -size 64x64 tile:mpr:tree   mpr_tile.gif

También puedes usar "mpr:" para capturar la salida de algunos de los filtros de formato de imagen de salida especiales para procesamiento adicional. Por ejemplo aquí guardamos la imagen de salida de "[histogram:](#histogram)" y luego la leemos de nuevo continuando procesándola en el mismo comando, |

  magick rose: -define histogram:unique-colors=false \
          -write histogram:mpr:hgram  +delete \
          mpr:hgram  -strip  -resize 50%  histogram_resized.gif

El guardado en memoria "mpr:" es en realidad la única forma en que puedes reutilizar imágenes que ya están en memoria a través de filtros de E/S especiales como un formato de archivo de salida como "[histogram:](#histogram)" o un formato de archivo de entrada como "[tile:](canvas.html#tile_memory)". Lo mismo es cierto para las opciones especiales que toman una imagen de entrada real, como "[-tile](https://imagemagick.org/command-line-options/#tile)" o para imágenes de "[Color Mapping](https://imagemagick.org/command-line-options/#map)" usando otra imagen como fuente. Consulta Mapas de Color Multiimagen. NOTA que tales opciones están siendo reemplazadas en IMv7 con versiones que no necesitan que la imagen se lea desde un archivo. También es la única forma de usar el método -draw 'image' para superponer imágenes usando una imagen generada en memoria, aunque hay muchas otras técnicas para hacer esto. La imagen "mpr:" en realidad guarda la secuencia de imágenes completa y no solo una imagen. Es un poco como tomar una instantánea de la secuencia de imágenes actual para que puedas recargarla más tarde para procesamiento adicional. Esto por ejemplo te permite tomar copias de una secuencia de animación completa, para duplicar o clonar, sin necesidad de saber cuántas imágenes están realmente involucradas. Consulta Composición de Capas para un ejemplo de cómo hacer esto. Cuando tienes múltiples imágenes en "mpr:" ¡en realidad aún puedes extraer imágenes individuales de esa secuencia! Usar "mpr:image'[2]'" extraerá la tercera imagen de una secuencia multiimagen guardada usando "-write mpr:image". Por ejemplo, aquí extraigo la imagen 'storm' de un conjunto de cuatro imágenes. |

  magick eye.gif news.gif storm.gif tree.gif \
          -write mpr:images  -delete 0--1 \
          \
          mpr:images'[2]'   mpr_extract.gif

El operador Clonación de Imágenes generalmente no puede manejar un número variable desconocido de imágenes, y de hecho antes de que se añadiera el operador Clone "mpr:" era el único método disponible para duplicar imágenes en memoria, sin usar archivos de disco intermedios. | A partir de IM v6.8.2 también puedes almacenar imágenes en un proceso demonio de caché de IM remoto. Esto permite que las imágenes (y sus metadatos) se pasen entre comandos de IM ejecutándose por separado, sin necesitar espacio en disco. ConsultaDemonio de Caché de Píxeles Distribuido
---|---

mpc:

Es un formato de guardado en disco específico de IM que se diseñó originalmente pensando en imágenes realmente grandes. Básicamente es un archivo de disco mapeado en memoria de la memoria del programa, guardado en disco como dos archivos binarios, un ".mpc" que contiene los metadatos de la imagen, y un ".cache" que contiene la caché de píxeles de la imagen.

El formato "MPC:" crea dos archivos para guardar una imagen

Tales archivos no funcionarán después de que IM se recompile o actualice, y solo para el IM compilado para una máquina específica. Por ello solo es bueno para archivos temporales de 'lectura rápida', como para contener imágenes temporales usadas por procesamiento de imágenes con script, y no para almacenamiento a largo plazo. Por ejemplo...

  magick very_big_image.tif  very_big_image.mpc

creará dos archivos en disco. Un pequeño archivo "very_big_image.mpc" y un archivo especial de volcado de memoria llamado "very_big_image.cache". El tamaño del segundo archivo probablemente será mucho mayor que cualquier otro formato de archivo de imagen ya que es solo un volcado de memoria sin procesar y sin comprimir. Sin embargo el archivo no necesita ser 'leído' o 'decodificado' sino que puede ser directamente 'paginado' en la memoria del ordenador, y usado exactamente tal cual, sin ninguna sobrecarga de procesamiento. Solo mucho espacio en disco y E/S de disco. En otras palabras solo necesita tiempo de acceso a disco para leer, sin ningún procesamiento de formato de archivo. Es decir, no se necesita decodificación de los datos. Debido a que la imagen está 'lista en memoria' es especialmente útil para imágenes temporales de todos los tamaños ya que será utilizable inmediatamente por el siguiente comando de IM que emitas. Pero recuerda, se generan dos archivos y serán más grandes que un tamaño de archivo de imagen normal, así que ten cuidado con tu uso de disco, y la limpieza del script. Mis propios scripts de IM hacen buen uso de esta característica. Por ejemplo consulta los scripts "de-pixelate", y "divide_vert", que hacen uso de un número bastante grande de archivos de imagen temporales para operaciones de procesamiento de imágenes. Esto puede ser extremadamente útil para scripts o Composición Alfa con Mogrify que necesitan poder leer la misma imagen, una y otra y otra vez, ya que IM no tiene que decodificar la imagen, o usar mucha memoria solo para almacenarla. Esto también es muy útil para procesar una imagen muy grande, donde debes extraer o Recortar una sección más pequeña de la imagen para el procesamiento real. Sin embargo como la mayoría de las operaciones de imagen en realidad hacen copias de clones de las imágenes durante el procesamiento, aún podría hacerse una nueva copia en memoria. Por ello aún se necesita algo de cuidado. Un Recorte o Redimensionado a tamaños de imagen mucho más pequeños son las operaciones más seguras para el manejo de imágenes grandes con MPC. Para más información consulta Manejo de Imágenes Realmente Enormes más abajo.

fd:{file_descriptor}

Este nombre de archivo especial que te permite especificar un 'descriptor de archivo ' específico desde el que la imagen se va a leer o al que se va a escribir. El nombre 'fd:0' es la 'entrada estándar ' y 'fd:1' es la 'salida estándar ' del programa. Estos son equivalentes a usar un '-' como nombre de archivo. Sin embargo puedes especificar cualquier 'descriptor de archivo ' con el que leer/escribir la imagen. Incluyendo 'fd:2' para 'error estándar ', o cualquier otro manejador de archivo previamente abierto que el programa padre pueda haber dispuesto. El uso más común para esto es en scripting de shell muy avanzado, donde puedes tener múltiples flujos de archivo de imágenes. O para demonios de red que pueden tener múltiples flujos de archivo abiertos simultáneamente.

inline:{base64_file|data:base64_data}

Las imágenes en línea te permiten leer una imagen definida en una codificación especial base64. Por ejemplo para leer una imagen codificada en base64 usa...

inline:base64_image.txt

Esta codificación podría ser de un archivo, pero más típicamente se da directamente como el argumento de lectura en lugar de como un nombre de archivo de alguna fuente de imagen externa. Esto se usa más típicamente como una alternativa a los 'blobs' en la línea de comandos, o en el procesamiento de imágenes por API. O pon los datos de imagen directamente en la línea de comandos...

inline:data:mime-type;base64,/9j/4AAQSk...knrn//2Q==

Por ejemplo codifiquemos en base64 una imagen muy pequeña (hay muchos programas que te permitirán hacer esta conversión)...

  openssl enc -base64 -in noseguy.gif

Nota que los datos base64 pueden contener cualquier cantidad de espacio en blanco como retornos y saltos de línea. Es simplemente ignorado por el formato. También solo usa caracteres ASCII normales, que es por lo que se usa para codificar datos binarios para correo electrónico y páginas web. También permite que datos binarios se almacenen en programas y scripts sin problemas. Por ejemplo podría tener el siguiente comando en un script de shell de modo que el propio script tiene la imagen incorporada en él, y por ello no necesita una fuente de imagen externa separada. |

  magick 'inline:data:image/gif;base64,
      R0lGODlhIAAgAPIEAAAAAB6Q/76+vvXes////wAAAAAAAAAAACH5BAEAAAUALAAA
      AAAgACAAAAOBWLrc/jDKCYG1NBcwegeaxHkeGD4j+Z1OWl4Yu6mAYAu1ebpwL/OE
      YCDA0YWAQuJqRwsSeEyaRTUwTlxUqjUymmZpmeI3u62Mv+XWmUzBrpeit7YtB1/r
      pTAefv942UcXVX9+MjNVfheGCl18i4ddjwwpPjEslFKDUWeRGj2fnw0JADs=
    '  b64_noseguy.gif

Recuerda que con esto la imagen podría usarse en tu script (shell o API). No necesitas tener un archivo de imagen externo separado, haciendo la instalación de un script por lo demás simple más complicada. ¿Entonces por qué "[inline:](#inline)" tiene esta forma más bien complicada? Básicamente porque este es el formato usado para imágenes en línea en páginas web HTML. Por ejemplo en lo siguiente la imagen a la derecha se incluyó directamente en línea en la página web, y no como un archivo externo separado, usando una etiqueta HTML de la forma... |

  <IMG SRC="data:image/gif;base64,
        R0lGODlhIAAgAPIEAAAAAB6Q/76+vvXes////wAAAAAAAAAAACH5BAEAAAUALAAA
        AAAgACAAAAOBWLrc/jDKCYG1NBcwegeaxHkeGD4j+Z1OWl4Yu6mAYAu1ebpwL/OE
        YCDA0YWAQuJqRwsSeEyaRTUwTlxUqjUymmZpmeI3u62Mv+XWmUzBrpeit7YtB1/r
        pTAefv942UcXVX9+MjNVfheGCl18i4ddjwwpPjEslFKDUWeRGj2fnw0JADs="
      ALT="Nose Guy" WIDTH=32  HEIGHT=32  VSPACE=5 HSPACE=5 BORDER=0 >

Esto no funcionará con todos los navegadores web, por ejemplo no funcionará con IE7 y anteriores, pero funcionará con IE8. Básicamente los navegadores web más modernos lo entienden.
El mismo tipo de formato de datos en línea también se usa para imágenes de 'cara' en cabeceras de EMail, y probablemente muchos otros tipos de archivo. APARTE: Gracias a la parte 'mágica' de ImageMagick, la mayoría de los formatos de archivo de imagen no necesitan tener el mime-type (la parte 'image/gif' de la larga cadena) incluido. Y de hecho en realidad es completamente ignorado por IM en cualquier caso). Sin embargo la coma ',' aún se requiere para marcar el final de esa parte de la cadena de datos de imagen en línea. |

  magick 'inline:data:,R0lGODlhEAAOALMAAOazToeHh0tLS/7LZv/0jvb29t/f3//U
       b//ge8WSLf/rhf/3kdbW1mxsbP//mf///yH5BAAAAAAALAAAAAAQAA4AAARe8L1Ek
       yky67QZ1hLnjM5UUde0ECwLJoExKcppV0aCcGCmTIHEIUEqjgaORCMxIC6e0CcguW
       w6aFjsVMkkIr7g77ZKPJjPZqIyd7sJAgVGoEGv2xsBxqNgYPj/gAwXEQA7
    '  b64_folder.gif

ADVERTENCIA: La entrada de opciones de la línea de comandos está restringida a 5000 caracteres. Además muchos shells (y particularmente la entrada de PC-DOS) tienen límites totales de longitud de la línea de comandos. Por ello esto no es adecuado para imágenes base64 muy grandes.

clipboard:

Leer o Escribir la imagen al o desde el Portapapeles de Windows. (Solo Windows).

ephemeral:{image_file}

Leer y luego Eliminar este archivo de imagen. Este es un formato de archivo especial de lectura de imagen que provocará que IM elimine el archivo de imagen dado después de que ese archivo haya sido leído en memoria. Nota que la imagen en memoria no habrá sido procesada ni siquiera guardada cuando el archivo leído haya sido eliminado. Esto es muy peligroso y debe usarse con extrema precaución. Se usa principalmente en Lanzamiento de Delegados. Aquí el delegado en segundo plano leerá la imagen de entrada, luego la elimina cuando tiene los datos. Esto a su vez notifica al proceso 'padre' en primer plano, que el 'hijo' está listo para proceder por sí mismo, ya que ha terminado de leer la imagen proporcionada. El programa principal puede entonces limpiar y continuar su procesamiento de imágenes por separado, o simplemente salir, según sea el caso. El delegado de salida de imagen "show:" usa esto con el comando "magick display", para automáticamente poner en segundo plano una visualización de imagen antes de que el comando principal continúe o salga. (ver abajo) Por ejemplo usé esto en un script de shell que llama a "[flicker_cmp](../static/img/scripts/flicker_cmp)" para mostrar algunos resultados intermedios, pero luego continúa automáticamente (o sale) cuando IM ha señalado que el programa ha terminado de leer su imagen de entrada eliminando la segunda imagen dada. Si necesitas esa retroalimentación pero también necesitas preservar la imagen que se está leyendo, entonces haz una copia, enlace duro, o enlace simbólico a la imagen original, y pasa ese archivo como "ephemeral:". de esa forma cuando se elimine la imagen original se preserva. NOTA: Actualmente no hay forma de hacer que "animate" o "display" señale cuándo ha terminado una animación, o ha puesto realmente la imagen en pantalla. :-( Sin embargo puedes hacer que "magick" lea una imagen "ephemeral:" separada, para notificar a un script controlador que ha alcanzado un punto específico en su procesamiento de imágenes.

# Difumina una imagen, y muestra una comparación en pantalla antes # de autoeliminar y salir. magick rose: input_image.png magick input_image.png -blur 0x5 blurred.png flicker_cmp input_image.png ephemeral:blurred.png &

# espera a que la segunda imagen haya sido leída y eliminada! while [ -f blurred.png ]; do usleep 100; done

# En este punto podemos continuar (o salir) sin problemas. # mientras la visualización en pantalla continúa en segundo plano. rm -f input_image.png

También he usado esto en otros programas en segundo plano, como señal de que ese programa en segundo plano está listo para continuar.

show:, win: y x: -- Mostrar imágenes directamente en pantalla

Estos son formatos de salida especiales que mostrarán directamente el resultado de la imagen en tu pantalla. En lugar de guardar la imagen en un archivo, simplemente muestra el resultado. Esto es muy útil para probar rápidamente comandos de IM para ver cuáles serán los resultados, y es altamente recomendable para este propósito. Sin embargo son solo versiones muy simples de los comandos "[display](basics.html#display)" y "[animate](basics.html#animate)". Por ejemplo, obtén un resumen rápido de las imágenes en un directorio...

magick montage *.jpg show:

Ve las áreas que son diferentes entre dos imágenes...

  magick compare image1.png image2.png show:

Todos los formatos listados aquí, en realidad invocan al programa "[display](basics.html#display)" para realizar su tarea. Sin embargo cada uno maneja el trabajo de formas diferentes. Por ejemplo 'show:' usará un Delegado de Lanzamiento para ejecutar un programa "[display](basics.html#display)" separado. Esto significa que una vez que la imagen ha sido mostrada, el comando original continuará su procesamiento (típicamente saliendo, a menos que uses "-write show:" ). Por otro lado, usar 'x:' o 'win:' esperará a que cierres la ventana de visualización antes de permitir que el comando original continúe (y salga). Desafortunadamente ninguno de estos métodos mostrará animaciones muy bien. Para eso es mejor que canalices la animación (en formato MIFF) al comando "[animate](basics.html#animate)".

x: (como entrada) - Lectura de una Pantalla de X Window

También puedes leer la pantalla actual de X window usando el operador "x:", de una forma muy similar a como puedes con el comando "import". De hecho sin opciones actúa exactamente como el comando "import". Usa el botón izquierdo para seleccionar la ventana de la que tomar una copia, o marca un área usando el botón central. Por ejemplo, para seleccionar una ventana usando tu ratón, luego mostrar la ventana que se acaba de tomar en otra ventana (sale cuando la ventana tomada se muestra)...

magick x: show:

ADVERTENCIA. ¡si tomas una ventana que está desmapeada (iconizada), o tiene otra ventana sobre ella, el contenido de la imagen contendrá ya sea un área en blanco, o el contenido de la ventana superpuesta! Así que asegúrate al tomar una ventana de que esa ventana esté completamente visible en pantalla. Para tomar toda la pantalla usa 'root' como nombre de ventana.

  magick x:'root'  full_screen_dump.jpg

O usa los Modificadores de Lectura para tomar un área específica de la pantalla.

  magick x:'root[300x400+879+122]'  part_screen_dump.jpg

Proporcionando un nombre de ventana puedes tomar una ventana específica. Por ejemplo esto tomará la ventana titulada 'MailEd'...

  magick x:'MailEd'  window.jpg

Sin embargo eso realmente no funciona bien, ya que a menudo tienes múltiples ventanas con el mismo nombre, o el nombre de la ventana simplemente no se puede determinar. La mejor forma es decirle a IM la ventana exacta que quieres usando un "X Window ID" que es el número que la pantalla de X usa para identificar de forma única una ventana específica (o ventana hija). El X Window ID se busca típicamente usando el comando "xwininfo", pero otros programas como "xdotool", y "xwit" así como otras herramientas como "xprop" pueden usarse para encontrar información sobre las ventanas. Por ejemplo cosas como, clase de ventana, nombre, título, su tamaño y ubicación, ventanas hijas, y decoración del gestor de ventanas. Por ejemplo, encuentra todas las ventanas con "Mozilla Firefox" en el título o nombre...

  xwininfo -root -all | grep "Mozilla Firefox"

Puedo entonces extraer el X Window ID de la ventana que quiero de la salida de lo anterior. Aquí hay un script bash un poco más complejo que tengo en mi gestor de ventanas. Cuando presiono un botón, busca el ID de la ventana con el 'foco' actual, lo captura, luego nombra el archivo como un PNG en mi directorio actual usando el siguiente número de captura, de acuerdo con cualquier captura previa realizada.

  bash -c "
    id=$(xprop -root _NET_ACTIVE_WINDOW | sed 's/.* //')
    magick x:$id capture-tmp-$$.png
    num=$( ls capture-[0-9]*.png 2>/dev/null | sed -n '$ s/[^0-9]//gp' )
    num=$( printf %03d $(expr $num + 1) )
    mv capture-tmp-$$.png capture-$num.png
  "

La mayoría de los programas de terminal te dirán el X Window ID que están usando para mostrar (magick) texto en la variable de entorno "WINDOWID". Por ello si ejecutas esto desde una línea de comandos de un XTerm, o Gnome Terminal, tomarás una copia de la ventana de terminal actual.

  magick x:$WINDOWID  this_terminal.png

Ahora para divertirnos un poco... Aquí tomo el contenido de mi terminal actual, dibujo algunas cosas en él, y luego uso el "[display](basics.html#display)" para dibujarlo de vuelta en la misma ventana de terminal!

  window=`xwininfo -children -id $WINDOWID |\
                  sed -n 's/^ *\(0x[^ ]*\).*/\1/p'`; \
  window="${window:-$WINDOWID}"; \
  magick x:$window -background black \
          -draw 'fill black         rectangle 40,40 160,160' \
          -draw 'stroke red         line 50,50 50,150 line 50,150 150,150' \
          -draw 'fill lime          circle 110,100 80,100' \
          -draw 'stroke dodgerblue  line 50,150 150,50' \
          rose: -geometry +180+60 -composite \
          png:- |\
    magick display -window $window -

El primer comando en lo anterior está diseñado para una ventana "XTerm", que requiere que la ventana en la que "magick display" sea la ventana hija del "WINDOWID" proporcionado. La segunda línea recurre al valor original de "WINDOWID" si no se encuentra ninguna ventana 'hija', como es el caso de una ventana "Gnome-Terminal". Una vez que se determina la ventana a usar, se toma, se dibuja sobre ella, y se restaura en la ventana de terminal! Y presto tienes salida gráfica instantánea directamente en la ventana de terminal actual. Aquí hay un ejemplo más simple, este oscurece el contenido de la ventana cada vez que lo ejecutas. Intenta ejecutar esto unas cuantas veces en una ventana "xterm" real, y descubrirás que cuanto más antiguo es el comando en la ventana de terminal más oscuro se vuelve!

  window=`xwininfo -children -id $WINDOWID |\
                  sed -n 's/^ *\(0x[^ ]*\).*/\1/p'`; \
  window="${window:-$WINDOWID}"; \
  magick x:$window -background black -colorize 20% png:- |\
    magick display -window $window -

Y aquí hay una 'captura de pantalla' que muestra lo que ocurrió mientras repetía lo anterior en mi propia ventana "xterm"...

Ten en cuenta que aunque el contenido del terminal se modifica, es solo temporal. Si iconizas, ocultas, o cambias de pantalla de escritorio, y luego vuelves al terminal, las modificaciones se perderán ya que el programa de terminal redibuja la ventana, y borra tu propio 'dibujo'. Lo anterior no funciona ni de cerca tan bien para un "Gnome-Terminal" como para los "XTerm" porque el primero le gusta 'redibujar' su ventana cada vez que se desplaza, mientras que un "XTerm" no. Imagina scripts de IM que muestran los resultados de gráficos y otras cosas directamente en varias ventanas como parte de un programa cliente más grande. Esto es de hecho cómo muchos visores de postscript, e incluso muchos navegadores web muestran la salida de subprogramas especiales. Es decir, hacen que ese subprograma tome el control y dibuje directamente en una subventana proporcionada. Experimenta, y por favor hazme saber (a mí y a otros) lo que se te ocurra, ya sea por correo electrónico o el Foro de Usuarios de IM.

Codificadores y Delegados para Formatos de Imagen

Los codificadores (coders) son módulos de biblioteca dinámica (normalmente escritos en el lenguaje de programación C) que manejan el aspecto "format:" de la entrada y salida de imágenes. También pueden ser usados por los usuarios para crear filtros de propósito especial. Pueden requerir la instalación de bibliotecas externas adicionales que se instalen, que a menudo se llaman 'bibliotecas delegadas'. Se cargan como módulos dinámicos solo cuando se necesitan, lo que significa que las bibliotecas asociadas usadas por un codificador no necesitan instalarse, a menos que realmente quieras hacer uso de ese codificador. Estos ejemplos no entrarán en la programación en C requerida para escribir codificadores, pero hay un codificador de ejemplo en el código fuente que puede usarse para crear tus propios módulos de codificador.
Un delegado (delegate) es simplemente un comando que IM conoce que le permitirá convertir (magick) entre diferentes formatos. Esto permite que IM use ese comando 'más simple' y preescrito, en lugar de requerir un codificador binario más complejo para manejar algún formato de archivo de imagen. Para obtener una lista de qué delegados están disponibles usa el comando especial...

  magick -list delegate

El programa 'delegado' más conocido del que IM hace uso es "ghostscript" que permitirá a IM leer, y convertir (magick) las muy complejas imágenes vectoriales de formato Postscript y PDF en algún otro formato de archivo de imagen rasterizada que IM pueda leer. Sin embargo los 'Comandos Delegados ' son muy útiles para los usuarios también, ya que te permiten expandir IM de modo que pueda manejar tipos especiales de imágenes, o proporcionar métodos alternativos para leer y escribir esas imágenes. Los 'comandos' en sí se listan en un archivo llamado "delegates.xml", y que está ubicado en el directorio de configuración del sistema de IM. Pero también leerá un "delegates.xml" ubicado en el subdirectorio personal ".magick" del usuario de su directorio home de Linux/UNIX. Y es en este segundo archivo donde los usuarios deberían colocar sus 'comandos delegados'.

Ejemplo de Comando de Delegado de Entrada

Por ejemplo puedo crear un archivo "delegates.xml" personal en el subdirectorio ".magick" de mi directorio home de Linux/UNIX, de la forma...

<?xml version="1.0" encoding="UTF-8"?>
<delegatemap>
  <delegate decode="flip" command="magick '%i' -flip 'miff:%o'"/>
</delegatemap>

Este es un archivo de configuración de 'delegado' completo, pero solo la línea del medio es un delegado real. Uno muy simple que le dice a IM que si ve una imagen con un sufijo '.flip' o un prefijo de formato 'flip:', debería llamar al comando anterior, para leer la imagen de formato 'flip'. Por ejemplo.. |

  magick flip:tree.gif   delegate_tree_flip.gif

En este caso todo lo que hace el comando delegado es usar un comando "magick" de IM separado para 'voltear' la imagen boca abajo, antes de que el comando original de IM siquiera lea y procese la imagen! El delegado asume que el comando entenderá el formato de archivo de imagen dado y que devolverá CUALQUIER formato de archivo de imagen que el propio IM pueda entender y procesar (un formato de archivo de imagen MIFF en este caso). Las partes '%i' y '%o' del delegado representan nombres de archivo temporales que el comando es los nombres de archivo de entrada y salida proporcionados que el delegado debería usar. Estos nombres de archivo son generados por IM, y estarán ubicados en un directorio temporal. Estos nombres de archivo temporales tampoco tienen ningún sufijo de imagen, así que es importante que prefijes el tipo de formato de imagen deseado, si es necesario. Se hace de esta forma por razones de seguridad, y porque el propio IM puede estar leyendo solo un flujo de datos, y no un archivo real. También significa que el comando delegado no tiene que lidiar con cosas como la limpieza de esos archivos cuando termine. Hay otras sustituciones de '%' para cosas como un segundo nombre de archivo temporal para archivos temporales intermedios, densidad de imagen, tamaño, y así sucesivamente. Más detalle sobre estos escapes y otras opciones de delegado se proporcionan en los comentarios en la parte superior del archivo "delegate.xml" 'del sistema' instalado de IM. Ahora esto puede parecer un ejemplo más bien tonto y trivial, pero básicamente significa que ahora puedes usar un comando secundario para convertir (magick) CUALQUIER archivo de datos en CUALQUIER imagen que IM entienda. IM entonces sabrá cómo manejar ese tipo de datos automáticamente dado el sufijo de imagen, o un prefijo de formato, sin que necesites recordar todos los detalles. Ya se han añadido muchos delegados de este tipo al archivo del sistema, así que vale la pena echar un vistazo. | _Por razones de seguridad los delegados en un archivo "delegates.xml" personal no anularán los delegados definidos en el archivo "delegates.xml" instalado del sistema. Solo puedes añadir nuevos formatos de delegado únicos en ".magick/delegates.xml" en tu directorio home, los delegados duplicados posteriores serán ignorados.

Por supuesto si el formato de entrada ya se conoce internamente entonces por supuesto los delegados del sistema no se consultan.

Además como siempre, sanea cualquier entrada de usuario (especialmente usuario web), ya que no quieres que el usuario haga uso de un delegado sin que lo sepas.

_
---|---
Por ejemplo a partir de IM v6.4.2-6, se añadió un delegado "autotrace:' al archivo de delegados del sistema, que ejecutará el comando "[AutoTrace](http://autotrace.sourceforge.net/)" mientras lee CUALQUIER imagen de entrada. IM convierte la imagen de entrada al formato de imagen PNG requerido por el programa delegado, la filtra a través del delegado, luego lee el SVG resultante (típicamente a través de una biblioteca RSVG externa), para generar una versión de bordes suaves de la imagen de mapa de bits de entrada original. Consulta Ejemplo de Conversor de Ráster a Vector. Si un conversor genera múltiples archivos de imagen (como PNG), necesitarás fusionar todas esas imágenes separadas en un único formato multiimagen como MIFF, de modo que IM pueda leer las múltiples imágenes desde el único archivo de salida. A veces IM encadenará múltiples programas delegados para leer una imagen. Por ejemplo para leer una página 'HTML' como imagen, primero llama al delegado "html2ps" para convertirla (magick) a postscript. Luego convierte el archivo postscript generado en un conjunto de múltiples imágenes usando el programa delegado especial "ghostscript". Por supuesto usar dos, o más delegados así puede producir otros problemas debido a las complejas interacciones, instalaciones incorrectas, y errores que pueden estar presentes en los programas delegados. Pero en general funciona, y es un aspecto clave de lo que hace mágico a ImageMagick.

Ejemplo de Delegado de Salida

Cosas similares se hacen al guardar en formatos de archivo de imagen específicos que IM no entiende directamente. Por ejemplo añadiendo este delegado a tu archivo ".magick/delegates.xml" personal, puedes decirle a IM cómo crear un archivo de imagen '.xyzzy'.

  <delegate decode="gif" encode="xyzzy" command='mv "%i" "%o"'/>