Exemplos do ImageMagick -- Manipulação de Arquivos de Imagem

Prefácio e Índice dos Exemplos do ImageMagick

Resumo dos Formatos de Imagem

Lendo Imagens

• Modificadores de Leitura
• Tratamento de Metacaracteres em Nomes de Arquivo de Entrada

• Imagens Comprimidas

  Salvando Imagens

• Escapes com Percentual em Nomes de Arquivo

• Imagens Comprimidas com GZip
• Atributos Salvos
• Imagens Criptografadas
• Escrevendo Múltiplas Imagens (adjoin)
• Número Inicial de Sequência (Cena)

• Escrevendo uma Imagem, Várias Vezes

  Formatos Especiais de Arquivo de Saída (Específicos do IM)

  miff: info: null: txt: sparse-color: histogram: mpr: mpc: fd: inline: clipboard: -- Ler/Escrever de/para a área de transferência do Windows ephemeral: -- Auto-deletar após a leitura show:, win:, e x: -- Exibir Imagens Diretamente x: (como entrada) -- Capturar e Re-desenhar a Tela Delegados e Codificadores para Formatos de Imagem

• Exemplo de Delegado de Entrada

• Exemplo de Delegado de Saída
• Listando Delegados e Arquivos-Fonte
• Delegado de Impressão
• Disparando Comandos Externos
• Delegados de Postscript e PDF
• Conversão Direta de Formato por Delegado (taint)

• Outros Exemplos de Delegados

  Manipulação de Imagens Realmente Enormes Longos Fluxos de Muitas Imagens, Sequências de Vídeo Para processar uma imagem, você não precisa apenas de operadores para trabalhar sobre as imagens, mas também precisa de maneiras de ler e escrever a imagem em tantos formatos de arquivo diferentes quanto possível. Nesta seção, examinamos os formatos de arquivo do IM em geral.

Resumo dos Formatos de Imagem

Um dos usos mais comuns do ImageMagick não é modificar imagens de forma alguma, mas apenas converter uma imagem de um formato de imagem para outro. De fato, este foi o motivo original da criação do IM: este tipo de conversão de formato de imagem. É por isso que o comando primário do IM se chama "magick". Para esse fim, o ImageMagick pode lidar com uma desconcertante variedade de formatos de imagem e de arquivo. A essa variedade é adicionado um grande número de formatos especiais de entrada e saída para imagens de teste embutidas, criação simples de imagens, e formatos de imagem específicos para programação de shell scripts e programas. Para uma lista completa, consulte a Página de Formatos de Imagem do IM no site do IM. Tudo isso pode ser intimidante para um novo usuário do ImageMagick. Meu melhor conselho é ignorar a maioria dos formatos de arquivo, pois você provavelmente nunca precisará deles. Em vez disso, concentre-se no que você quer fazer e tente fazê-lo. Se você não souber como, tente procurar um exemplo nestas páginas e pela web. Para formatos de imagem demonstrados nos Exemplos do IM, consulte Índice de Referência, Formatos de Arquivo.

Lendo Imagens

Por padrão, o IM tentará determinar o tipo de formato da imagem pelos códigos de identificação 'magic' de arquivo dentro do próprio arquivo. Se isso falhar, no entanto, você precisará especificar o formato de arquivo da imagem usando o sufixo do arquivo, ou adicionando um prefixo de formato. Alguns formatos não lerão arquivo algum e ignorarão qualquer nome de arquivo fornecido. Estas são algumas das imagens embutidas comuns...

  logo:      granite:     rose:

Algumas delas gerarão imagens com base em argumentos fornecidos como um nome de arquivo e talvez um "[-size](https://imagemagick.org/command-line-options/#size)" extra controlando o tamanho final da imagem...

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

Em alguns casos, você pode até usar múltiplos formatos...

  -size 30x30  tile:pattern:gray95

Isso, no entanto, é exagero neste caso, pois o codificador de formato 'pattern:' já tem o codificador 'tile:' embutido nele. Mas deixa claro o que você pretendia fazer. O IM também pode baixar uma imagem que esteja publicada na 'world wide web' especificando a URL dessa imagem. Isso basicamente fornece um codificador de imagem 'http:', que é o motivo pelo qual funciona. |

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

Como você pode ver, este comando lê a imagem da WWW e a redimensiona antes de finalmente salvar o resultado em disco. | Quando um prefixo de formato de arquivo é fornecido, qualquer sufixo dado como parte do nome do arquivo não tem qualquer influência sobre a maneira como o arquivo é lido. Isto é, de fato, vital ao ler alguns formatos de arquivo, como o tratamento do formato de arquivo "[text:](text.html#text)" versus "[txt:](#txt)". Claro que, se um gerador de imagem realmente ler um arquivo de imagem para processá-lo de uma maneira especial (por exemplo, "[tile:](canvas.html#tile)"), então o sufixo (ou prefixo) de formato de arquivo se torna novamente importante, como foi no último exemplo
---|---
Um prefixo de codificador especial "implicit::" pode ser usado para 'desligar' qualquer uso de codificadores, permitindo o uso de ':' no nome do arquivo. Nomes de arquivo podem ter os 'metacaracteres de arquivo' especiais, como '*' e '?', embutidos neles. O IM expandirá esses caracteres para gerar uma lista de nomes de arquivo a serem lidos, evitando a necessidade de um shell externo para fazer isso, ou problemas com limites de comprimento da linha de comando. Por exemplo...

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

Isso produzirá uma única imagem de índice em montagem de todos os arquivos JPEG no diretório atual. Note, no entanto, que eu precisei colocar o argumento entre aspas para impedir que meu shell UNIX expandisse os nomes de arquivo em vez do ImageMagick. Veja abaixo uma especificação mais completa do "magick montage". Claro que os shells do linux também podem expandir caracteres '*' e '?' passados a eles sem aspas. No entanto, em alguns casos você pode acabar atingindo 'limites de linha de comando' se a lista de arquivos expandir para um número muito grande de nomes de arquivo. Aqui estão outros exemplos de uso de um shell linux para expandir o nome do arquivo...

  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

Veja também Ler Quadros, Modificador de Leitura abaixo, para um número incremental formatado no nome do arquivo. Se o nome do arquivo for simplesmente a string de caractere único '-', o IM lê a imagem da entrada padrão. |

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

Note que alguns formatos de arquivo de imagem permitem que você simplesmente anexe múltiplos arquivos de imagem juntos em um longo fluxo multi-imagem. Esses formatos incluem os formatos de imagem simples PbmPlus/NetPBM, bem como o próprio formato de arquivo especial do 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

O caractere especial '@' no início de um nome de arquivo significa substituir o nome do arquivo pelo conteúdo do arquivo fornecido. Ou seja, você pode ler um arquivo contendo uma lista de arquivos! |

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

Você também pode usar '@' com o nome de arquivo especial '-' para ler os nomes de arquivo da entrada padrão. |

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

| A leitura de uma lista de nomes de arquivo de um arquivo usando a sintaxe '@' foi adicionada no IM v6.5.2-1.
---|---
| Como precaução de segurança, isso só funciona com arquivos de imagem reais. Não funciona com geradores de imagem como "rose:" ou "label:string". Também não pode ser usado para 'incluir' opções de linha de comando a partir de um arquivo.
---|---

Modificadores de Leitura ou Configuração Extract

A imagem pode ser modificada imediatamente após ter sido lida na memória, mas antes de a(s) imagem(ns) serem efetivamente adicionadas à sequência de imagens atual. Você pode especificar uma configuração "[-extract](https://imagemagick.org/command-line-options/#extract)". Por exemplo, aqui eu recorto a imagem rose... |

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

Ou você pode anexar um modificador de leitura ao final do nome do arquivo usando colchetes '[...]'. Por exemplo... |

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

Note, no entanto, que os caracteres '[]' são geralmente também metacaracteres especiais do shell, então, se você os usar, é uma boa ideia colocar o modificador adicional entre aspas, para impedir que os shells UNIX o interpretem. Tanto a configuração "[-extract](https://imagemagick.org/command-line-options/#extract)" quanto o modificador de leitura fazem o mesmo trabalho, embora o último sobrescreva o primeiro. Além disso, quando você usa um modificador, deve deixar o IM lidar com quaisquer metacaracteres especiais de expansão de arquivo, como '*' e '?', pois um shell UNIX não 'encontrará' os arquivos solicitados por causa do modificador. O que ele realmente faz nesse caso depende do shell. Por isso, todo o nome do arquivo deve ser colocado entre aspas ao usar modificadores de leitura. O verdadeiro propósito desses modificadores de leitura é limitar a quantidade de memória necessária, removendo imagens indesejadas ou tornando as imagens menores, enquanto as imagens ainda estão sendo lidas na memória. Por exemplo, ao ler um diretório inteiro de grandes imagens JPEG. Aqui está a lista de todos os modificadores de leitura especiais (e configurações "[-extract](https://imagemagick.org/command-line-options/#extract)") e seus efeitos. Um '#' representa algum número.

'[#]' '[#-#]' '[#,#,#]' [#,#-#,#]'. Ler Quadros

Selecionará sub-quadros específicos de um formato de arquivo multi-imagem a partir da imagem que foi lida. O índice numérico '#' fornecido especifica o número do quadro a ler. Múltiplos índices podem ser especificados tanto em ordem separada por vírgulas quanto como um intervalo de índices. O índice da imagem começa em zero para a primeira imagem, 1 para a segunda, e assim por diante. Se você especificar um índice negativo, então a contagem é a partir do final da sequência de imagens, em ordem reversa, -1 para a última imagem, -2 para a penúltima imagem. Esta é exatamente a mesma convenção usada para os Operadores de Listas de Imagens. Por exemplo

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

Você também pode fazer o IM ler imagens com base em uma lista de números. Por exemplo..

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

lerá os arquivos "image_005.png", "image_006.png" e "image_007.png". Com este método, você não pode usar um índice negativo.

'[#x#]' Redimensionar na Leitura

A partir da versão 6.2.6-2 do IM, um novo modificador foi adicionado para ajudar os usuários do IM a lidar com imagens muito muito grandes. Este modificador redimensionará a imagem que acabou de ser lida, imediatamente antes de essa imagem ser adicionada às outras imagens já na memória. Isso pode tanto encolher imagens quanto ampliar imagens. Por exemplo... |

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

Atenção: o modificador de leitura atualmente não usa nenhuma das flags de redimensionamento, como '!' (sem preservação de proporção) ou '>' (somente encolher imagens maiores). (talvez se você fizer um pedido?) Você também pode usá-lo como uma forma alternativa de especificar o tamanho de uma tela de cor sólida. Na verdade, o que está acontecendo é que ele está redimensionando a imagem padrão de um único pixel. Por exemplo... |

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

O modificador é mais importante quando você está tentando ler muitas imagens muito muito grandes, pois cada imagem será redimensionada antes que a próxima imagem seja lida, produzindo uma economia substancial na memória total necessária para lidar com essas imagens. Por exemplo, em vez de...

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

que lê todos os arquivos tiff primeiro e depois os redimensiona. Você pode, em vez disso, fazer...

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

Isso lerá cada imagem e a redimensionará antes de prosseguir para a próxima imagem. Resultando em muito menos uso de memória e possivelmente evitando a paginação em disco (thrashing), quando os limites de memória são atingidos. Para imagens JPEG, também recomendo que você use a configuração especial "[-define](https://imagemagick.org/command-line-options/#define)", produzindo algo como...

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

A configuração especial é passada à biblioteca JPEG e é usada para limitar o tamanho da imagem JPEG durante o processo de leitura. No entanto, ela não é exata, com a imagem resultante ficando em algum ponto entre esse tamanho ou o dobro desse tamanho, com a proporção preservada. Veja Lendo Imagens JPEG para mais detalhes. O resultado da combinação é uma leitura muito mais rápida e um uso de memória ainda menor para imagens JPEG. Especialmente ao gerar muitas miniaturas pequenas. Veja Criação Geral de Miniaturas.

'[#x#+#+#]' Recortar na Leitura

A partir do IM v6.3.1, se você também adicionar um deslocamento, o acima se torna um recorte da imagem que está sendo lida. Por exemplo, para obter uma sub-seção menor de 600x400 pixels de uma imagem muito maior.

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

Isso, no entanto, lerá toda a imagem na memória e depois a recortará antes de ela ser finalmente adicionada à sequência de imagens atual. Se você quer lidar com imagens realmente grandes, sugiro que dê uma olhada no comando "[stream](basics.html#stream)" e canalize sua imagem para o comando "magick" para processamento adicional. Veja Manipulação de Imagens Enormes abaixo. Se a imagem estiver compactada com "gzip", o IM automaticamente a descompactará, em um arquivo temporário, antes de tentar descobrir o formato da imagem e decodificar o formato de arquivo da imagem. Dessa forma, você não apenas pode salvar imagens em formato comprimido com gzip, mas usá-las diretamente em processamento posterior do IM. Para grandes imagens baseadas em texto, isso pode resultar em economias enormes de espaço em disco. | O formato PNG inclui compressão "gzip" como parte de sua especificação de formato. Nesse caso, o primeiro dígito da configuração de dois dígitos "[-quality](https://imagemagick.org/command-line-options/#quality)" do PNG define o nível de compressão. Para mais detalhes, veja os exemplos de Formato de Arquivo de Imagem PNG.
---|---
O acima é apenas um breve resumo das opções especiais de entrada disponíveis ao ler imagens no ImageMagick. Um resumo completo é dado na página A Anatomia da Linha de Comando no Website do ImageMagick.
Como mostrado anteriormente, a entrada de imagem pode ser modificada por algumas configurações do IM, como "[-size](https://imagemagick.org/command-line-options/#size)" para criação de imagem e "[-define](https://imagemagick.org/command-line-options/#define) jpeg:size=??" para leitura de JPEG. Outras opções também afetam a criação da entrada de imagem, incluindo "[-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)". Veja Definindo/Alterando Metadados da Imagem. | Tenha muito cuidado ao passar um argumento fornecido pelo usuário ao IM em um script, garantindo que o argumento seja o que você espera. Você não vai querer deixar um script de processamento de imagem na web retornar uma imagem do arquivo de senhas do sistema, por exemplo.
---|---

Tratamento de Metacaracteres em Nomes de Arquivo de Entrada

Em Construção

Não só o shell trata metacaracteres (a menos que esse argumento esteja
entre aspas), mas o IM também faz sua própria forma de tratamento de metacaracteres em nomes de arquivo.

Por exemplo
  magick *.jpg ....

é expandido pelo shell ANTES de passar os nomes de arquivo ao IM, enquanto

  magick '*.jpg' ....

fará com que o shell passe "*.jpg" ao ImageMagick, que então o expande em
uma lista interna de nomes de arquivo!  Isso foi fornecido para suporte ao Windows DOS, e
como um método para evitar estouros de limite da linha de comando em comandos como
"magick mogrify" e "magick montage", que tipicamente processam longas listas de imagens.

Sendo assim, para realmente fazer o IM ler um arquivo literalmente nomeado em disco como
'*.jpg'  você precisa usar qualquer uma das seguintes formas...

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

NOTA; a segunda linha NÃO é recomendada, pois alguns shells (não o bash) e algumas
APIs (programas em C, possivelmente PHP) podem na verdade remover a barra invertida única, e
passar '*.jpg' ao IM, que novamente o expandirá!

Além de '?' e '*',  o IM também adiciona o tratamento de metacaracteres de  ':', '%'
e '[...]' para tratamento de modificadores de leitura.  Estes, no entanto, têm um significado
diferente  (especificação de codec, inclusão de número de cena, e modificadores de leitura) da
sintaxe normal de shell desses metacaracteres.

Por exemplo, usuários DOS precisarão escapar uma 'letra de unidade' em caminhos de nome de arquivo
sendo passados ao ImageMagick.  Por exemplo...

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

Outro exemplo é ao carregar uma imagem contendo um código de tempo.  Por exemplo..

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

lerá o nome de arquivo "time_10:30.jpg" do disco.  Sem a barra invertida, o IM
pode pensar que a imagem deve ser lida com um formato de arquivo de imagem inexistente
(ou delegado) "time_10:", e falhar de uma maneira inesperada.

Uma alternativa é usar um ponto de interrogação...

  magick "time_10?30.jpg" ...

Porém isso também pode corresponder a outro arquivo, como "time_10_30.jpg" também!

Comprimindo Imagens

Em Construção

O IM também lerá arquivos que foram comprimidos, e que tenham o sufixo
apropriado, ou especificação de formato de imagem.

Ou seja, uma imagem salva como "image.gif.gz"  será primeiro descomprimida, antes
de ser decodificada do seu formato de imagem GIF.

Imagens XPixmap (xpm) e NetPbm/PbmPlus (ppm) comprimidas com Gzip também são automaticamente
tratadas, tanto pelo ImageMagick quanto pela biblioteca delegada normal do formato.  Dessa
forma, você pode usar as formas comprimidas diretamente tanto no IM quanto em outros
programas que entendam esses formatos de arquivo.

Veja  [Salvando Imagens Comprimidas](#save_gzip) abaixo.

Salvando Imagens

Processar imagens é muito bom, mas pode ser igualmente importante salvar os resultados da maneira certa. O último argumento dos comandos "magick", "magick montage" e "magick composite" define um nome de arquivo e um formato de imagem para uma escrita final da imagem (saída de imagem padrão). Embora você também possa salvar uma imagem no meio de uma sequência de imagens usando "[-write](https://imagemagick.org/command-line-options/#write)" (veja abaixo). Para especificar em que formato de arquivo você quer salvar sua imagem, ou imagens, você pode usar um sufixo de nome de arquivo, como uso em praticamente todos estes exemplos, ou prefixar o nome do arquivo com a string "{format}:". Por exemplo... |

  magick tree.gif    GIF:tree_image

Se você verificar a imagem resultante, descobrirá que um arquivo de imagem GIF foi de fato criado, mesmo que o próprio nome do arquivo não tenha um sufixo de nome de arquivo ".gif". O caso do formato não é sensível, então você pode usar tanto minúsculas quanto maiúsculas. Esta especificação de formato de imagem se torna particularmente importante quando você quer salvar a imagem na saída padrão do comando (usando um nome de arquivo "-"). Este nome de arquivo especial não tem sufixo, então você deve informar ao ImageMagick qual formato usar. Se você não o fizer, a imagem voltará por padrão ao formato de imagem original de onde a imagem veio (se conhecido). Por exemplo, aqui escrevemos uma enumeração de pixels do IM na tela usando um "-" para enviar o resultado à saída padrão.

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

Também é usado para passar a imagem a outro comando, como "magick identify", através de um 'pipeline' do shell, sem salvá-la em um arquivo temporário.

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

Neste caso, você também pode ver que o nome de arquivo especial "-" também é usado para denotar a leitura de uma imagem da entrada padrão pelo comando "magick identify". Para mais informações, veja o guia oficial em A Anatomia da Linha de Comando, Nomes de Arquivo de Saída.

Escapes com Percentual em Nomes de Arquivo

O nome de arquivo de salvamento pode conter algumas sequências especiais de escape com percentual (%). Especificamente, '%d', '%x' e '%o'. Elas inserem o 'número de cena' das imagens no nome do arquivo usando os formatos do 'printf()' da linguagem C. Para mais informações, veja Escrevendo uma Sequência Multi-Imagem abaixo. Claro que isso significa que, se você quiser inserir um caractere de percentual no nome do arquivo, precisará duplicá-lo ('%%'). A partir do IM v6.4.8-4, você agora também pode inserir uma configuração especial pré-preparada (deve começar com 'filename:') no nome final do arquivo. Por exemplo... |

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

Isso salva a imagem rose embutida em um arquivo contendo o tamanho dessa imagem em pixels. Especificamente, o nome de arquivo "rose_70x46.gif". Isso permitirá que você (com um pouco de indireção) use qualquer Escape com Percentual de Propriedade de Imagem como parte do seu nome de arquivo de saída. Note que apenas um escape de imagem '%[filename:_label_]' Propriedade pode ser usado dentro do nome de arquivo de saída (junto com o escape normal '%d'). Esta restrição existe por razões de segurança e pelo fato de que nomes de arquivo de imagem legítimos poderiam incluir '%' e '[]'. Atenção: não inclua o sufixo do arquivo na configuração filename! O IM não o verá, e salvará a imagem usando o formato de arquivo original, em vez daquele que foi incluído na configuração filename. Ou seja, o nome do arquivo terá o sufixo que você especificar, mas o formato da imagem pode ser diferente! A configuração 'filename:' não precisa ser a mesma para todas as imagens. Você pode gerar ou até calcular ou definir uma configuração diferente para cada imagem em uso. Aqui está outro exemplo em que modifico uma imagem e a escrevo em um novo nome de arquivo, que foi construído usando o nome de arquivo original de cada imagem individual.

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

Isso amplia cada imagem como "eye.gif" e a salva no arquivo "eye_magnify.gif" no diretório atual. No entanto, todas as três imagens são lidas na memória e depois modificadas pelo único comando. Esta não é uma solução recomendada para uma quantidade de imagens grandes, ou números muito grandes de imagens, devido à possibilidade de atingir os limites de memória e, assim, ir para a paginação em disco (thrashing). Note que o "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)" neste caso é vital para impedir que o IM salve todas as imagens em uma animação GIF multi-imagem, usando apenas o nome de arquivo da primeira imagem. Também me certifiquei de preservar o sufixo original do nome do arquivo usando a sequência de escape "%e". Normalmente, incluir o sufixo na configuração filename é uma má ideia, pois o IM não o vê quando ele vem de uma sequência de escape, para determinar o formato de arquivo de saída. Neste caso, porém, o formato não está mudando, então não há problema. É preciso cautela. Para obter o nome de arquivo original exato da imagem, use '%d/%f' ou '%d/%t.%e'. Você também pode usar '%m' em vez de '%e', que é o formato real (em maiúsculas) que o IM encontrou no arquivo original das imagens (que pode não corresponder ao sufixo original do nome de arquivo das imagens). Note que, para imagens embutidas, muitas dessas strings de sequência de escape ficam em branco. Além disso, se não houver diretório, o '%d' ficará em branco. Este é um problema conhecido para o IMv7. Outro exemplo de uso da 'Sequência de Escape de Nome de Arquivo' está em Recortando Imagens em Mosaico, onde a técnica é usada para gerar um nome de arquivo baseado em uma posição de mosaico calculada para cada uma das imagens resultantes. Veja também o exemplo em Usando Convert em Vez de Mogrify.

Sufixo Automático GZip

O IM também aplicará automaticamente "gzip" às imagens se um sufixo ".gz" for fornecido. Por exemplo, aqui salvo a imagem "rose:" embutida como um arquivo GIF não comprimido, mas compactado com "gzip". Desligo a compressão LZW normal do GIF, pois ela impediria que a compressão "gzip" atingisse sua melhor compressão. |

  magick rose: -compress none  rose.gif.gz

A forma como os navegadores tratam uma imagem comprimida com gzip depende do tipo de arquivo retornado pelo servidor web e de como seu navegador lida com imagens comprimidas. Por causa disso, não exibi a imagem acima diretamente. Clique no ícone de 'arte' para ver o que seu navegador faz com tal imagem deste servidor web. Compare o tamanho disso com uma imagem GIF normal salva com compressão LZW... |

  magick rose: rose.gif

A rose comprimida com "gzip" tem bytes de tamanho, enquanto uma rose normal comprimida com LZW tem bytes. Como você pode ver, a compressão GZIP é, na verdade, ligeiramente melhor que a compressão LZW que o formato GIF usa, então pode ser melhor para fins de arquivamento. Arquivos de imagem comprimidos com GZip são mais comumente usados para armazenamento de longo prazo de formatos de arquivo de imagem que não têm qualquer compressão por padrão. Isso inclui o formato de arquivo do IM "MIFF:" e os formatos de arquivo de imagem NetPBM mais simples.

Atributos Salvos

Em Construção

Outras configurações específicas da escrita de imagem....
    -depth  -quality  -compress -type  -loop
    -set label   -set comment
Veja também [Profundidade de Imagem](basics.html#depth),
[Tipo de Imagem](basics.html#type),
[Qualidade JPEG](formats.html#jpg_write),
[Qualidade PNG](formats.html#png_quality).
[Loop GIF](anim_basics.html#loop).

Falar sobre compressões de arquivo, que fazem parte de vários formatos de imagem.

Diferentes compressões são usadas para diferentes formatos de imagem.

Especialmente a mudança de compressão JPEG para TIFF necessária.

Usando ou "[-compress](https://imagemagick.org/command-line-options/#compress)
None" e a seleção de formato texto/binário NetPBM "[-compress](https://imagemagick.org/command-line-options/#compress)".

A compressão GIF e a patente de direitos autorais.

Além de usar o IM para reduzir -quality ou mudar o formato para algo
diferente, a opção -compression raramente é usada.  Frequentemente, ela é usada apenas internamente
pelo IM para salvar imagens usando a mesma compressão com que a imagem foi lida.

Imagens Criptografadas

O IM também permite que você salve imagens sensíveis criptografadas com uma frase secreta usando as opções "[-encipher](https://imagemagick.org/command-line-options/#encipher)" e "[-decipher](https://imagemagick.org/command-line-options/#decipher)". Veja Criptografando Imagens

Escrevendo Múltiplas Imagens - Técnicas de Adjoin

Um grande problema ao salvar imagens é que o ImageMagick trabalha com uma sequência (lista) ordenada de imagens, não apenas uma imagem por vez. Por causa disso, o IM tentará escrever TODAS as imagens na sequência de imagens atual no nome de arquivo fornecido. Se o formato de arquivo permitir múltiplas imagens, o IM, por padrão, salvará todas as imagens na sequência de imagens atual nesse arquivo de imagem. Por exemplo, se você olhar a página de exemplos Noções Básicas de Animação GIF, você verá que ele salvará múltiplos quadros de imagem em um único formato de arquivo de imagem para produzir uma animação. Se o formato de saída não permitir que você salve múltiplas imagens em um único arquivo, o IM, em vez disso, gerará múltiplos arquivos. Por exemplo, ao salvar em formatos de imagem como JPEG e PNG e assim por diante. Você também pode forçar esse comportamento em formatos de imagem que permitem múltiplas imagens por arquivo, como GIF e PS, usando a configuração de tratamento de arquivo de saída "[+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

Aqui geramos as imagens "image_0.gif" a "image_2.gif", usando um sublinhado em vez do padrão do IM, que é um traço. | _Você não só pode usar '%d' para um número decimal, mas pode usar '%x' para um número hexadecimal (minúsculas), '%X' para um número hexadecimal (maiúsculas), ou '%o' para um número octal.

_
---|---
| _Se você realmente quer um caractere de percentual seguido por uma dessas letras, então precisará duplicar o caractere de percentual para escapar de seu significado. Ou seja, você precisará usar '%%' para garantir que realmente gere um símbolo de percentual.

---|---
| _O '%d' no nome de arquivo de saída na verdade ativa a configuração "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)" do ImageMagick, automaticamente.
Porém, embora eu na verdade não precise do "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)" no acima, provavelmente é uma boa ideia fornecê-lo de qualquer forma, só para que fique claro que você está gerando imagens separadas.
---|---
Isso funciona bem para um pequeno número de imagens, mas se você tiver mais de dez imagens, obterá uma mistura de imagem com números de um e de dois dígitos. E se você tiver mais de cem, obterá também números de três dígitos. Quando isso acontece, as listagens de diretório não mais listarão as imagens salvas em sequência, já que "image_15.gif" apareceria alfabeticamente antes de "image_5.gif". Claro que há maneiras de corrigir isso. Por exemplo, usando expressões de shell de linha de comando 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

O último método é a forma própria do IM de lidar com uma sequência de arquivos, embora você precise saber o intervalo de números que quer usar. O '%d' formata cada número para corresponder ao nome do arquivo (veja a seguir). Em todo caso, isso é trabalhoso e propenso a erros, pode produzir erros se houver arquivos faltando, e pode depender do tipo de sistema computacional que você está usando. É melhor evitar esse problema completamente. Se você está familiarizado com a linguagem 'C' (consulte a página de manual do sistema UNIX para 'printf'), então provavelmente saberá que, se você usar algo como "%03d", sempre obterá números de 3 dígitos (com zeros à esquerda) para o número de quadro da sequência de imagens. Os nomes das imagens seriam, nesse caso, "images_000.gif", "images_001.gif" e assim por diante.

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

Usando este método, as imagens não só serão numeradas, mas também serão listadas alfabeticamente de forma correta, tornando a manipulação dos arquivos de imagem muito mais fácil. Por isso, recomendo que você adicione um '%03d' ou o que for apropriado ao nome de arquivo de saída sempre que planejar escrever múltiplas imagens como arquivos de imagem separados.

Números de Cena Escritos

Se você quer que a sequência de imagens comece em '1', em vez de '0', e não quer renomear todos os arquivos de imagem resultantes, a solução mais simples é antepor uma imagem 'descartável' no início da sequência a ser escrita.

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

Você pode, é claro, usar "[+insert](https://imagemagick.org/command-line-options/#insert)" para fazer isso após seu processamento de imagem. Esta não é uma solução particularmente elegante, mas funciona, e é simples, e compatível com as versões maiores mais antigas do IM. A partir da versão 6.2 do IM, você pode usar a configuração "[-scene](https://imagemagick.org/command-line-options/#scene)" para definir o número inicial da sequência de imagens atual.

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

O que produziu os arquivos de imagem "image_101.gif" a "image_103.gif".

Escrevendo uma Imagem, Várias Vezes

Já que estamos no assunto de escrita de imagens, é possível escrever uma imagem a partir do meio de uma sequência de operações de imagem, usando o operador de imagem especial "[-write](https://imagemagick.org/command-line-options/#write)". Isso é muito útil quando você gosta de produzir uma imagem várias vezes em vários pontos durante o processamento de imagem. Por exemplo, veja Processamento Complexo de Imagem com Depuração. Aqui está um exemplo em que tenho uma Foto de alguns Papagaios, cortesia do Kodak Lossless True Color Image Suite (imagem 23), mas quero salvá-los em uma variedade de tamanhos diferentes, usando um único 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 você pode ver, podemos usar os Operadores de Lista de Imagens para processar um 'clone' de uma imagem, escrever o resultado, depois deletar e retroceder de volta à imagem-fonte original, repetindo o processo quantas vezes você precisar. Neste caso particular, isso significa que não acabei redimensionando a mesma imagem repetidas vezes e, assim, acumulando erros de redimensionamento. Também significou que eu poderia ter, com a mesma facilidade, gerado as imagens menores primeiro, depois as imagens maiores em seguida, sem problemas, ou modificado a imagem de muitas maneiras diferentes para cada arquivo de imagem gerado. Ou seja, a ordem e a modificação de cada imagem é irrelevante! Note que "[+clone](https://imagemagick.org/command-line-options/#clone)" na verdade não duplica os dados da imagem! O IM usa um processo de clonagem com contagem de referências que só copia os pixels da imagem quando eles são atualizados. Dessa forma, apenas memória suficiente para conter a imagem original e a nova imagem que é gerada é de fato utilizada no processo acima. Isso também torna o "[+clone](https://imagemagick.org/command-line-options/#clone)" muito rápido e eficiente em memória.
Aqui está outra técnica para fazer a mesma coisa, mas salvando a imagem original em um registro de imagem nomeado usando "[MPR:](#mpr)" (veja abaixo), em vez 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

Aqui salvamos uma cópia da imagem original no registro de imagem "mpr:scroll", antes de modificar a imagem ainda na memória após a escrita. Note que um registro MPR pode na verdade conter uma sequência inteira de imagens. Uma vez que os resultados dessa operação são escritos e deletados da memória, a imagem original (ou sequência de imagens) é recuperada, e o processo é repetido quantas vezes for necessário. Claro que, como anteriormente, não há necessidade de usar "[-write](https://imagemagick.org/command-line-options/#write)" na imagem final, pois podemos simplesmente produzi-la normalmente. Se você usou um "[-write](https://imagemagick.org/command-line-options/#write)", você pode, em vez disso, simplesmente descartar a imagem final usando outro formato de arquivo especial "[NULL:](#null)" (veja abaixo).Uma palavra de aviso sobre "[-write](https://imagemagick.org/command-line-options/#write)": Como alguns formatos de arquivo exigem que as imagens estejam em um formato especial para a escrita, o operador "[-write](https://imagemagick.org/command-line-options/#write)" poderia modificar imagens. Imagens GIF, por exemplo, podem ter as cores reduzidas (veja Quantização e Pontilhamento). No entanto, outros formatos deixarão a imagem-fonte como está (veja MIFF e MPC abaixo). Se você precisar se proteger dessas alterações (já que você não está simplesmente deletando a imagem em seguida), pode usar "[+write](https://imagemagick.org/command-line-options/#write)", que fará um clone interno da imagem para a escrita e depois o deletará. No entanto, lembre-se de que isso pode resultar em uma duplicação do uso de memória para conter a cópia da imagem modificada pela escrita. Ao menos por um momento.

Formatos Especiais de Arquivo (específicos do IM)

Como você viu acima (e explorará na próxima seção Formatos Comuns de Arquivo de Imagem), o ImageMagick entende um número enorme de formatos de arquivo de imagem bem conhecidos. Ele também inclui um bom número de geradores de imagem especiais (como exemplificado em Criação de Tela). Além desses, há também alguns formatos de arquivo muito especiais, que permitem algumas manipulações muito especiais de imagens.

miff:

É o Formato de Arquivo do ImageMagick. A sequência inteira de imagens e todos os atributos associados às imagens são salvos neste formato de arquivo. Claro que apenas comandos do ImageMagick lerão este formato, então ele não é adequado para transferência entre diferentes pacotes de processamento de imagem. O propósito primário do formato de arquivo "miff:" é como um formato intermediário de salvamento, ao processar imagens de maneiras longas e complexas. Também é adequado para 'canalizar' uma imagem de um comando do IM para outro, transmitindo metadados de imagem e outros atributos associados à imagem. Recomendo que, ao escrever "miff:", você inclua uma opção "[+depth](https://imagemagick.org/command-line-options/#depth)". Isso redefinirá a 'profundidade de entrada' da imagem para a qualidade de memória do IM, de modo a usar a melhor qualidade possível para o salvamento intermediário da imagem. Claro que você pode 'cortar' a profundidade da imagem salva usando "-depth 8", de modo a reduzir o tamanho da imagem em disco, no entanto isso também forçará efeitos de Arredondamento de Quantum (a menos que o salvamento em ponto flutuante HDRI também esteja habilitado). Para os interessados em analisar este formato, ele começa com um cabeçalho de texto simples com todos os atributos da imagem. O cabeçalho termina em uma linha contendo um único caractere de formfeed. Este cabeçalho é, ele próprio, uma forma útil de extrair informações básicas da imagem em vários scripts de processamento de imagem. Por exemplo, aqui uso um comando GNU-sed para listar o cabeçalho "miff:" até o separador formfeed, mostrando todos os atributos da imagem "rose:" embutida.

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

Isso é, na verdade, bastante útil, pois revela todas as flags de configuração atuais e os metadados que o IM conhece sobre a imagem. No entanto, há também estatísticas, pois estas são geradas tanto pelo comando "magick identify", quanto pelo operador "[-identify](https://imagemagick.org/command-line-options/#identify)" ou pelo formato especial "info:"; se solicitadas com uma opção "[-verbose](https://imagemagick.org/command-line-options/#verbose)". (veja a seguir) O formato de arquivo de imagem tem requisitos de análise muito baixos e, embora não seja comprimido, pode lidar com QUALQUER tipo de imagem que o IM conheça. É praticamente o formato mais ideal para usar com imagens temporárias e comandos de imagem canalizados que você pode usar, embora os programas do ImageMagick sejam os únicos que podem lê-lo. Veja também o registro de memória de imagem "[MPR](#mpr)" e os formatos de mapeamento de memória em disco "[MPC](#mpc)" abaixo. | _Os dados brutos da imagem (binários) são, na verdade, prefixados pela sequência de quatro caracteres "\n\f\n:", (formfeed sozinho em uma linha, e dois-pontos). Como esses dados devem ser lidos está codificado nos dados do cabeçalho, mas tipicamente consiste em inteiros binários em tuplas RGB. Mas pode ter mais canais, e poderia até consistir em valores de dados float ou mesmo double.

De muitas maneiras, é praticamente idêntico a um formato de arquivo de imagem binário PbmPlus, com um cabeçalho bastante expandido para conter os metadados da imagem, e mais variações no número de canais e tipos de dados._
---|---

Streaming de Imagem MIFF

O formato "miff:" é um formato de arquivo de imagem de 'streaming'. Ou seja, múltiplas imagens são tratadas simplesmente anexando ou concatenando as imagens juntas, uma após a outra. Isso significa que você pode gerar um 'fluxo' de múltiplas imagens, simplesmente escrevendo as imagens no mesmo destino, como um pipeline. Mesmo que as imagens individuais tenham sido geradas por comandos diferentes. Por exemplo, você pode ter um loop de comandos de processamento de imagem, cada comando simplesmente produzindo uma imagem MIFF em 'streaming'. Após o loop, você pode canalizar o 'fluxo' de imagens para um único comando para gerar montagens, colagens, animações, ou algo mais. Por exemplo, o seguinte gera uma lista de cores começando com a letra 'b', então usa um loop de comandos "magick" para gerar um quadro de cor rotulado, uma cor por vez. Estes são então 'canalizados' para um "magick montage" para gerar uma tabela de cores simples.

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

O exemplo específico acima foi programado em um script "show_colors " que você pode usar para pesquisar, encontrar e exibir cores, para uso no seu processamento de imagem. O acima é um exemplo de um 'Pipeline de Imagens em Streaming ' que é muito útil para gerar sequências multi-imagem. Outros exemplos desta técnica incluem Posicionamento Programado de Imagens em Camadas, Pinos em um Mapa, a 'Imagem de Cores Nomeadas' em Cores por Nome, e as animações como mostrado em Ondulações Aleatórias. Esta técnica também pode ser usada com operações como "-write miff:-", de modo a produzir uma imagem em formato miff a partir de múltiplos pontos em um único comando. Cada imagem será automaticamente anexada junto no fluxo de saída final. Isso pode ser especialmente útil para depurar comandos complexos de processamento de imagem. O método alternativo (comumente usado em scripts PHP) é usar uma técnica de 'comando gerado', que usa um shell script para gerar um longo comando "magick" a ser executado. Os scripts em Animações de Deformação de Imagem usam esta técnica.

info:

O formato de arquivo "info:" (adicionado no IM v6.2.4) NÃO produz uma imagem real! Este formato basicamente produz a mesma informação que o comando "magick identify" do ImageMagick produzirá. Assim como o "magick identify", este formato de saída é controlado pelas opções "[-format](https://imagemagick.org/command-line-options/#format)" e "[-verbose](https://imagemagick.org/command-line-options/#verbose)", permitindo que você produza apenas a informação específica em que está interessado, conforme definido pela página Escapes de Propriedade de Imagem. Por exemplo, em vez de canalizar uma imagem MIFF para "magick identify" como fizemos acima (veja Salvando Imagens), poderíamos ter usado o seguinte, para recuperar a identificação de linha única do formato de imagem resultante.

magick granite: info:-

Claro que você pode usar uma configuração "[-format](https://imagemagick.org/command-line-options/#format)" para produzir a informação desejada de uma forma específica e mais facilmente analisável. O que é tão útil sobre "info:" é que você agora pode produzir sua imagem, enquanto extrai informações extras sobre ela, ao mesmo tempo. Isso é feito usando o operador "[-write](https://imagemagick.org/command-line-options/#write)" para salvar este formato de imagem especial em um arquivo (ou na saída padrão normal do comando). | |

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

| |

Há também um operador "[-identify](https://imagemagick.org/command-line-options/#identify)" que é equivalente a usar "[-write](https://imagemagick.org/command-line-options/#write) info:" para produzir informações de identificação de imagem na saída padrão. Isso torna ainda mais fácil monitorar o que está acontecendo com suas imagens ao depurar seus comandos do IM. Por exemplo... | |

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

| |

Aqui você pode ver como "[-trim](https://imagemagick.org/command-line-options/#trim)" reduziu o tamanho da imagem, mas preserva a informação de 'recorte' de qual parte da imagem foi cortada, então o "[+repage](https://imagemagick.org/command-line-options/#repage)" removendo essa informação extra de 'tela' ou 'página'. E assim por diante. Também, assim como o comando "magick identify", tanto "[info:](#info)" quanto "[-identify](https://imagemagick.org/command-line-options/#identify)" se tornarão muito mais detalhados se a configuração "[-verbose](https://imagemagick.org/command-line-options/#verbose)" estiver ligada. Aqui limito a longa saída apenas às primeiras linhas, só para que você possa ter uma pequena ideia sobre ela.

  magick rose: -verbose  info:  | head

| _A configuração "[-verbose](https://imagemagick.org/command-line-options/#verbose)" também fará com que informações extras sobre imagens sendo lidas ou escritas sejam impressas no erro padrão (com exceção do formato "info:"). Ela também faz com que alguns operadores, como "[-colors](https://imagemagick.org/command-line-options/#colors)", produzam informações adicionais. Por isso, você pode querer desligá-la novamente após usá-la com "[-identify](https://imagemagick.org/command-line-options/#identify)" ou o formato "info:".

Por exemplo _ "-verbose -write info:image_info.txt +verbose" ou "-verbose -identify +verbose" .
---|---
| A leitura via script da saída de qualquer forma de "[identify](basics.html#identify)" deve ser feita de maneira não sensível a maiúsculas/minúsculas. Isso garante melhor compatibilidade retroativa entre diferentes versões do ImageMagick.
---|---
NOTA: "info:" (e "[-identify](https://imagemagick.org/command-line-options/#identify)") é apenas um formato de saída, produzindo a mesma saída que o comando "[identify](basics.html#identify)". Você não pode ler, ou criar uma imagem usando o formato de arquivo "info:". Você também pode usar "[-print](https://imagemagick.org/command-line-options/#print)" para imprimir informações, mas isso é aplicado apenas uma vez sobre toda a sequência de imagens. Isso significa que você pode usar este operador para calcular expressões '%[fx:...]' muito mais complexas envolvendo múltiplas imagens. Mas lembre-se de que, diferentemente dos outros métodos acima, ele é aplicado apenas uma vez sobre todas as imagens.

null:

Como um formato de saída, isto simplesmente 'descartará' os resultados da imagem. Sendo assim, se usado como o argumento final em um comando "magick", "magick montage", ou "magick composite", o resultado final não será salvo! Por quê? Bem, pode ser que você esteja mais interessado em imagens específicas, geradas durante o processamento de imagem, do que no resultado geral, especialmente ao depurar. Por exemplo, aqui extraímos e salvamos uma imagem de uma sequência de imagens, depois descartamos todas as outras imagens usando "null:". |

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

Isso é muito mais simples do que tentar deletar todas as outras imagens uma de cada vez. Como um formato de imagem de entrada, no entanto, "null:" gerará uma imagem especial de espaço reservado, de um único pixel transparente, com uma flag especial de 'origem null', na sequência de imagens atual. Esta imagem especial é especialmente importante para Deixar Lacunas em uma Montagem, e como um separador de lista para Composição de Camadas multi-imagem. Ela está intimamente relacionada a outro formato de imagem especial conhecido como uma 'imagem perdida', que pode ser gerada para operações como "[-crop](https://imagemagick.org/command-line-options/#crop)". Este formato de imagem é produzido quando uma operação produz um resultado vazio ou sem sentido. Ambas as imagens são um único pixel transparente, e dessa forma imagens "null:" também serão tratadas como se fossem uma 'imagem perdida'. No momento, não há método para remover qualquer "null:" ou mesmo 'imagem perdida' da sequência de imagens atual. No entanto, tal método foi proposto. Mande-me um e-mail se você descobrir que precisa de tal método.

txt:

Este é um arquivo de texto ASCII simples, que basicamente lista cada pixel na imagem, um por linha. Não é um conversor geral de texto para imagem, para isso veja Exemplos de Arquivos de Texto de Múltiplas Linhas. Se a 'enumeração de pixels' não for reconhecida, a imagem será passada ao codificador de formato "[text:](text.html#text)", para renderização como um arquivo de texto simples. Por exemplo, aqui está uma imagem "netscape:" escalonada para uma imagem de 2x2 pixels, depois listada usando um formato de imagem "txt:".

magick netscape: -scale 2x2! txt_netscape.txt

A primeira linha (cabeçalho) da imagem está repleta de informações básicas sobre a imagem. A informação consiste em... Magic do Arquivo: O cabeçalho da imagem define este arquivo como o formato especial de imagem de texto do IM (por exemplo, um arquivo "ImageMagick pixel enumeration"), isto é conhecido em círculos da computação como o 'magic' do arquivo, ou a string de código que identifica este arquivo como sendo este formato de arquivo específico. Tamanho da Imagem: Os dois números seguintes definem o tamanho da imagem contida neste arquivo. Multiplicar esses números também lhe dirá quantas linhas devem seguir o cabeçalho para definir totalmente a imagem. O IM sempre produzirá esse número de linhas, embora, como você verá mais adiante ao ler, você NÃO precise definir TODOS os pixels. MaxValue: O último número no cabeçalho define o 'valor máximo' dos dados da imagem que é possível. Nos exemplos acima, isto foi '255', que é resultado do uso de uma profundidade de 8 bits. A razão pela qual ele produziu a imagem "netscape:" embutida nessa profundidade é porque ela foi definida internamente usando valores de 8 bits, e dessa forma o IM preservou esse nível de profundidade para a imagem. Veja a seção sobre a Configuração de Profundidade para mais informações. Mas você pode sobrescrever a configuração de profundidade (até o limite do valor Q do seu IM ou da configuração de Qualidade em Tempo de Compilação), alterando o "[-depth](https://imagemagick.org/command-line-options/#depth)" das imagens. Por exemplo, aqui produzo os valores de cor como valores de 16 bits (de 0 a 65535)...

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

| No momento, você não pode definir um 'Valor Máximo' específico para usar no formato de arquivo de saída. Você só pode definir um valor diferente em termos da configuração atual "[-depth](https://imagemagick.org/command-line-options/#depth)", fazendo com que o valor máximo seja igual a 2^depth-1.
---|---
Espaço de cor: O último item no cabeçalho define o espaço de cor dos dados que seguem. Se a imagem contiver qualquer transparência, uma letra final 'a' (de alfa) também é anexada ao nome do espaço de cor, e uma coluna extra de números é adicionada entre parênteses. Imagens em tons de cinza produzirão uma imagem como 'grey', mas definirão ao menos três números, que serão o mesmo valor para cada pixel. Por exemplo, aqui está a mesma imagem usando um espaço de cor de 'LAB' com um canal alfa adicionado!

  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

Ler imagens TXT também é válido. Você não precisa definir TODOS os pixels na imagem. Na verdade, você nem precisa ter os pixels na ordem correta! O ImageMagick simplesmente lerá cada linha de definição de pixel por vez, e a 'desenhará' sobre uma tela de imagem em branco. Apenas os números entre parênteses em cada linha são usados para isso, não os nomes de cor. A tela em branco inicial é limpa e definida com a cor de fundo atual. Dessa forma, qualquer pixel não fornecido por uma imagem "txt:" será deixado com esta cor. Para um uso interessante de imagens "txt:", olhe Mapeamento de Pixels para a Frente, onde produzo uma Imagem de Pixels Enumerados, depois altero cada uma das localizações de pixel de modo a rotacionar (distorcer) a imagem, antes de ler a Imagem de Pixels Enumerados de volta para o IM novamente. Na imagem resultante, algumas localizações de pixel não foram definidas, enquanto outras localizações tiveram múltiplos pixels adicionados. O IM tratou disso sem problemas.
O formato "txt:" é especialmente útil com o operador "[-unique-colors](https://imagemagick.org/command-line-options/#unique-colors)", que substitui cada imagem na sequência de imagens atual por uma nova imagem contendo um pixel para cada cor única encontrada. Quando isso é produzido em um arquivo de formato "txt:", você obtém um resumo básico das cores contidas em uma imagem (embora não suas contagens, ou histograma). Por exemplo, aqui estão as cores usadas pela imagem tree. Como o GIF só pode usar números de 8 bits, as cores também são produzidas na mesma Profundidade. | |

  magick tree.gif -unique-colors txt:-

|

Há outra alternativa ao uso do formato "txt:" do IM, usando os vários formatos de arquivo de imagem NetPBM. O IM, por padrão, produz este formato como binário, mas você pode desligar "[-compress](https://imagemagick.org/command-line-options/#compress)" para produzir uma versão de texto ASCII do formato NetPBM. Por exemplo.

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

Você pode notar que os números acima correspondem aos números no formato de Pixels Enumerados ("txt:") do IM. Veja Gradiente Redimensionado para alguns exemplos de geração de uma imagem em formato NetPBM para o IM ler. Se você quer apenas a cor de um pixel específico, pode recortar a imagem até um pixel e produzi-la como uma imagem "txt:".

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

Ou você pode usar um Formato de Escape FX especial para produzir a cor em uma forma diretamente utilizável pelo IM.

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

Veja também Extraindo Cores de Imagem.

sparse-color:

Este é um formato especial de imagem de saída que retornará uma lista simples, separada por vírgulas, de coordenadas e cores para cada pixel que não é transparente. A string de saída é adequada para entrada direta no Operador Sparse Color. Por exemplo, isto encontra os poucos pixels 'mais próximos' de uma cor vermelha pura na imagem "rose:".

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

De muitas maneiras, isto é mais útil que o formato "[txt:](#txt)" mostrado acima, mas apenas se um par de pixels estiver envolvido. Esteja avisado, porém, que no momento da escrita, a saída é toda em uma linha. Shell scripts podem querer converter os espaços na saída em novas linhas.

histogram:

Este é, na verdade, o formato de imagem "[miff:](#miff)", mas com um comentário de imagem muito grande que contém uma contagem completa de todas as cores dentro da imagem. Ou seja, no atributo 'Comment={...}' do cabeçalho de texto do "[miff:](#miff)". Por exemplo, aqui novamente listamos as cores presentes na imagem "tree", mas desta vez incluindo a contagem de pixels para cada cor. O comentário de histograma de texto é extraído da imagem "histogram:" usando um magick identify secundário formatado com "[info:](#info)". | |

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

|

| O formato de saída "info:" foi adicionado ao IM v6.2.4. Para versões do IM anteriores a esta, use.. |

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

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

Uma imagem que é muito escura será fortemente ponderada para a esquerda, enquanto uma imagem clara será fortemente ponderada para a direita. Os meios-tons, da mesma forma, são representados no meio. Para ver isto melhor, aqui separo os histogramas para cada um dos canais de cor. Também removo o comentário de texto do histograma (se ainda presente), e redimensiono a imagem para exibição.

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

---

Vermelho |
Verde |
Azul

Para a imagem "rose:" acima, você verá que o vermelho está mais espalhado, mostrando sua importância vital na imagem. Por outro lado, verde e azul têm picos à esquerda, mostrando que têm muito pouca influência sobre a imagem. Se você está mais interessado no brilho de uma imagem do que em suas cores, converta a imagem para escala de cinza antes de gerar uma imagem "histogram:". |

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

Como você pode ver, o histograma de uma imagem em escala de cinza é um pouco diferente. Como a cor vermelha predominante se torna mais uma cor cinza de meio-tom, produzindo um pico no centro do histograma. Também a pequena área de branco-sujo na imagem agora produz um pico distinto na extremidade direita do gráfico. O espaço completamente vazio na extremidade esquerda também mostra que não há manchas escuras na imagem. Por outro lado, um histograma 'global' melhor pode ser gerado simplesmente separando todos os canais de cor na imagem original e anexando. O histograma resultante é uma representação de todos os valores de cor, independentemente de qual canal esse valor seja. |

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

Infelizmente, como "histogram:" é um formato de saída, você precisará 'canalizar' a imagem para outro comando, salvá-la em disco, ou usar o salvamento/leitura especial "[mpr:](#mpr)", se quiser processar a imagem mais a fundo. Veja o exemplo em "[mpr:](#mpr)" abaixo. Seria bom se algum método de gerar histogramas (e outros gráficos) se tornasse disponível como operadores em vez de um formato especial de saída.

mpr:_{label}_

(Memory Program Register / Registro de Memória de Programa) salvará a sequência inteira de imagens em um registro de memória nomeado, do qual você pode posteriormente ler os dados da imagem. Sendo assim, se você quer salvar uma imagem para uso posterior, em uma operação de imagem complexa, você pode fazê-lo. Escrever em um "mpr:" no fim do processamento é inútil, pois a memória do programa é devolvida ao sistema quando o programa termina. Por isso, você vai querer usar uma operação de Escrita para salvar as imagens em um arquivo no meio das suas etapas de processamento, se você precisar dela em um processo diferente. O 'label ' dado ao "mpr:" pode ser qualquer coisa que você quiser, é apenas um rótulo de onde a imagem foi salva na memória. Pode até ser apenas um número simples para pessoas que fazem scripts e não querem lidar com nomes, embora nomes possam tornar seu script mais fácil de seguir. Depois que você tiver salvo uma imagem (veja abaixo), você pode então ler a imagem novamente, a partir da mesma localização de memória 'rotulada', quantas vezes você quiser. Por exemplo... |

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

Note o uso de "[+delete](https://imagemagick.org/command-line-options/#delete)" no processamento de imagem acima. No exemplo acima, não é necessário (basta reler o "mpr:tree" duas vezes em vez de três), mas é muito comum Deletar todas as imagens da sequência de imagens atual após salvar as imagens em um registro "mpr:". Basicamente, as duas linhas no acima podem ser pensadas como dois comandos "magick" completamente separados, mas usando um registro de memória nomeado para a imagem intermediária em vez de espaço em disco. De muitas maneiras, usar "mpr:" é como usar Clone ou Duplicate (que poderíamos ter usado no exemplo acima), mas usar "mpr:" permite que você remova completamente todas as imagens, para limpar a lista de imagens atual para outro trabalho. A melhor característica deste método é que ele também permite que você use configurações e operações que só funcionam na entrada de imagem. Por exemplo, usando-o com o operador de imagem de entrada "[tile:](canvas.html#tile)" para ladrilhar uma imagem sobre uma área maior. |

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

Você também pode usar "mpr:" para capturar a saída de alguns dos filtros especiais de formato de imagem de saída para processamento adicional. Por exemplo, aqui salvamos a imagem de saída de "[histogram:](#histogram)" e depois a lemos de volta para continuar a processá-la no mesmo comando, |

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

O salvamento em memória "mpr:" é, na verdade, a única forma de você reutilizar imagens já em memória através de filtros de E/S especiais, como um formato de arquivo de saída como "[histogram:](#histogram)" ou um formato de arquivo de entrada como "[tile:](canvas.html#tile_memory)". O mesmo é verdade para as opções especiais que recebem uma imagem de entrada real, como "[-tile](https://imagemagick.org/command-line-options/#tile)" ou para imagens de "[Mapeamento de Cores](https://imagemagick.org/command-line-options/#map)" usando outra imagem como fonte. Veja Mapas de Cores Multi-imagem. NOTE que tais opções estão sendo substituídas no IMv7 por versões que não precisam que a imagem seja lida de um arquivo. É também a única forma de usar o método -draw 'image' para sobrepor imagens usando uma imagem gerada em memória, embora haja muitas outras técnicas para fazer isso. A imagem "mpr:" na verdade salva a sequência inteira de imagens e não apenas uma imagem. É um pouco como tirar um instantâneo da sequência de imagens atual para que você possa recarregá-la posteriormente para processamento adicional. Isso, por exemplo, permite que você tire cópias de uma sequência de animação inteira, para duplicar ou clonar, sem precisar saber quantas imagens estão de fato envolvidas. Veja Composição de Camadas para um exemplo de como fazer isso. Quando você tem múltiplas imagens em "mpr:", você pode na verdade ainda extrair imagens individuais dessa sequência! Usar "mpr:image'[2]'" puxará a terceira imagem de uma sequência multi-imagem salva usando "-write mpr:image". Por exemplo, aqui extraio a imagem 'storm' de um conjunto de quatro imagens. |

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

O operador de Clonagem de Imagem geralmente não consegue lidar com um número variável desconhecido de imagens e, de fato, antes de o operador Clone ser adicionado, "mpr:" era o único método disponível para duplicar imagens em memória, sem usar arquivos de disco intermediários. | A partir do IM v6.8.2, você também pode armazenar imagens em um processo daemon de cache remoto do IM. Isso permite que imagens (e seus metadados) sejam passadas entre comandos do IM executados separadamente, sem precisar de espaço em disco. Veja Daemon de Cache de Pixels Distribuído
---|---

mpc:

É um formato especial de salvamento em disco específico do IM que foi originalmente projetado tendo em mente imagens realmente grandes. Basicamente, é um arquivo de disco mapeado em memória da memória do programa, salvo em disco como dois arquivos binários, um ".mpc" contendo os metadados da imagem, e um ".cache" contendo o cache de pixels da imagem.

O formato "MPC:" cria dois arquivos para salvar uma imagem

Tais arquivos não funcionarão após o IM ser recompilado ou atualizado, e apenas para o IM compilado para uma máquina específica. Sendo assim, ele só serve para arquivos temporários de 'leitura rápida', como ao conter imagens temporárias usadas por processamento de imagem com scripts, e não para armazenamento de longo prazo. Por exemplo...

  magick very_big_image.tif  very_big_image.mpc

criará dois arquivos no disco. Um pequeno arquivo "very_big_image.mpc" e um arquivo especial de dump de memória chamado "very_big_image.cache". O segundo arquivo provavelmente terá um tamanho muito maior que qualquer outro formato de arquivo de imagem, pois é apenas um dump de memória bruto e não comprimido. No entanto, o arquivo não precisa ser 'lido' ou 'decodificado', mas pode ser diretamente 'paginado' para a memória do computador, e usado exatamente como está, sem qualquer sobrecarga de processamento. Apenas muito espaço em disco e E/S de disco. Em outras palavras, ele só precisa de tempo de acesso ao disco para ler, sem qualquer processamento de formato de arquivo. Ou seja, nenhuma decodificação dos dados é necessária. Como a imagem está 'pronta na memória', é especialmente útil para imagens temporárias de todos os tamanhos, pois será imediatamente utilizável pelo próximo comando do IM que você emitir. Mas lembre-se, dois arquivos são gerados e eles serão maiores que o tamanho de um arquivo de imagem normal, então tenha cuidado com seu uso de disco e a limpeza do script. Meus próprios scripts do IM fazem bom uso deste recurso. Por exemplo, veja os scripts "de-pixelate" e "divide_vert", que fazem uso de uma quantidade bastante grande de arquivos de imagem temporários para operações de processamento de imagem. Isso pode ser extremamente útil para scripts ou Composição Alpha com Mogrify que precisam conseguir ler a mesma imagem, repetidas e repetidas vezes, pois o IM não precisa decodificar a imagem, ou usar muita memória apenas para armazená-la. Isso também é muito útil para processar uma imagem muito grande, onde você deve extrair ou Recortar uma seção menor da imagem para o processamento real. No entanto, como a maioria das operações de imagem na verdade fazem cópias clonadas das imagens durante o processamento, uma nova cópia em memória ainda poderia ser feita. Por isso, ainda é necessário algum cuidado. Um Recorte ou Redimensionamento para tamanhos de imagem muito menores são as operações mais seguras para a manipulação de imagens grandes com MPC. Para mais informações, veja Manipulação de Imagens Realmente Enormes abaixo.

fd:{file_descriptor}

Este nome de arquivo especial permite que você especifique um 'descritor de arquivo ' específico de onde a imagem deve ser lida ou para onde deve ser escrita. O nome 'fd:0' é a 'entrada padrão ' e 'fd:1' é a 'saída padrão ' do programa. Estes são equivalentes a usar um '-' como nome de arquivo. No entanto, você pode especificar qualquer 'descritor de arquivo ' de onde ler/escrever a imagem. Incluindo 'fd:2' para o 'erro padrão ', ou qualquer outro manipulador de arquivo previamente aberto que o programa pai possa ter providenciado. O uso mais comum disso é em scripts de shell muito avançados, onde você pode ter múltiplos fluxos de arquivo de imagens. Ou para daemons de rede que possam ter múltiplos fluxos de arquivo abertos simultaneamente.

inline:{base64_file|data:base64_data}

Imagens inline permitem que você leia uma imagem definida em uma codificação base64 especial. Por exemplo, para ler uma imagem codificada em base64, use...

inline:base64_image.txt

Esta codificação poderia vir de um arquivo, mas é mais tipicamente fornecida diretamente como o argumento de leitura, em vez de um nome de arquivo, a partir de alguma fonte externa de imagem. Isso é mais tipicamente usado como uma alternativa a 'blobs' na linha de comando, ou no processamento de imagem por API. Ou coloque os dados da imagem diretamente na linha de comando...

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

Por exemplo, vamos codificar em base64 uma imagem muito pequena (há muitos programas que permitirão que você faça esta conversão)...

  openssl enc -base64 -in noseguy.gif

Note que dados base64 podem conter qualquer quantidade de espaço em branco, como retornos e novas linhas. Ele é simplesmente ignorado pelo formato. Ele também só usa caracteres ASCII normais, que é a razão pela qual é usado para codificar dados binários para e-mail e páginas web. Também permite que dados binários sejam armazenados em programas e scripts sem problemas. Por exemplo, eu poderia ter o seguinte comando em um shell script, de modo que o próprio script tenha a imagem embutida nele e, assim, não precise de uma fonte de imagem externa separada. |

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

Lembre-se, com isso a imagem poderia ser usada no seu script (shell ou API). Você não precisa ter um arquivo de imagem externo separado, tornando a instalação de um script de outra forma simples mais complicada. Então por que "[inline:](#inline)" tem esta forma um tanto complicada? Basicamente porque este é o formato usado para imagens inline em páginas web HTML. Por exemplo, no seguinte, a imagem à direita foi incluída diretamente inline na página web, e não como um arquivo externo separado, usando uma tag HTML da 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 >

Isso não funcionará com todos os navegadores web, por exemplo não funcionará com o IE7 e anteriores, mas funcionará com o IE8. Basicamente, os navegadores web mais modernos o entendem.
O mesmo tipo de formato de dados inline também é usado para imagens de 'rosto' em cabeçalhos de e-mail, e provavelmente em muitos outros tipos de arquivo. À PARTE: Graças à parte 'magic' do ImageMagick, a maioria dos formatos de arquivo de imagem não precisa ter o mime-type (a parte 'image/gif' da string longa) incluído. E, na verdade, ele é completamente ignorado pelo IM em todo caso). No entanto, a vírgula ',' ainda é necessária para marcar o fim dessa parte da string de dados da imagem inline. |

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

AVISO: A entrada de opção de linha de comando é restrita a 5000 caracteres. Além disso, muitos shells (e particularmente a entrada do PC-DOS) têm limites totais de comprimento da linha de comando. Sendo assim, isto não é adequado para imagens base64 muito grandes.

clipboard:

Lê ou Escreve a imagem de ou para a Área de Transferência do Windows. (Apenas Windows).

ephemeral:{image_file}

Lê e então Deleta este arquivo de imagem. Este é um formato especial de leitura de arquivo de imagem que fará com que o IM delete o arquivo de imagem fornecido após esse arquivo ter sido lido na memória. Note que a imagem na memória não terá sido processada ou mesmo salva quando o arquivo lido tiver sido removido. Isto é muito perigoso e deve ser usado com extrema cautela. É usado principalmente em Disparo de Delegados. Aqui, o delegado de segundo plano lerá a imagem de entrada, depois a deleta quando tiver os dados. Isso, por sua vez, notifica o processo 'pai' em primeiro plano que o 'filho' está pronto para prosseguir por conta própria, pois terminou de ler a imagem fornecida. O programa principal pode então fazer a limpeza e continuar seu processamento de imagem separadamente, ou simplesmente sair, conforme o caso. O delegado de saída de imagem "show:" usa isto com o comando "magick display", para automaticamente colocar em segundo plano uma exibição de imagem antes que o comando principal continue ou saia. (veja abaixo) Por exemplo, usei isto em um shell script que chama "[flicker_cmp](../static/img/scripts/flicker_cmp)" para exibir alguns resultados intermediários, mas então continua (ou sai) automaticamente quando o IM sinalizou que o programa terminou de ler sua imagem de entrada deletando a segunda imagem fornecida. Se você precisa desse feedback, mas também precisa preservar a imagem que está sendo lida, então faça uma cópia, hard link, ou link simbólico para a imagem original, e passe esse arquivo como "ephemeral:". Dessa forma, quando ele for deletado, a imagem original é preservada. NOTA: No momento, não há forma de fazer com que "animate" ou "display" sinalizem quando terminaram uma animação, ou efetivamente colocaram a imagem para exibição. :-( No entanto, você pode fazer com que "magick" leia uma imagem "ephemeral:" separada, para notificar um script controlador de que ele atingiu um ponto específico em seu processamento de imagem.

# Borra uma imagem, e mostra uma comparação na tela antes # de auto-deletar e sair. magick rose: input_image.png magick input_image.png -blur 0x5 blurred.png flicker_cmp input_image.png ephemeral:blurred.png &

# espera a segunda imagem ter sido lida e deletada! while [ -f blurred.png ]; do usleep 100; done

# Neste ponto podemos continuar (ou sair) sem problemas. # enquanto a exibição na tela continua em segundo plano. rm -f input_image.png

Também usei isto em outros programas de segundo plano, como um sinal de que esse programa de segundo plano está pronto para continuar.

show:, win: e x: -- Exibir imagens diretamente na tela

Estes são formatos especiais de saída que exibirão diretamente o resultado da imagem na sua tela. Em vez de salvar a imagem em um arquivo, ele apenas exibe o resultado. Isto é muito útil para testar rapidamente comandos do IM para ver quais serão os resultados, e é altamente recomendado para esse propósito. No entanto, eles são apenas versões muito simples dos comandos "[display](basics.html#display)" e "[animate](basics.html#animate)". Por exemplo, obtenha um resumo rápido das imagens em um diretório...

magick montage *.jpg show:

Veja as áreas que são diferentes entre duas imagens...

  magick compare image1.png image2.png show:

Todos os formatos listados aqui, na verdade, recorrem ao programa "[display](basics.html#display)" para realizar sua tarefa. No entanto, cada um deles trata o trabalho de maneiras diferentes. Por exemplo, 'show:' usará um Delegado de Disparo para executar um programa "[display](basics.html#display)" separado. Isso significa que, uma vez que a imagem tenha sido exibida, o comando original continuará seu processamento (tipicamente saindo, a menos que você use "-write show:"). Por outro lado, usar 'x:' ou 'win:' esperará que você feche a janela de exibição antes de permitir que o comando original continue (e saia). Infelizmente, nenhum desses métodos exibirá animações muito bem. Para isso, é melhor você canalizar a animação (em formato MIFF) para o comando "[animate](basics.html#animate)".

x: (como entrada) - Lendo uma Tela X Window

Você também pode ler a tela X window atual usando o operador "x:", da mesma forma que pode com o comando "import". De fato, sem opções, ele age exatamente como o comando "import". Use o botão esquerdo para selecionar a janela da qual capturar uma cópia, ou marque uma área usando o botão do meio. Por exemplo, para selecionar uma janela usando seu mouse, depois exibir a janela que acabou de capturar em outra janela (sair quando a janela capturada for exibida)...

magick x: show:

AVISO. Se você capturar uma janela que está desmapeada (iconizada), ou tem outra janela sobre ela, o conteúdo da imagem conterá ou uma área em branco, ou o conteúdo da janela sobreposta!!! Por isso, certifique-se, ao capturar uma janela, de que essa janela esteja totalmente visível na tela. Para capturar a tela inteira, use 'root' como nome da janela.

  magick x:'root'  full_screen_dump.jpg

Ou use os Modificadores de Leitura para capturar uma área específica da tela.

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

Fornecendo um nome de janela, você pode capturar uma janela específica. Por exemplo, isto capturará a janela intitulada 'MailEd'...

  magick x:'MailEd'  window.jpg

No entanto, isso não funciona realmente bem, pois muitas vezes você tem múltiplas janelas com o mesmo nome, ou o nome da janela simplesmente não pode ser determinado. A melhor forma é informar ao IM a janela exata desejada usando um "ID de Janela X", que é o número que a tela X usa para identificar exclusivamente uma janela específica (ou janela filha). O ID de Janela X é tipicamente consultado usando o comando "xwininfo", mas outros programas como "xdotool" e "xwit", bem como outras ferramentas como "xprop", podem ser usados para encontrar informações sobre as janelas. Por exemplo, coisas como classe da janela, nome, título, seu tamanho e posicionamento, janelas filhas, e a decoração do gerenciador de janelas. Por exemplo, encontre todas as janelas com "Mozilla Firefox" no título ou nome...

  xwininfo -root -all | grep "Mozilla Firefox"

Posso então extrair o ID de Janela X da janela que quero da saída do acima. Aqui está um script bash um pouco mais complexo que tenho no meu gerenciador de janelas. Quando pressiono um botão, ele consulta o ID da janela com o 'foco' atual, captura-a, depois nomeia o arquivo como um PNG no meu diretório atual usando o próximo número de captura, de acordo com quaisquer capturas anteriores feitas.

  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
  "

A maioria dos programas de terminal lhe dirá o ID de Janela X que estão usando para exibir texto na variável de ambiente "WINDOWID". Sendo assim, se você executar isto a partir de uma linha de comando de um XTerm, ou Gnome Terminal, você capturará uma cópia da janela de terminal atual.

  magick x:$WINDOWID  this_terminal.png

Agora, para um pouco de diversão... Aqui capturo o conteúdo do meu terminal atual, desenho algumas coisas nele, e depois uso o "[display](basics.html#display)" para desenhá-lo de volta na mesma janela 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 -

O primeiro comando no acima é projetado para uma janela "XTerm", que exige que a janela na qual você "magick display", seja a janela filha do "WINDOWID" fornecido. A segunda linha recorre ao valor original do "WINDOWID" se nenhuma janela 'filha' for encontrada, como é o caso de uma janela "Gnome-Terminal". Uma vez que a janela a ser usada está definida, ela é capturada, desenhada, e restaurada na janela de terminal! E pronto, você tem saída gráfica instantânea diretamente na janela de terminal atual. Aqui está um exemplo mais simples, este escurece o conteúdo da janela cada vez que você o executa. Tente executar isto algumas vezes em uma janela "xterm" real, e você descobrirá que quanto mais antigo o comando na janela de terminal, mais escuro ele fica!

  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 -

E aqui está uma 'captura de tela' mostrando o que aconteceu enquanto eu repetia o acima na minha própria janela "xterm"...

Esteja avisado de que, embora o conteúdo do terminal seja modificado, é apenas temporário. Se você iconizar, obscurecer, ou mudar de tela da área de trabalho, e depois voltar ao terminal, as modificações serão perdidas, pois o programa de terminal re-desenha a janela, e apaga seu próprio 'desenho'. O acima não funciona nem de longe tão bem para um "Gnome-Terminal" quanto para "XTerm"s, porque o primeiro gosta de 're-desenhar' sua janela toda vez que rola, onde um "XTerm" não. Imagine scripts do IM que exibem os resultados de gráficos e outras coisas diretamente em várias janelas como parte de um programa cliente maior. É, de fato, assim que muitos visualizadores de postscript, e até muitos navegadores web, exibem a saída de sub-programas especiais. Ou seja, eles fazem com que esse sub-programa assuma e desenhe diretamente em uma sub-janela fornecida. Experimente, e por favor me informe (e a outros) o que você descobrir, seja via e-mail ou no Fórum de Usuários do IM.

Codificadores e Delegados para Formatos de Imagem

Codificadores são módulos de biblioteca dinâmica (geralmente escritos na linguagem de programação C) que tratam do aspecto "format:" da entrada e saída de imagem. Eles também podem ser usados pelos usuários para criar filtros de propósito especial. Eles podem exigir a instalação de bibliotecas externas adicionais, que são frequentemente chamadas de 'bibliotecas delegadas'. Eles são carregados como módulos dinâmicos apenas conforme necessário, o que significa que as bibliotecas associadas usadas por um codificador não precisam ser instaladas, a menos que você queira efetivamente fazer uso desse codificador. Estes exemplos não entrarão na programação em C necessária para escrever codificadores, mas há um codificador de exemplo no código-fonte que pode ser usado para criar seus próprios módulos de codificador.
Um Delegado é simplesmente um comando que o IM conhece, que lhe permitirá converter entre diferentes formatos. Isso permite que o IM use esse comando 'mais simples' e pré-escrito, em vez de exigir um codificador binário mais complexo para tratar algum formato de arquivo de imagem. Para obter uma lista de quais delegados estão disponíveis, use o comando especial...

  magick -list delegate

O programa 'delegado' mais conhecido que o IM utiliza é o "ghostscript", que permitirá que o IM leia e converta as imagens vetoriais muito complexas do formato Postscript e PDF em algum outro formato de arquivo de imagem raster que o IM possa ler. No entanto, 'Comandos Delegados ' são muito úteis também para os usuários, pois permitem que você expanda o IM de modo que ele possa tratar tipos especiais de imagens, ou fornecer métodos alternativos para ler e escrever essas imagens. Os 'comandos' em si são listados em um arquivo chamado "delegates.xml", que está localizado no diretório de configuração do sistema do IM. Mas ele também lerá um "delegates.xml" localizado no subdiretório pessoal ".magick" do diretório home Linux/UNIX do usuário. E é neste segundo arquivo que os usuários devem colocar seus 'comandos delegados'.

Exemplo de Comando de Delegado de Entrada

Por exemplo, posso criar um arquivo "delegates.xml" pessoal no subdiretório ".magick" do meu diretório home Linux/UNIX, da forma...

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

Este é um arquivo de configuração 'delegado' completo, mas apenas a linha do meio é um delegado real. Um muito simples que diz ao IM que, se ele vir uma imagem com um sufixo '.flip' ou um prefixo de formato 'flip:', ele deve chamar o comando acima, para ler a imagem de formato 'flip'. Por exemplo.. |

  magick flip:tree.gif   delegate_tree_flip.gif

Neste caso, tudo o que o comando delegado faz é usar um comando "magick" do IM separado para 'virar' a imagem de cabeça para baixo, antes mesmo de o comando original do IM ler e processar a imagem! O delegado pressupõe que o comando entenderá o formato de arquivo de imagem fornecido e que retornará QUALQUER formato de arquivo de imagem que o próprio IM possa entender e processar (um formato de arquivo de imagem MIFF neste caso). As partes '%i' e '%o' do delegado representam nomes de arquivo temporários, os nomes de arquivo de entrada e saída fornecidos que o delegado deve usar. Estes nomes de arquivo são gerados pelo IM, e estarão localizados em um diretório temporário. Estes nomes de arquivo temporários também NÃO têm nenhum sufixo de imagem, então é importante que você prefixe o tipo de formato de imagem desejado, se necessário. Isso é feito dessa forma por razões de segurança, e porque o próprio IM pode estar apenas lendo um fluxo de dados, e não um arquivo real. Também significa que o comando delegado não precisa lidar com coisas como a limpeza desses arquivos quando terminar. Há outras substituições de '%' para coisas como um segundo nome de arquivo temporário para arquivos temporários intermediários, densidade da imagem, tamanho, e assim por diante. Mais detalhes sobre esses escapes e outras opções de delegados são fornecidos nos comentários no topo do arquivo 'de sistema' "delegate.xml" instalado do IM. Ora, isto pode parecer um exemplo bastante bobo e trivial, mas basicamente significa que você agora pode usar um comando secundário para converter QUALQUER arquivo de dados em QUALQUER imagem que o IM entenda. O IM então saberá como tratar esse tipo de dado automaticamente, dado o sufixo da imagem, ou um prefixo de formato, sem que você precise lembrar de todos os detalhes. Muitos delegados deste tipo já foram adicionados ao arquivo de sistema, então vale a pena dar uma olhada. | _Por razões de segurança, delegados em um arquivo "delegates.xml" pessoal não sobrescreverão os delegados definidos no arquivo "delegates.xml" instalado pelo sistema. Você só pode adicionar novos formatos de delegado únicos em ".magick/delegates.xml" no seu diretório home, delegados duplicados posteriores serão ignorados.

Claro que, se o formato de entrada já for conhecido internamente, então é claro que os delegados de sistema não são consultados.

Além disso, como sempre, sanitize qualquer entrada do usuário (especialmente do usuário web), pois você não quer que o usuário faça uso de um delegado sem você saber disso.

_
---|---
Por exemplo, a partir do IM v6.4.2-6, um delegado "autotrace:' foi adicionado ao arquivo de delegados de sistema, que executará o comando "[AutoTrace](http://autotrace.sourceforge.net/)" enquanto lê QUALQUER imagem de entrada. O IM converte a imagem de entrada para o formato de imagem PNG exigido pelo programa delegado, filtra-a através do delegado, depois lê o SVG resultante (tipicamente via uma biblioteca RSVG externa), para gerar uma versão de bordas suaves da imagem de bitmap de entrada original. Veja Exemplo de Conversor de Raster para Vetor. Se um conversor gerar múltiplos arquivos de imagem (como PNG), você precisará mesclar todas essas imagens separadas em um único formato multi-imagem, como o MIFF, de modo que o IM possa ler as múltiplas imagens do único arquivo de saída. Às vezes, o IM encadeará múltiplos programas delegados para ler uma imagem. Por exemplo, para ler uma página 'HTML' como uma imagem, ele primeiro chama o delegado "html2ps" para convertê-la em postscript. Depois, ele converte o arquivo postscript gerado em um conjunto de múltiplas imagens usando o programa delegado especial "ghostscript". Claro que usar dois, ou mais delegados assim pode produzir outros problemas devido às interações complexas, instalações incorretas, e bugs que possam estar presentes nos programas delegados. Mas, em geral, funciona, e é um aspecto-chave do que torna o ImageMagick mágico.

Exemplo de Delegado de Saída

Coisas semelhantes são feitas ao salvar em formatos de arquivo de imagem específicos que o IM não entende diretamente. Por exemplo, adicionando este delegado ao seu arquivo ".magick/delegates.xml" pessoal, você pode informar ao IM como criar um arquivo de imagem '.xyzzy'.

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