Exemplos do ImageMagick -- Uso Básico

Aqui explicamos em detalhe o processamento de linha de comando que o IM segue, algumas das novas capacidades de processamento de imagem, as ideias, a filosofia e a metodologia, e o que está realmente acontecendo internamente. Com esse conhecimento de fundo, o restante das páginas de exemplos fornecidas torna-se muito mais claro. Mesmo que você use apenas a Interface de Programação de Aplicações (API), esta seção vale muito a pena conhecer e compreender.

Processamento de Linha de Comando do ImageMagick

Por que o estilo da linha de comando mudou! ou...

O problema com as versões anteriores do IM

Nas versões principais anteriores do ImageMagick (versão 5.5.7 e anteriores), a interface de linha de comando para a biblioteca IM estava sujeita a problemas envolvendo a ordem em que as operações eram realizadas. Era bastante aleatório e confuso para qualquer um que tentasse entender o que estava realmente acontecendo. Além disso, o que funcionava de uma vez podia não funcionar na mesma ordem em outra ocasião, à medida que o autor do IM batalhava constantemente com a interface para fazê-la funcionar como as pessoas esperavam. A causa do problema era que o ImageMagick seguia um estilo de linha de comando UNIX bastante padrão...

**command  [options]  input_image   output_image**

Com o tempo, isso começou a produzir problemas, pois imagens são objetos complexos com um enorme número de operações que podem ser realizadas sobre elas, muitas vezes envolvendo outras imagens. Como consequência disso, a forma acima foi lentamente expandida para se tornar..

**command  [options] image1 [options] image2 [options]  output_image**

Isso funcionava, e é o estilo básico que foi usado na versão 5.5.7. As várias operações de imagem, como "[-negate](https://imagemagick.org/command-line-options/#negate)", "[-resize](https://imagemagick.org/command-line-options/#resize)" e "[-crop](https://imagemagick.org/command-line-options/#crop)", etc., podiam aparecer antes ou depois da imagem à qual deveriam ser aplicadas. Por exemplo, na versão 5.5.7, os dois comandos a seguir eram igualmente válidos e faziam a mesma coisa.

  magick -negate  image.gif   output.gif

  magick  image.gif  -negate  output.gif

O problema era: e se você estivesse lidando com duas operações de processamento de imagem! Por exemplo...

  magick -size 40x20 xc:red  xc:blue \
          -append   -rotate 90    append_rotate.gif

O resultado (no IM v5.5.7) era que as duas imagens de entrada eram rotacionadas primeiro e, em seguida, anexadas juntas, produzindo uma imagem como... Ou seja, o operador "[-rotate](https://imagemagick.org/command-line-options/#rotate)" seria aplicado ANTES do "[-append](https://imagemagick.org/command-line-options/#append)", o que provavelmente não é o que o usuário pretendia.
Com o ImageMagick versão 6, os operadores serão sempre aplicados na ordem da linha de comando dada pelo usuário.
Assim, o exemplo anterior no IMv7 resultará em: as duas imagens sendo anexadas juntas primeiro e, em seguida, esse resultado será rotacionado; produzindo isto...
Se o usuário realmente pretendia fazer as rotações antes do append, ele pode pedir explicitamente ao IM v6 que o faça nessa ordem.

  magick -size 40x20 xc:red  xc:blue \
          -rotate 90  -append    append_rotate_bad.gif

Esse tipo de controle fino estava simplesmente além das versões anteriores do IM e provavelmente teria exigido um pipeline, ou imagens intermediárias salvas, para ser alcançado. A solução para o problema, infelizmente, exigiu uma medida drástica e alguma incompatibilidade. Por outro lado, praticamente todo comando 'simples' que funcionava no IM versão 5 funciona como você esperaria no IM versão 6. Em essência, o uso da linha de comando nas versões anteriores à versão 6 era mal definido e, no meu modo de pensar, quebrado, produzindo numerosos resultados estranhos e inesperados.

Sintaxe de comando do IMv7

Observe que nenhuma 'operação' deve ser dada antes que pelo menos uma imagem seja lida ou criada. Na verdade, você pode considerar uma 'leitura/criação de imagem' também como uma operação. Afinal, ela é realmente uma operação de processamento de imagem, a de traduzir uma imagem em um arquivo para uma imagem na memória. Portanto, a maneira correta de fazer isso no IMv7 é ler a imagem, processar e então usar o argumento final de 'escrita implícita' para gravar o resultado. Ou seja..

**command  "image" { -operation }... "output_image"**

É claro que existem algumas configurações que podem ser necessárias para controlar a leitura da imagem e que precisam ser fornecidas antes de realmente ler a imagem (veja abaixo o significado de uma configuração). Assim, a sintaxe do IMv7 basicamente segue o seguinte...

**command { [settings] [operation] }...  "implict_write"**

Com a parte em '{...}' sendo repetida com quantas 'leituras' ou 'operações' você quiser ou precisar. E '[operation]' sendo uma leitura ou criação de imagem, ou uma operação de processamento de imagem que realmente 'faz algo'. E você as faria na ordem exata em que deseja processar as imagens.

Tipos de Opções - Operadores e Configurações...

Um resumo do que se segue também está disponível agora no Site do ImageMagick em A Anatomia da Linha de Comando. Todas as opções de linha de comando agora se enquadram em dois grupos básicos: 'configurações' e 'operadores de imagem'. As configurações definem valores, os operadores efetivamente realizam alguma ação. Opções de Configuração

| são opções de linha de comando que apenas salvam informações que serão usadas mais tarde por outros 'operadores de imagem'. Ou seja, elas não fazem nada, exceto definir algum valor a ser usado posteriormente. Muitas das opções têm tanto o estilo '-' quanto o '+'. O último é geralmente usado para desligar a configuração, ou redefini-la para seu estado padrão normal. Isso permite remover o efeito de uma configuração de forma rápida e simples. Por exemplo, "[+gravity](https://imagemagick.org/command-line-options/#gravity)" retornará a configuração de gravity ao estado inicial 'gravity none'. As configurações podem ainda ser divididas em várias subcategorias... Configurações de Operador que controlam como os operadores posteriores funcionam. Elas definem as cores e fontes que podem ser usadas por um operador, controlam o posicionamento de imagens e texto, a busca de cor em imagens de origem, controlam o método de processamento de alguns dos operadores mais complexos, etc., etc., etc..

-dither -gravity -fill -background -bordercolor -stroke -font -pointsize -strokewidth -box -virtual-pixel -interpolate

A maioria das opções de configuração pertence a esta categoria. Configurações de Entrada são especificamente restritas ao controle da criação de imagens que são criadas ou lidas. Tipicamente, são usadas para atribuir ou substituir metadados específicos que devem ser associados à(s) imagem(ns) criada(s) após aquela configuração ter sido definida. Elas são criadas ou lidas a partir de um arquivo externo.

-label -delay -dispose -page -comment -size

Lembre-se, elas são SOMENTE aplicadas quando uma imagem é criada ou lida, e caso contrário são completamente ignoradas. O operador especial "[-set](https://imagemagick.org/command-line-options/#set)" foi fornecido para alterar os metadados das imagens depois que elas foram lidas para a memória, ou processadas de alguma forma. Veja Metadados abaixo para mais detalhes. Configurações de Saída que são usadas apenas durante a escrita ou salvamento de imagens de volta ao disco. Embora possam ser fornecidas em qualquer lugar na linha de comando, elas só são aplicadas quando a imagem é gravada, seja como a operação padrão do argumento final de nome de arquivo de imagem, seja por meio de uma operação "[-write](https://imagemagick.org/command-line-options/#write)" ou "[-identify](https://imagemagick.org/command-line-options/#identify)".

-quality -loop -compression -format -path -transparent-color

Se não definidas, ou desligadas (usando sua forma com mais '+'), um padrão apropriado será usado. Geralmente esse padrão é um valor salvo da última imagem lida. Algumas 'configurações de operação', como a cor "[-background](https://imagemagick.org/command-line-options/#background)" atual, também são atribuídas à imagem, se o formato de arquivo exigir. Configurações de Controle e Depuração que controlam como o IM, em geral, executa suas tarefas. Estas incluem...

-verbose -debug -warnings -quiet -monitor -regard-warnings

Veja Controles de Operação do IM abaixo, para mais informações sobre essas configurações especiais.

Operadores de Imagem
| São argumentos de linha de comando que modificarão a(s) imagem(ns) de alguma forma. Eles são realizados imediatamente quando vistos, e podem usar outras 'opções de configuração' que tenham sido fornecidas anteriormente na linha de comando. Esses operadores podem ser agrupados em algumas subcategorias... Operadores de Criação de Imagem que lerão imagens de um arquivo ou pipeline, ou gerarão novas imagens. Estes incluem...

image.png xc: canvas: logo: rose: gradient: radial-gradient: plasma: tile: pattern: label: caption: text:

Como 'operadores', eles também são realizados imediatamente quando vistos na linha de comando. Eles apenas adicionam novas imagens àquelas já na memória, mas não tocam nas previamente lidas. É claro que, sendo operadores, quaisquer 'configurações' definidas previamente serão aplicadas a eles. Especialmente as Configurações de Entrada, usadas para controlar a entrada a partir do arquivo ou fluxo de arquivo. Por exemplo, "[-size](https://imagemagick.org/command-line-options/#size)", que sugere o tamanho da imagem que você deseja criar, ou configurações que definem ou substituem metadados de imagem, como "[-delay](https://imagemagick.org/command-line-options/#delay)" e "[-page](https://imagemagick.org/command-line-options/#page)". Operadores Simples de Processamento de Imagem modificarão todas as imagens que já foram lidas para a memória. Cada imagem é modificada separadamente das demais. Eles incluem operações como...

`-crop -repage -border -frame -trim -chop -draw -annotate -resize -scale -sample -thumbnail -magnify -adaptive-resize -liquid-resize -distort -morpohology -sparse-color -rotate -swirl -implode -wave -flip -flop -transpose -transverse -blur -gaussian-blur -convolve -shadow --radial-blur -motion-blur -sharpen -unsharp -adaptive-sharpen -adaptive-blur -noise -despeckle -median -negate -level -level-color -gamma -auto-level -auto-gamma -sigmoidial-contrast -normalize -linear-stretch -contrast-stretch -colorize -tint -modulate -contrast -equalize -sepia-tone -solarize -recolor -opaque -transparent -colors -map -ordered-dither -random-dither -raise -paint -sketch -charcoal -edge -vignette -emboss -shade -poloroid -encipher -decipher -stegano -evaluate -function -alpha -colorspace -separate

E provavelmente muitos outros operadores que eu esqueci! (ou que foram adicionados)`

Como todos os operadores de imagem são realizados imediatamente quando vistos na linha de comando, eles devem ser fornecidos depois das imagens sobre as quais devem operar terem sido lidas para a memória. Se mais de uma imagem estiver presente, todas as imagens são operadas, uma de cada vez em sequência. Assim, você terá que ter cuidado com qual(is) imagem(ns) você tem na lista de imagens atual. Observe que é possível que alguns desses operadores gerem múltiplas imagens. Por exemplo, "[-crop](https://imagemagick.org/command-line-options/#crop)" poderia gerar múltiplos 'ladrilhos' de imagem, ou "[-separate](https://imagemagick.org/command-line-options/#separate)", que divide imagens em imagens de canal separadas. Assim, você pode acabar com mais imagens na memória. Mas todos eles tomam apenas uma imagem de cada vez como entrada. Observe que muitas APIs aplicam apenas a operação equivalente à primeira imagem na lista de imagens fornecida. Ou seja, elas podem não iterar sobre cada imagem. Os comandos "magick" e outros CLI (interface de linha de comando), no entanto, aplicam o operador a cada imagem na lista de imagens atual, por vez. Operadores de Lista de Múltiplas Imagens são especiais por modificarem toda a lista atual de imagens como uma única entidade. Eles podem substituir toda a lista por uma única imagem combinada, ou modificar cada imagem dependendo das outras imagens encontradas antes ou depois dela. Eles são usados para composição alfa, manipulação de animação, manipulação de canais de cor, etc...

-append -flatten -mosaic -layers -composite -combine -fx -coalesce -clut -evaluate-sequence mean -evaluate-sequence

Lembre-se de que toda a lista é tratada como uma única entidade, e algumas imagens podem ser removidas ou substituídas. A maioria dos operadores acima mescla todas as múltiplas imagens fornecidas em uma única imagem final. O método Layers Composite é atualmente o único operador que dividirá a lista de imagens atual em duas listas de imagens completamente separadas, antes de mesclá-las para formar uma lista de imagens completamente nova. Ele faz a divisão procurando pela imagem especial 'null:' em algum lugar na lista de imagens atual. Nenhum desses operadores pode ser usado em um comando "[mogrify](#mogrify)", pois esse comando processa uma lista de imagens de entrada (fornecidas no final) como imagens individuais. Operadores de Pilha de Imagem afetam a ordenação da lista de imagens atualmente na memória. Especificamente, eles fornecem um processamento especial 'paralelo' de imagens. Eles são, de muitas formas, semelhantes ao Operador de Lista de Imagem anterior, mas não modificam as imagens em si, apenas como elas estão dispostas na memória.

( ) -delete -insert -swap -reverse -duplicate -clone

Observe que os parênteses '(' e ')' podem exigir escape com barra invertida ou aspas, para evitar qualquer significado especial dado a eles pela Interface de Linha de Comando do shell (CLI). Nenhum desses operadores pode ser usado em um comando "[mogrify](#mogrify)", pois esse comando processa uma lista de imagens de entrada (fornecidas no final) como imagens individuais. Operadores Especiais Diversos são operadores que fazem coisas de maneiras incomuns ou não padronizadas (em comparação com os acima).

-geometry -version -list -bench -concurrent -preview

O operador "[-geometry](https://imagemagick.org/command-line-options/#geometry)" é especial, pois é o único operador que afeta apenas uma imagem (a última) na lista de imagens, em vez de afetar todas as imagens de alguma forma. Ele é fornecido apenas para compatibilidade retroativa e requisitos especiais de composição alfa. Veja Geometry, redimensionar apenas a última imagem para mais detalhes. Os outros dois, "[-version](https://imagemagick.org/command-line-options/#version)" e "[-list](https://imagemagick.org/command-line-options/#list)", são operadores geradores de informação e fazem o IM encerrar explicitamente após retornar a informação solicitada. Veja Controles Especiais do IM abaixo, para mais informações sobre essas opções. Algumas opções poderiam até fazer com que o comando inteiro fosse executado várias vezes. Basicamente, elas são tratadas de forma especial, de algum modo estranho e incomum. Geralmente, estas não são usadas, exceto em situações especiais ou para recuperar informações globais específicas.
Espero que a separação das opções em configurações e operadores esteja clara, pois é vital para a forma como o IM agora funciona. Lembre-se de que, na versão 6 do ImageMagick...

As Configurações são salvas de alguma forma para uso posterior,
enquanto os Operadores são aplicados imediatamente às imagens.

Isso é o que torna a versão 6 diferente de todas as versões anteriores do IM. Todas as opções são definidas como uma 'configuração' ou um 'operador', e a ordem determinará exatamente quando, e a quais imagens, a opção será aplicada. A Referência de Opções dos Exemplos do IM pode ser usada para identificar o que é uma 'configuração' e o que é um 'operador'.

Exemplo Prático de um Comando do IM

Vamos dar uma olhada em um exemplo e em como ele será processado pelo IM versão 6. |

  magick eye.gif news.gif -append    storm.gif tree.gif \
           -background skyblue +append    result.gif

Vamos detalhar isso e ver o que o IM v6 faz... Argumento | | Ação Realizada | Imagens
---|---|---|---

magick | Inicializar e criar uma 'lista de imagens' vazia | seq vazia
eye.gif | Ler a imagem e adicionar ao final da lista de imagens atual | 1 imagem
news.gif | Adicionar uma segunda imagem à lista (agora com duas imagens) | 2 imagens
-append | Tomar todas as imagens na lista atual e anexar verticalmente.
Todas as imagens são substituídas por uma única imagem. | 1 (mesclada)
storm.gif | Adicionar outra imagem à lista de imagens | 2
tree.gif | E mais uma | 3
-background skyblue | Definir uma 'cor de fundo' a ser usada mais tarde.
Nenhuma alteração é feita em nenhuma imagem. | 3
+append | Juntar todas as 3 imagens na lista horizontalmente
A cor de fundo atual é usada para preencher o espaço vazio | 1 (mesclada)
result.gif | Como este é o último argumento, uma operação -write implícita é realizada com este argumento. A única imagem na lista atual é gravada usando o nome de arquivo fornecido, que também define o formato de arquivo de imagem a ser usado. | gravada
Como você pode ver, o processamento da linha de comando no ImageMagick versão 6 é muito direto e lógico, tornando o resultado previsível. E esse é o ponto...

Estilo de Linha de Comando Legado

Devido ao fato de que muitos scripts IM muito antigos por aí usam um comando com um único operador de imagem da forma...

**command  -operator  input_image   output_image**

Ou seja, você especificava um operador de imagem antes de realmente ler a imagem à qual o operador seria aplicado. Para lidar com essa situação legada, o IM salvará todos os operadores de imagem que vir e os aplicará à primeira imagem quando ela for finalmente vista na linha de comando. Ou seja, o exemplo acima funcionará como se você tivesse escrito a operação no estilo do IMv7...

**command  input_image   -operator  output_image**

Por exemplo, este comando legado do IMv5 (tratamento de opções no estilo UNIX).... |

  magick -flip  storm.gif   cmd_flip_legacy.gif

Produzirá o mesmo resultado que este comando do IM versão 6... |

  magick storm.gif -flip  cmd_flip_postfix.gif

O estilo de linha de comando legado funciona, mas tem os mesmos problemas que afligiam o IM versão 5 (veja Por que o estilo da linha de comando mudou acima). Todas as configurações são aplicadas antes da primeira leitura, e todos os operadores são simplesmente guardados para serem executados quando a primeira imagem for lida (e somente na primeira imagem). Também não há garantia de que a ordem de múltiplos operadores será a mesma que a ordem que você fornece, embora seja provável que sejam aplicados nessa ordem. Além disso, como os operadores ficam guardados até que a primeira imagem seja realmente lida, você pode descobrir que repetir um comando várias vezes antes de ler a imagem pode resultar no 'desaparecimento' de alguns dos comandos anteriores. Isso não é um bug, mas um uso indevido das capacidades legadas do IM. Esse estilo de linha de comando é apenas para suporte legado e, como tal, está obsoleto, portanto deve ser evitado sempre que possível. Quaisquer scripts contendo esse estilo antigo também devem ser atualizados para fazer leituras de imagem antes dos operadores que você deseja aplicar a elas. | O suporte legado continuará no IM versão 7, que inclui um comando que permite o processamento de passagem única de linhas de comando. Isso permite que ele realmente leia opções de processamento de imagem de arquivos de script e até de um pipeline. No entanto, uma técnica de processamento de passagem única não permitirá salvar operadores ANTES de ler uma imagem à qual aplicá-los. Na verdade, o comando "magick" produzirá erros do tipo 'no image' se você tentar usar um operador sem uma imagem na memória.
---|---

Linha de Comando vs API

Existem algumas diferenças importantes entre o IM de linha de comando e o uso das APIs do Magick, como PerlMagick, RMagick, PHP IMagick e MagickWand.

Apenas uma Lista de Imagens Ativa

A linha de comando só tem uma Lista de Imagens que pode ser trabalhada a qualquer momento. Você pode 'empilhar' ou salvar uma lista de imagens temporariamente (veja Parênteses e MPR: Registradores de Memória Nomeados). Você pode até 'clonar' (fazer uma cópia eficiente) de imagens da última lista 'empilhada'. Mas você não pode realmente trabalhar em duas dessas listas ao mesmo tempo. As APIs de outras linguagens, por outro lado, permitem que você tenha quantas listas de imagens ou 'wands' separadas quiser. De fato, você normalmente salva cada imagem como um wand separado (lista de imagens e configurações) para melhor processamento, e só mescla a imagem em uma lista conforme necessário ou como parte da etapa final. Você também pode trabalhá-las em qualquer ordem e armazená-las em bancos de dados ou outras estruturas de dados, para ordenação ou comparação posterior. Na linha de comando, no entanto, uma única lista de imagens significa que você não pode fazer operações em qualquer ordem, mas geralmente tenta fazer as coisas em uma sequência mais lógica, terminando completamente cada etapa de processamento de imagem à medida que avança. Basicamente, isso significa que é muito mais difícil 'voltar atrás' ou alterar algo mais tarde, usando resultados de um conjunto de operações para selecionar ou modificar qual conjunto de operações de processamento deve ser realizado em seguida. É especialmente mais difícil mesclar ou intercalar (embaralhar) duas listas de imagens completamente separadas em um todo lógico. No entanto, algumas técnicas foram desenvolvidas para permitir que você faça isso a partir da linha de comando. Por exemplo, veja Composição Alfa em Múltiplas Camadas de Listas de Imagens.

Acesso Direto aos Dados de Pixel

Novamente, você pode fazer algum processamento matemático e mesclagem de dados de pixel a partir da linha de comando, mas não pode facilmente consultar atributos, ou ler e modificar um pixel ou área específica usando a interface de linha de comando. Você pode mesclar e modificar matematicamente os dados de pixel de imagens usando o Operador de Imagem FX especial, mas ele é geralmente limitado à transformação de imagens inteiras e é muito, muito lento. Para facilitar, muitas operações comuns desenvolvidas por usuários usando o operador FX agora foram incorporadas ao IM, criando coisas como Tabelas de Busca de Cor, Funções Matemáticas de Avaliação e Funções de Múltiplos Argumentos. Bem como o Operador Geral de Distorção de Imagem e alguns Métodos Especiais de Composição de Imagem. As APIs podem manipular imagens de uma maneira muito mais direta, permitindo que você crie uma operação única por conta própria muito mais facilmente, na velocidade total fornecida pela linguagem da API.

Processamento Condicional

A interface de linha de comando do IM não pode modificar facilmente imagens com base em algum atributo derivado da imagem. Por exemplo, é muito difícil processar imagens de forma diferente dependendo de a imagem usar um fundo claro ou um fundo escuro. Sim, você pode fazer algumas ações condicionais limitadas e específicas usando o Operador de Imagem FX, ou pedir ao IM para ajustar (rotacionar) a Orientação de uma imagem com base em certas condições, ou apenas reduzir e nunca ampliar ao Redimensionar Imagens. Mas estes lidam apenas com condições de processamento especiais, bem conhecidas e comuns. A única maneira verdadeiramente prática de fazer processamento condicional é usar comandos separados e arquivos temporários. Para um exemplo disso, veja o bem comentado Script de Quebra-Cabeça. As APIs, por outro lado, podem fazer esse tipo de processamento condicional, mantendo todas as imagens envolvidas na memória, prontas para continuar o processamento com base nas condições específicas, conforme e quando você precisar.

Processamento em Laço

Você também não pode simplesmente iterar sobre imagens de maneira controlada, ou modificar facilmente o processo com base em qual imagem da sequência está sendo manipulada. Ou seja, você não pode simplesmente fazer algo diferente para cada imagem com base no número de 'cena' da imagem, ou nos resultados de imagens anteriores. Por exemplo, desenhar texto em tamanhos diferentes, ou desfocar gradualmente uma imagem, ou gerar uma lista de animação em um único comando. Sim, você pode modificar imagens específicas em uma lista de imagens. Por exemplo, veja Modificação Quadro a Quadro de uma Animação. Mas você deve saber quantas imagens há na lista de imagens, e 'desenrolar' o laço para processar cada imagem na lista separadamente. A única maneira verdadeiramente prática de iterar sobre imagens a partir da linha de comando é gravar as imagens individuais como arquivos de imagem separados (veja Gravando Múltiplas Imagens) e processá-las uma de cada vez em um laço de script externo. Por exemplo, veja o script de shell que foi projetado para Dividir uma Imagem Verticalmente. Alternativamente, você pode gerar as imagens usando um laço de script de shell e canalizar o resultado para um comando final para mesclá-las na imagem final ou sequência de imagens. Para um exemplo disso, veja Exemplos de Imagens em Camadas, ou os vários geradores de scripts de shell de Animações de Imagens Deformadas. As APIs, no entanto, não têm problema em iterar sobre múltiplas imagens, seja em uma única lista de imagens, ou até em múltiplas listas de imagens, ou mesmo com um array ou estrutura de dados inteiros de listas de imagens. Elas também podem manter todas as imagens na memória prontas para a etapa final de combinação, sem pipeline ou uso de arquivos temporários.

Se sua aplicação precisar ser capaz de fazer qualquer uma dessas coisas (embora poucas aplicações realmente precisem ir tão longe), então uma API pode ser uma escolha melhor. O programa "[magick conjure](#conjure)" (veja abaixo) foi originalmente projetado para permitir um uso mais bem programado do ImageMagick, permitindo o uso de múltiplas listas de imagens. As melhorias feitas no "magick" do IM v7 fizeram com que essa API experimental caísse em desuso, embora ainda esteja disponível e ainda esteja sendo desenvolvida.

Tratamento de Argumentos

Além dos nomes de arquivo e opções na linha de comando, existem apenas alguns estilos básicos de argumentos de opção que são usados.

• Nomes Constantes (para configurações específicas e tipos de método)
• Lista de Nomes Constantes (por exemplo, duas cores, ou Canais)
• Argumento de Geometria (uma lista de números especialmente formatada com flags)
• Listas de Ponto Flutuante (às vezes com Escapes de Porcentagem)
• Strings de Texto de Forma Livre (com Escapes de Porcentagem)

Nomes Constantes

Nomes Constantes são constantes de string específicas que são usadas para consultar uma biblioteca interna de configurações permitidas que podem ser usadas por uma opção. Por exemplo, a configuração "[-gravity](https://imagemagick.org/command-line-options/#gravity)" pode receber qualquer uma de nove configurações diferentes. Uma vez definida, essa configuração é então usada por todos os operadores de processamento de imagem que seguem a configuração na linha de comando. Por exemplo: configurações como 'North', 'East' ou 'NorthEast'. Você pode obter uma lista de todas as configurações válidas usando a Opção Operacional List (veja abaixo). Por exemplo, usando o comando...

  magick -list gravity

Somente essas configurações específicas são permitidas e, se você tentar usar alguma outra configuração, receberá um erro. Por exemplo...

  magick xc: -gravity Invalid   null:

A configuração pode ser especificada de várias maneiras diferentes, todas perfeitamente válidas. O IM é muito tolerante quanto a isso. Por exemplo, uma configuração pode ser especificada em maiúsculas, minúsculas, ou qualquer combinação das duas. As palavras individuais (especificadas por letras maiúsculas na saída de "[-list](https://imagemagick.org/command-line-options/#list)") podem ter espaços extras, hifens ou sublinhados incluídos, que são então simplesmente ignorados (mas apenas entre as palavras). Consequentemente, todos os argumentos a seguir são válidos para definir "[-gravity](https://imagemagick.org/command-line-options/#gravity)" como "North East"...

'`NorthEast`', '`northeast`', '`NORTHEAST`', '`NorTheAst`', '`north east`', '`north-EAST`', '`NORTH_EAST`', '` North East `', '`___North___East___`'.

Mas um argumento de 'Nor The Ast' não é válido, mesmo que as letras estejam todas corretas, pois usa espaços dentro das palavras declaradas da configuração. Esses nomes constantes não são apenas para configurações, mas também para declarar o método operacional a ser usado em alguns dos operadores de processamento de imagem mais complexos, como "[-layers](https://imagemagick.org/command-line-options/#layers)", "[-distort](https://imagemagick.org/command-line-options/#distort)" e "[-morphology](https://imagemagick.org/command-line-options/#morphology)". Alguns dos nomes constantes são lidos de arquivos de configuração externos. Por exemplo, nomes de cores como para "[-fill](https://imagemagick.org/command-line-options/#fill)", "[-stroke](https://imagemagick.org/command-line-options/#stroke)", "[-background](https://imagemagick.org/command-line-options/#background)" e "[-mattecolor](https://imagemagick.org/command-line-options/#mattecolor)". Ou os mapas de 'threshold' especiais usados para "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)". Novamente, "[-list](https://imagemagick.org/command-line-options/#list)" pode ser usado para consultar quais nomes a sua versão atualmente instalada do IM conhece.

Lista de Nomes Constantes

Este é um argumento pouco usado e é mais comumente usado em configurações que precisam de uma ou duas cores, como Ajuste de Nível por Cor. A opção "[-level-colors](https://imagemagick.org/command-line-options/#level-color)" pode receber qualquer um dos seguintes estilos de argumento.

color color1,color2 color1-color2

Também é usado para Seleção de Imagem, em operações que fazem uso de múltiplos índices de imagem, por exemplo Duplicate e Clone. Os índices começam com zero para a primeira imagem, enquanto índices negativos podem ser usados para denotar índices de imagem a partir do final da lista de imagens. Por exemplo, '-2-1' significa pegar da segunda última imagem (índice '-2') até a segunda imagem (índice '1'). E sim, isso realmente significa pegar as imagens na ordem inversa à especificada! Outra opção que faz uso intenso disso é a Seleção de Canal, onde você pode especificar uma lista de canais especificamente nomeados. Por exemplo: 'Red,Green,Blue,Black,Alpha'. No entanto, a Configuração de Canal também pode usar uma forma abreviada usando uma string de letras individuais (Ex: 'RGBA')

Argumentos de Geometria

Esta é a forma mais comum de argumento de opção, e é tipicamente usada para especificar tamanhos, retângulos e deslocamentos para várias operações. Mas também é usada por qualquer opção que precise de uma lista de 1 a 5 números, sejam eles inteiros ou de ponto flutuante. Por exemplo, opções como "[-crop](https://imagemagick.org/command-line-options/#crop)" e "[-resize](https://imagemagick.org/command-line-options/#resize)" usarão a sintaxe completa de um argumento de geometria, enquanto outras como "[-border](https://imagemagick.org/command-line-options/#border)", "[-level](https://imagemagick.org/command-line-options/#level)" e "[-gamma](https://imagemagick.org/command-line-options/#gamma)" podem usar apenas uma pequena parte da sintaxe completa de geometria. Esse tipo de argumento é tão comum que um analisador especial (e complexo) foi escrito para converter tais argumentos de string em números e flags, para uso por qualquer operador que precise de um argumento de geometria. Um argumento de geometria basicamente permite que um usuário especifique um único argumento de string contendo até 5 valores de ponto flutuante (embora a maioria dos operadores use apenas inteiros). Todas as seguintes formas de string são compreendidas pelo analisador de argumentos de geometria...

WxH+X+Y WxH +X+Y A A/B/C A,B,C,D,E

Os usuários podem especificar a pequena lista de números em QUALQUER uma dessas formas, mas tipicamente qual forma é usada depende da operação para a qual o argumento está sendo usado. As primeiras são tipicamente usadas para a especificação de um retângulo de tamanho e localização específicos, ou apenas um deslocamento para algum propósito. Deslocamentos são sempre decodificados em números diferentes, aqueles em cada lado de um 'x' na string. Ou seja, um "+X+Y" é sempre decodificado como o 3º e o 4º números, enquanto sinaliza que o 1º e o 2º são indefinidos (ou zero). As últimas formas permitirão até um máximo de 5 valores de entrada possíveis, e são tipicamente usadas para especificar um valor para cada um dos canais de imagem RGBKA padrão. Além desses números, o analisador também relata se quaisquer caracteres 'flag' especiais estão presentes (qualquer um de '%', '^', '!', '<', '>' ). O analisador, no entanto, só relata se os caracteres estão presentes. Ele não relata onde foram encontrados no argumento. O IM, por exemplo, não lembra que '%' estava anexado a um número específico. Ele também não relata se aparece várias vezes. Isso significa que um argumento de geometria de '%50' tem exatamente o mesmo significado que '50%', embora o último seja preferido para legibilidade. Além disso, '50%x30' provavelmente significará '50%x30%' e NÃO 50% da largura da imagem e 30 pixels de altura, como você poderia pensar. | _Como os argumentos de geometria podem conter flags '%' especiais, você atualmente não pode usar Escapes de Porcentagem para definir seus valores com base em atributos de imagem.

Existe uma Proposta Futura sobre exatamente quando um escape de porcentagem será expandido, que poderia corrigir esse problema com argumentos de geometria. E, esperançosamente, fará parte do IMv7.

_
---|---

Listas de Ponto Flutuante

Se mais de 5 números de ponto flutuante forem necessários, talvez até um número desconhecido de valores, então um argumento de Lista de Ponto Flutuante é usado, embora no momento estes sejam geralmente analisados por opções individuais, pois podem variar ligeiramente de opção para opção. Geralmente, consistem em uma string (tipicamente entre aspas) de números de ponto flutuante separados por vírgula ou espaço. O Operador Distort é provavelmente o operador mais conhecido a usar uma lista de números de ponto flutuante. Outros incluem Kernels de Morfologia e Convolução Definidos pelo Usuário, embora ele também tenha sintaxe extra específica para definir um array de números (kernels). Uma variante de números de ponto flutuante é usada por "[-sparse-color](https://imagemagick.org/command-line-options/#sparse-color)", permitindo que você substitua cores por alguns valores de ponto flutuante. Internamente, estes ainda são convertidos em valores de ponto flutuante quando o array resultante é passado para a função da biblioteca central.

Strings de Forma Livre

Outras opções simplesmente tomam uma string como argumento. Seja para gerar rótulos, anotar texto ou salvar como metadados de imagem. Estas tipicamente incluirão Escapes de Porcentagem na string, que são substituídos em algum ponto antes de a string ser usada. Pode ser uma substituição imediata, ou a substituição pode ser realizada mais tarde, logo antes de o argumento ser realmente usado. (Veja Escapes de Porcentagem Adiados abaixo.

Argumentos com Escapes de Porcentagem

Escapes de Porcentagem Adiados

Observe que, para algumas opções de configuração, os Escapes de Porcentagem não são expandidos imediatamente quando vistos, mas simplesmente armazenados COMO fornecidos. Só mais tarde, quando o texto é realmente usado, é que quaisquer Escapes de Porcentagem encontrados na string devem ser expandidos, quando a imagem com a qual serão usados é finalmente conhecida. Ou seja, esses argumentos devem adiar a substituição dos Escapes de Porcentagem até que o argumento seja realmente usado. Essas opções incluem as Configurações de Entrada, como: "[-label](https://imagemagick.org/command-line-options/#label)", "[-comment](https://imagemagick.org/command-line-options/#comment)", bem como a configuração "[-format](https://imagemagick.org/command-line-options/#format)" e os valores globais de "[-define](https://imagemagick.org/command-line-options/#define)". Isso significa que você pode especificar um "[-label](https://imagemagick.org/command-line-options/#label)" contendo Escapes de Porcentagem específicos da imagem muito antes de a imagem à qual ele será aplicado ser realmente lida. Somente quando o rótulo é realmente anexado à imagem (logo após ela ser lida) é que os Escapes de Porcentagem são expandidos, para que possa fazer uso dos atributos da imagem à qual está sendo aplicado. | _A principal limitação para o uso mais difundido dosEscapes de Porcentagem é que ele é atualmente aplicado apenas a um conjunto limitado de argumentos de opção. Por exemplo, atualmente não podemos usá-los com Argumentos de Geometria, que também usam caracteres 'percent', mas para um propósito diferente.

Este é um dos principais problemas que o IMv7 corrigirá._
---|---

Comandos do ImageMagick

Embora a maior parte dessas páginas de exemplos do ImageMagick use o comando "magick" para processar imagens, existem vários outros comandos do ImageMagick, que apresentarei brevemente aqui. Alguns desses comandos, no entanto, não podem ser demonstrados adequadamente em uma página web. Mesmo assim, tentarei dar dicas e sugestões envolvendo esses comandos aqui, mesmo que eu não possa realmente mostrar sua saída diretamente.

Convert -- Converter e Modificar Imagens

O comando "magick" é o principal cavalo de batalha do ImageMagick e, como tal, praticamente todo conjunto de exemplos nestas páginas usa este comando. Assim, não cobrirei muito o uso deste comando aqui, mas vou olhar um pouco da história. O propósito original do comando, quando o IM foi criado pela primeira vez, era a conversão de imagens de um formato de imagem para outro. Na verdade, ele ainda é usado para esse propósito, e é por isso que se chama "magick". Por causa disso, o comando pode nem mesmo ler uma imagem para a memória, mas pode usar programas Delegados secundários externos ao IM propriamente dito para fazer a conversão diretamente. Esse aspecto completamente externo, no entanto, caiu em desuso ao longo do tempo, e por falta de necessidade, exceto como um meio de ler e gravar formatos de arquivo de imagem complexos. Ao longo de um longo período de tempo, alguns recursos extras de processamento de imagem foram adicionados para fazer pequenas alterações nas imagens à medida que eram transferidas entre formatos, ou mesmo no mesmo formato. Estas eram geralmente opções simples, mas a partir do IM versão 5, o uso desses recursos de processamento havia se tornado extenso, e um aspecto muito mais importante do comando "magick" do que apenas a conversão de imagem. À medida que as opções se multiplicavam, e múltiplas opções começavam a ser usadas, a ordem das opções começou a produzir resultados estranhos e incontroláveis. Para os usuários, o IM tornou-se conhecido como instável e incontrolável quando múltiplas opções de processamento de imagem eram usadas, e começou a cair em desfavor. O IM versão 6 viu a mudança de um estilo simples de 'opções' para um estilo 'faça conforme você vê' para o processamento de imagem e, como resultado, as capacidades de processamento de imagem tornaram-se estáveis, previsíveis, e as capacidades de linha de comando do IM tornaram-se muitas ordens de magnitude mais úteis. Como resultado disso, o "magick" não trata mais tanto de 'converter' imagens de um formato para outro, mas sim de uma API de linha de comando para acessar funções de processamento de imagem, para criar e modificar imagens de maneiras muito complexas, sem precisar de um diploma em processamento de imagem, ou de programar em uma linguagem de computador (como Perl, PHP ou C). É claro que algum conhecimento de script de shell é útil, embora não estritamente necessário.

identify -- Imprimir os detalhes das imagens que o IM vê

O comando "identify" é projetado para retornar informações sobre uma imagem de maneira simples e útil. Por padrão, ele gera um resumo simples e compacto, detalhando o nome da imagem, o formato de arquivo, o tamanho da imagem, o tamanho e o deslocamento da tela virtual, a profundidade de cor, o tipo de formato interno e, se conhecido, o tamanho original da imagem em disco em termos humanos. Por exemplo...

  magick identify  tree.gif

Observe que o '8c' no resultado acima não é o número de cores dentro desta imagem (que é, na verdade, 6), mas o tamanho da paleta de 'pseudocores' (veja o exemplo posterior para o número real de cores). Observe também que a 'tela virtual' da imagem tem o mesmo tamanho da imagem real, com deslocamento zero, o que significa que ela atualmente não está sendo usada. Adicionar um -verbose, um Controle Operacional, produzirá o máximo de informação sobre a imagem que o IM conhece ou pode calcular facilmente. Isso inclui estatísticas de cor, contagens de cor, informações de perfil, tipo de salvamento interno da imagem, etc. etc.. No entanto, esteja avisado de que a saída é realmente... verbosa! Informações específicas podem ser obtidas e exibidas de maneiras específicas usando a configuração "[-format](https://imagemagick.org/command-line-options/#format)" e os escapes especiais de porcentagem ('%') do IM para exibir Propriedades de Imagem. No entanto, tipicamente você precisa especificar um EOL (nova linha no UNIX ou MacOSX) como parte desse argumento (alterado no IM v6.8.5-8). Por exemplo, você pode apenas extrair uma contagem do número de cores dentro de uma imagem.

  magick identify -format '%k\n' tree.gif

| Antes do IM v6.8.5-8, "[-format](https://imagemagick.org/command-line-options/#format)" adicionava automaticamente um ou mais caracteres de fim de linha à saída, para separar múltiplos resultados de imagem. Isso não é mais feito, então você pode precisar adicionar seus próprios caracteres EOL apropriados à string "[-format](https://imagemagick.org/command-line-options/#format)".
---|---

Identify, Fazer Ping ou Não

O "[magick identify](#identify)" por padrão lê apenas informações básicas mínimas sobre uma imagem, usando uma técnica conhecida como "[-ping](https://imagemagick.org/command-line-options/#ping)". Isso significa que o identify lê apenas o suficiente do arquivo de imagem para determinar informações simples da imagem, como o tamanho, sem tentar ler a imagem inteira para a memória. Veja Ping, Controle Operacional abaixo. Esta é uma grande vantagem que o "[magick identify](#identify)" tem sobre o "[magick](#magick)". No entanto, a maioria dos metadados de imagem não estará disponível. Por exemplo, rótulos de imagem de um arquivo de imagem PNG. Por exemplo, aqui crio uma imagem com um 'label', e tento usar uma configuração de format simples para imprimir esse label.

|

  magick rose: -set label "rose with a label" rose.png
  magick identify -format '"%l"\n' rose.png

No entanto, isso só acontece para casos muito específicos. Qualquer "[-format](https://imagemagick.org/command-line-options/#format)" que tenha escapes mais complexos desativará automaticamente o uso de uma leitura mínima de 'ping'.

  magick identify -format '"%[label]"\n' rose.png

Ou você pode desativar especificamente essa leitura mínima de 'ping' e forçar o identify a ler a imagem 'por completo' para que obtenha a informação desejada.

  magick identify +ping -format '"%l"\n' rose.png

Geralmente, você não precisa se preocupar muito com isso. A menos que esteja lidando com imagens muito grandes, como fotos.

Identify como uma Calculadora de Ponto Flutuante

Você pode fazer alguma matemática de ponto flutuante usando Expressões de Escape FX...

  magick identify -ping -format 'double_width=%[fx:w*2] PI=%[fx:atan(1)*4]\n' tree.gif

Observe que a matemática nem precisa estar relacionada à própria imagem, permitindo que você use o IM como uma simples calculadora de ponto flutuante para uso dentro de seus scripts. Como precisamos apenas de informações básicas, usamos o controle Ping para impedir que o identify leia a imagem inteira. Não tem efeito sobre o resultado neste caso, mas pode acelerar o comando enormemente.

Ressalvas Extras sobre o Identify

Detalhes Específicos de Formato

Normalmente, o IM lê a imagem para a memória (que é essencialmente seu próprio formato de dados interno), usando várias APIs de biblioteca de imagem e programas delegados, antes de exibir os resultados que vê usando o identify. Ou seja, o "magick identify" analisa o conteúdo de imagem/dados que ele leu e armazenou. Ele não analisa como o formato de arquivo específico armazena ou manipula os dados de imagem. Isso é importante, pois pode haver aspectos muito específicos de formatos de arquivo específicos sobre os quais o "magick identify" não relatará. Por exemplo, embora ele liste o conteúdo da tabela de cores de uma imagem GIF para cada imagem presente (múltiplas imagens são possíveis), ele não dirá se todas as imagens no arquivo compartilham a mesma tabela de cores ou não. Se você precisar de informações específicas sobre um formato de arquivo de imagem específico, pode ser melhor usar uma ferramenta projetada especificamente para esse formato. Por exemplo, "giftrans" para o formato de arquivo GIF, e "jpegtrans" para o formato de arquivo JPEG.

Saída de Histograma de Cor

Observe que, se a imagem tiver mais de 1024 cores, nenhum histograma ou tabela de cores será incluído na saída verbosa. Para forçar a geração dessa informação, você pode usar o formato de arquivo especial 'histogram:', que inclui tudo como um grande comentário de imagem.

Status de Saída

O programa identify retorna um status de saída diferente de zero se uma imagem corrompida for encontrada e você adicionar um Controle Regard Warnings.

error=magick identify -regard-warnings image 2>&1 >/dev/null; if [ $? -eq 0 ]; then echo "The image is good" else echo "The image is corrupt or unknown format" echo "$error" fi

Alternativas de Saída do Identify

A partir do IM v6.2.4, você também pode produzir a saída do identify a partir do comando "[convert](#convert)" usando o formato de arquivo de saída especial "[info:](files.html#info)".

  magick ../images/k* \
          -format 'image \"%f\" is of size %G\n'  info:

Você pode usar um Operador Write para gravar em "[info:](files.html#info)" no meio de uma sequência de operações, digamos, como ferramenta de depuração. Você também pode fazê-lo gravar essa saída em um arquivo específico (ou fluxo de arquivo). Um método mais simples seria usar uma opção "[-identify](https://imagemagick.org/command-line-options/#identify)" para gravar na 'saída padrão' normal.

  magick ../images/k* \
          -format 'Image #%p named \"%f\" is a %m\n' -identify \
          null:

Isso também pode ser combinado com outra opção, "[-print](https://imagemagick.org/command-line-options/#print)", para exibir outras informações.

  magick null: -print ' (50 + 25)/5  ==>  %[fx: (50+25)/5 ]\n' null:

A principal diferença entre "[-identify](https://imagemagick.org/command-line-options/#identify)" e "[-print](https://imagemagick.org/command-line-options/#print)" é que o primeiro será executado uma vez para cada imagem na memória, enquanto o último será executado apenas uma vez. Isso significa que podemos gerar praticamente qualquer arquivo de texto que quisermos sobre as imagens na memória, inteiramente a partir de um único comando do ImageMagick. Por exemplo, aqui gero um arquivo HTML do mesmo conjunto de imagens que usei no exemplo anterior...

  magick ../images/k* \
     -print "<HTML><BODY><CENTER>\n" \
     -print "<H1>  Display of %n Thumbnails  </H1>\n" \
     -print "\n" \
     -format "<IMG SRC=\"%i\" ALT=\"%f\" WIDTH=%w HEIGHT=%h>\n" -identify \
     -print "\n" \
     -print "<BR>That's all folks\!\n" \
     -print "\n" \
     -print "</CENTER></BODY></HTML>\n" \
     null:

Você pode ver o resultado da saída acima como uma Página Web HTML mostrando as imagens. Uma palavra final sobre essas opções. Todas elas, por padrão, imprimirão na 'saída padrão' do comando "magick". Você não pode gerar especificamente saída para algum outro 'pipeline' ou para um arquivo específico, a menos que tenha previamente redirecionado a 'saída padrão'. Gravar a saída usando "[info:](files.html#info)" permitirá que você direcione a saída para um arquivo específico, assim como pode para um arquivo de imagem. Você também pode direcionar a saída para um descritor de arquivo previamente preparado, usando o formato de arquivo de saída especial "[fd:](files.html#fd)". É claro que isso grava uma vez por imagem, então pode ser necessário algum malabarismo com as imagens para fazer com que ela gere a saída apenas uma vez.

Mogrify -- processamento em lote no local

O comando "magick mogrify" é, de muitas formas, semelhante ao "magick", exceto que é projetado para modificar imagens no local. Ou seja, seu propósito principal é ler imagens (ou animações), um arquivo de cada vez, e modificá-las, antes de salvar a imagem de volta no exato mesmo nome de arquivo do qual a imagem foi lida. Por causa disso...

O Mogrify é perigoso, pois pode facilmente destruir a imagem original!

Assim, antes de fazer qualquer coisa definitiva, teste o "magick mogrify" com uma cópia separada de suas imagens. Não o use em uma imagem original que não tenha backup. Agora, embora o "magick mogrify" normalmente salve uma imagem modificada no mesmo nome de arquivo, ele tem duas opções especiais que permitem salvar imagens em um arquivo diferente. A configuração específica do "magick mogrify", "[-format](https://imagemagick.org/command-line-options/#format)", define um formato e sufixo diferentes a serem usados ao salvar arquivos. Assim, um comando como...

  magick mogrify    -format jpg   *.png

Permitirá que você converta, ou modifique em lote, imagens, sem destruir a imagem original. Neste caso, convertendo todos os arquivos PNG em arquivos JPEG com o mesmo nome de arquivo, mas um sufixo diferente. No entanto, esteja avisado de que, se houver um arquivo existente com o mesmo nome, ele será sobrescrito. Então, deixe-me reiterar...

Pense e verifique antes de usar o Mogrify

ou você pode descobrir que acabou de sobrescrever algo que queria manter. A partir do IM v6.2.0, você também pode usar uma nova opção "[-path](https://imagemagick.org/command-line-options/#path)" para especificar um diretório diferente no qual gerar as imagens processadas. Isso o torna mais seguro, no entanto, ele ainda sobrescreverá quaisquer imagens de mesmo nome que já possam estar nesse diretório. Além disso, quaisquer imagens antigas que tenham ficado nesse diretório não serão removidas. Assim, você pode fazer o IM salvar os resultados (digamos, miniaturas de imagem) em um subdiretório existente, usando algo assim...

  magick mogrify   -path thumbnail-directory   -thumbnail 100x100  *

| Antes do IM v6.3.4-3, as configurações "[-format](https://imagemagick.org/command-line-options/#format)" e "[-path](https://imagemagick.org/command-line-options/#path)" eram mutuamente exclusivas. A partir dessa versão, você pode alterar formatos e o local do diretório de saída.
---|---
Devido à capacidade de processamento de múltiplas imagens, o comando "magick mogrify" não pode usar nenhum dos Operadores de Lista de Múltiplas Imagens ou Operadores de Pilha de Imagem. Isso significa que você não pode usar operadores de processamento de imagem como "[-fx](https://imagemagick.org/command-line-options/#fx)", "[+swap](https://imagemagick.org/command-line-options/#swap)", "[-composite](https://imagemagick.org/command-line-options/#composite)", "[-append](https://imagemagick.org/command-line-options/#append)", "[-flatten](https://imagemagick.org/command-line-options/#flatten)" e "[-layers](https://imagemagick.org/command-line-options/#layers)" em um comando "magick mogrify". Como algumas opções de configuração precisam ser definidas antes de a primeira imagem ser lida (por exemplo, "[-size](https://imagemagick.org/command-line-options/#size)", "[-label](https://imagemagick.org/command-line-options/#label)" e "[-density](https://imagemagick.org/command-line-options/#density)"), essas opções são processadas e definidas antes de a primeira imagem ser lida. Depois disso, cada imagem é lida e os operadores aplicados a elas na ordem da linha de comando, antes de a imagem ser salva e a próxima imagem lida. É importante ter isso em mente, pois, se você alterar uma dessas configurações mais tarde na sequência, pode fazer o IM esquecer uma configuração anterior. Por exemplo..

  magick mogrify -format gif  -size 200x200  -pointsize 18 \
          -font Candice -gravity north  -annotate 0 "%f" \
          -font Ravie   -gravity Center -annotate 0 "%f" \
          -font Gecko   -gravity south  -annotate 0 "%f" \
          -size 100x64   xc:gold  xc:orange   xc:tomato

Como você pode ver, o tamanho das imagens geradas acima foi determinado pela segunda configuração de entrada "[-size](https://imagemagick.org/command-line-options/#size)", com a primeira configuração maior sendo completamente ignorada. Por outro lado, a configuração de operação "[-font](https://imagemagick.org/command-line-options/#font)" é definida corretamente para cada uma das operações "[-annotate](https://imagemagick.org/command-line-options/#annotate)" individuais. Essa complexidade adicional significa que provavelmente é uma boa ideia...

Fazer Mogrify de imagens de forma simples.

Não tente fazer operações muito longas e complexas, ao estilo do "magick", em uma operação em lote usando o "magick mogrify"; ele provavelmente terá problemas de 'configuração'. Se você realmente quiser fazer um processamento complexo, escreva um script de shell/dos/perl para usar o "magick" para processar cada imagem uma de cada vez, ou recorra a uma interface de API do ImageMagick. Para exemplos de modificação de muitas imagens usando um script, veja Exemplos Avançados do ImageMagick. Apenas lembre-se, "magick mogrify" é um comando perigoso e deve sempre ser exaustivamente testado em imagens de backup, antes de ser colocado em produção. Na verdade, também recomendo que os scripts incluam 'testes' rápidos em coisas como o "magick mogrify", para garantir que o comando não quebre nada (devido a mudanças de versão ou diferenças nas instalações dos computadores) antes de processar uma coleção muito grande de imagens. Ou seja, faça um pequeno 'caso de teste' e aborte se ele não produzir um resultado correto, antes de prosseguir. Isso é, na verdade, uma boa ideia para qualquer projeto de processamento de imagem em grande escala, de modo a proteger os usuários de consequências imprevistas. Eu mesmo faço isso nos Exemplos do IM, e isso me poupou muitos problemas.

Composição Alfa usando "magick mogrify"

Como o "magick mogrify" não pode usar Operadores de Lista de Múltiplas Imagens, ele não pode facilmente sobrepor coisas como logotipos, ou mascarar imagens usando Composição Alfa. Há uma exceção a isso, usando "[-draw](https://imagemagick.org/command-line-options/#draw)" para realizar a composição alfa de imagem. Isso permite que você especifique a segunda imagem, como parte dos argumentos do operador, fora da lista de imagens atual. Por exemplo, aqui primeiro faço uma cópia das imagens originais que quero processar usando um script especial "[cp_perl](http://www.ict.griffith.edu.au/anthony/software/#mv_perl)". Em seguida, crio uma imagem de 'máscara' circular temporária, que então uso para recortar uma forma de círculo de todas essas imagens, usando o "magick mogrify" com um método de composição alfa '[Dst_In](compose.html#dstin)'.

  cp_perl  's/^/mogrify_/'  eye.gif news.gif storm.gif tree.gif
  magick -size 32x32 xc:none -draw 'circle 15.5,15.5 15.5,0'  circle.gif
  magick mogrify  -alpha Set -draw 'image Dst_In 0,0 0,0 "circle.gif"'  mogrify_*.gif

Observe que qualquer método de Composição Alfa pode ser usado dessa forma, mas apenas com uma imagem 'fonte' ou 'sobreposição' constante sendo aplicada a todas as imagens. Além disso, como o "magick mogrify" estará lendo a imagem 'fonte' várias vezes, sugiro que você use o formato de arquivo específico do IM "MPC:" para reduzir a sobrecarga de decodificar a imagem ao lê-la repetidamente. Esse formato de arquivo de imagem não precisa ser analisado pelo IM, pois será mapeado diretamente do disco para a memória (para a mesma máquina em que foi criado). Isso economiza muito tempo de processamento, especialmente ao lidar com um grande número de imagens.

Usando o Convert em vez do Mogrify

Usando uma técnica especial para modificar o nome do arquivo de saída usando Escapes de Porcentagem, (veja Escapes de Porcentagem de Nome de Arquivo), você pode substituir o "[mogrify](#mogrify)" por um comando "[convert](#convert)" mais versátil. Não apenas isso, mas ele lhe fornecerá mais controle sobre o nome de destino final da imagem e permitirá que você lide melhor com o processamento de múltiplas imagens, como composições e animações. Por exemplo, aqui crio miniaturas de imagens no diretório atual, inserindo uma string "_tn" no nome do arquivo de entrada, para criar o nome do arquivo de imagem de saída apropriado.

  magick *.jpg   -thumbnail 120x90 \
          -set filename:fname '%t_tn' +adjoin '%[filename:fname].gif'

Aviso: não inclua um sufixo de arquivo diferente na própria configuração de nome de arquivo. O IM não o verá ao decidir o formato de arquivo de imagem a ser usado. Observe que, se o IM não conseguir decidir a partir do nome do arquivo, ele recorrerá ao formato de arquivo original que foi lido, então um sufixo claro, ou um prefixo de codificador, pode ser importante ao usar essa técnica. Para obter o nome de arquivo original exato de onde a imagem fonte veio, use "%i", "%d/%f" ou "%d/%t.%e". É claro que todos estes têm o sufixo de nome de arquivo na configuração de nome de arquivo, que o IM não usa, mas isso deve estar OK, pois é o mesmo formato de arquivo de imagem. O verdadeiro problema de usar o "[convert](#convert)" em vez do "[mogrify](#mogrify)" é que TODAS as imagens são lidas para a memória primeiro! O Mogrify se esforça muito para ler/modificar/gravar apenas um arquivo (embora esse arquivo possa conter múltiplas imagens) de cada vez. Mas o "[convert](#convert)" não. Assim, você pode facilmente exceder os limites de memória se não tiver cuidado. Embora existam maneiras de contornar isso. Veja exemplos em Modificadores de Leitura e Miniaturas. Além disso, como todas as imagens estão na memória como uma única lista de imagens, você precisará ter cuidado com a forma como processa essas imagens. Por exemplo, você não pode usar diretamente a Composição Alfa como faria normalmente, mas pode precisar usar a Composição de Lista de Múltiplas Imagens especializada para fazer o trabalho. É claro que, assim como com o "magick mogrify", esse método de usar o "magick" pode ser perigoso, pois poderia facilmente sobrescrever e destruir os arquivos de imagem originais.

Alternativas de Processamento em Lote

Se o processamento em lote de imagens usando o "magick mogrify" não for prático, especialmente se você estiver copiando as imagens em vez de modificá-las no local, então pode ser melhor usar algumas outras soluções de laço não relacionadas ao IM. Estas incluem...

  # Use a simple shell loop, to process each of the images.
  mkdir thumbnails
  for f in *.jpg
  do   magick $f -thumbnail 200x90 thumbnails/$f.gif
  done

  # Use find to substitute filenames into a 'convert' command.
  # This also provides the ability to recurse though directories by removing
  # the -prune option, as well as doing other file checks (like image type,
  # or the disk space used by an image).
  find * -prune -name '*.jpg' \
         -exec  magick '{}' -thumbnail 200x90 thumbnails/'{}'.gif \;

  # Use xargs -- with a shell wrapper to put the argument into a variable
  # This can be combined with either "find" or "ls" to list filenames.
  ls *.jpg | xargs -n1 sh -c 'magick $0 -thumbnail 200x90 thumbnails/$0.gif'

  # An alternative method on linux (rather than plain unix)
  # This does not need a shell to handle the argument.
  ls *.jpg | xargs -r -I FILE   magick FILE -thumbnail 200x90 FILE_thumb.gif

Composite -- sobrepor imagens de maneiras especiais

O comando "magick composite" é projetado especificamente para a composição alfa simples (sobreposição) de duas imagens juntas de várias maneiras. Isso inclui limitar a área em que as imagens são combinadas, por meio do uso de uma terceira imagem de máscara. Ao contrário do "magick", o comando "magick composite" é um comando muito tradicional, pois lerá todas as suas opções e configurações antes de realmente realizar a única operação de processamento de imagem para a qual foi projetado. O comando "magick composite" também fornece acesso simples a alguns dos modos de composição alfa mais complexos. Por exemplo, as composições de imagem "[-dissolve](https://imagemagick.org/command-line-options/#dissolve)", "[-blend](https://imagemagick.org/command-line-options/#blend)" e "[-watermark](https://imagemagick.org/command-line-options/#watermark)". Se qualquer um desses argumentos for fornecido, ele substituirá qualquer outra configuração "[-compose](https://imagemagick.org/command-line-options/#compose)" que tenha sido (ou venha a ser) fornecida para esse comando. Observe também que a configuração "[-tile](https://imagemagick.org/command-line-options/#tile)" também funciona de forma diferente da do "magick" ou do "magick montage" e "magick display". No "magick composite", isso fará com que a imagem sobreposta seja ladrilhada por todo o fundo da imagem de fundo. Algo ainda não disponível em outros comandos do IM. Embora esses recursos especiais tornem o "magick composite" um comando útil, a composição alfa agora também está disponível para uso no comando "magick". (Para detalhes, veja Composição Alfa no IM). Para um resumo de várias maneiras diferentes de sobrepor duas ou mais imagens juntas, veja os exemplos em Composição de Múltiplos Pares de Imagens. Para mais informações sobre o método pelo qual duas imagens podem ser mescladas, veja a página de exemplos de Composição Alfa. As capacidades de limitação de sobreposição ou 'Mascaramento' também são detalhadas na página de exemplos acima em Usando uma Máscara de Composição para Limitar a Área Composta.

Montage -- gerar arranjos de miniaturas

O comando especial de indexação de imagens do IM, "magick montage", também seguiu o mesmo estilo de estrutura de linha de comando 'faça conforme você vê' do "magick". A única diferença é que, quando o fim do comando é alcançado (exceto pelo argumento final de nome de arquivo de imagem de saída), o "magick montage" começará a processar a lista de imagens em uma ou mais páginas de índice de miniaturas, de acordo com as configurações atualmente definidas. Isso torna o "magick montage" muito mais versátil do que era no IM versão 5, pois agora você pode processar as imagens exatamente como faria no "magick", depois definir todas as configurações do "magick montage" que quiser, e deixá-lo terminar o trabalho. Para mais detalhes sobre o "magick montage", veja Montage, Arranjos de Miniaturas.

display -- Apresentações de Slides de Imagens

O programa "magick display" é projetado para exibir uma imagem, ou lista de imagens, na forma de uma apresentação de slides em laço. Ele não é projetado para uma animação de imagens cuidadosamente orquestrada e temporizada; para isso, use o comando "[animate](#animate)". Cada imagem será exibida em uma janela dimensionada apropriadamente para a imagem, a menos que outras opções (como o "[-geometry](https://imagemagick.org/command-line-options/#geometry)" da janela, veja abaixo) substituam esse comportamento. A imagem também geralmente será exibida sobre um fundo quadriculado, de modo a mostrar os efeitos de qualquer transparência que a imagem possa ter (veja abaixo). Lembre-se de que isso NÃO é projetado para a exibição de uma animação, mas como uma apresentação de slides de imagens reais. Assim, algum cuidado pode ser necessário ao usar o display em um programa de script. Tempo de Exibição da Imagem, Laço e outras opções Por padrão, um atraso de aproximadamente 2 segundos é usado, somado a qualquer atraso que o usuário especifique usando a configuração "[-delay](https://imagemagick.org/command-line-options/#delay)". No entanto, você pode fazê-lo esperar pela entrada do usuário (barra de espaço) usando a opção "-delay 0". No entanto, os padrões podem ser substituídos pelas próprias imagens, dependendo do formato de arquivo delas. Assim, formatos de animação como GIF e MIFF podem resultar em uma pausa, ou em 2 segundos mais a configuração de atraso dos metadados da imagem. Recomenda-se, portanto, que você sempre defina um "[-delay](https://imagemagick.org/command-line-options/#delay)" conforme apropriado (lembre-se de que "-delay 5x1" atrasará 5+2 ou cerca de 7 segundos) para o seu script e necessidades. O mesmo vale para a configuração "[-loop](https://imagemagick.org/command-line-options/#loop)". Por padrão, o "magick display" faz laço infinito ("-loop 0"), mas formatos de imagem como MIFF ou GIF podem substituir isso, de modo a fazê-lo sair após a última imagem do laço. Veja a opção "[-loop](https://imagemagick.org/command-line-options/#loop)" apropriadamente para sua situação. Observe que o "magick display" não tratará nenhuma Configuração de Animação GIF, então os quadros não são descartados, e os tamanhos e deslocamentos da tela virtual são ignorados. Em outras palavras, você verá as imagens parciais brutas em uma animação GIF, não a imagem corretamente sobreposta. Ele fornece uma opção "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" para limpar tais animações para fins de exibição.

Tratamento de Transparência

Imagens contendo um canal alfa completo (por exemplo, formatos PNG e MIFF) serão sobrepostas sobre um padrão de fundo 'quadriculado', de modo a permitir que você veja os efeitos de qualquer semitransparência, como efeitos de sombra. Você pode alterar isso selecionando um fundo diferente com "[-texture](https://imagemagick.org/command-line-options/#texture)", como...

  magick display -texture granite: test.png

  magick display -texture xc:black test.png

Imagens com transparência de paleta (ou booleana), como os formatos GIF e PNG8, são exibidas com a 'cor de transparência' atual que foi usada para representar a transparência na tabela de cores. Ou seja, uma cor geralmente aleatória pode ser usada (tipicamente preto) em vez do padrão quadriculado padrão. Isso poderia ser considerado um bug, embora tecnicamente não seja. No entanto, se você quiser que o display trate tais imagens da mesma forma que outras imagens contendo informações de transparência, você pode remover os metadados de paleta antes de alimentar a imagem ao "magick display" usando os seguintes comandos para alterar o estilo interno do formato de saída da imagem.

  magick image.gif -type truecolormatte miff:- | display -

Alternativamente, praticamente qualquer operação que modifique a imagem sendo exibida também removerá os metadados de paleta existentes. Assim, algumas opções do "magick display" podem ser usadas para remover a paleta. Por exemplo, usando "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)".

  magick display -coalesce image.gif

Isso tem o bônus adicional de limpar as otimizações de animação GIF que possam estar presentes. Embora, para múltiplas imagens não relacionadas, possa ter outros efeitos colaterais indesejáveis. Sim, esses métodos são desajeitados, mas funcionam.

Display Usando o Convert

Um método de exibição alternativo (que não seja usar "magick animate", veja a seguir) é usar o formato de imagem de saída "x:" mais simples (Veja formato de saída display).

  magick image.png x:

Esse método não fornece uma janela de fundo, opções de menu ou outros controles. Ele simplesmente exibe as imagens, uma imagem de cada vez. Se você quiser apenas simplesmente 'exibir' a imagem resultante, o Delegado de Spawn de saída especial 'show:' ou 'win:' fará a mesma coisa, executando o comando "[display](#display)" na imagem de saída e saindo sem esperar que essa janela seja fechada.

  magick image.png show:

Tamanho de Saída do Display

O display não escalará uma imagem para ajustá-la à exibição da janela X. O tamanho da janela será ajustado para caber em cada imagem, a menos que definido usando a configuração "[-geometry](https://imagemagick.org/command-line-options/#geometry)". Essa configuração também pode ser usada para fixar a posição da janela na exibição da janela X. Imagens maiores que a tela também não serão redimensionadas, mas transbordarão a tela; o display, no entanto, também fornecerá uma 'janela de rolagem' para permitir que o usuário deslize pela imagem. Isso pode ser doloroso ao visualizar uma foto digital moderna de alta resolução. Para limitar o display, digamos, a uma área de 800x600 pixels (apenas reduzir, nunca ampliar), use...

  magick display -resize 800x600\> photo.jpg

Para imagens JPG, você pode acelerar a leitura da imagem usando uma configuração especial de dica de tamanho de entrada jpeg. Veja Opções de Controle de Leitura de JPEG.

  magick display -define jpeg:size=1600x1200 -thumbnail 800x600\> photo.jpg

Se a imagem for de uma câmera digital moderna, você também pode usar "[-auto-orient](https://imagemagick.org/command-line-options/#auto-orient)" para corrigir a rotação da câmera da imagem exibida, usando os metadados EXIF no formato de arquivo de imagem. Se você não quiser menus, pode desativá-los usando a configuração "[-immutable](https://imagemagick.org/command-line-options/#immutable)" no "magick display", para que ele saiba que não deve permitir edição.

Uso do Display em Scripts

Com essas opções em mente, a seguir está minha recomendação para usar o "magick display" para exibir resultados de um script de shell complexo...

  magick display -delay 0 -loop 1 -coalesce -resize 800x600\>   some_random_image

Display com X Windows

A opção "[-window](https://imagemagick.org/command-line-options/#window) root" pode ser usada para exibir uma imagem na janela de fundo (root) do X window. Nesse caso, o programa "magick display" sai automaticamente. Por padrão, uma imagem é ladrilhada pelo fundo. Por exemplo, tente isto..

  magick display -window root pattern:checkerboard

Para muitos outros exemplos de ladrilhos de imagem, e para gerá-los, veja Telas Ladrilhadas e Exemplos de Imagens de Fundo. Se você quiser usar uma única imagem para o fundo do seu X Windows, pode precisar saber o tamanho da exibição da sua janela X. O programa "xdpyinfo", embora não faça parte do ImageMagick, pode lhe dar essa informação.

  xdpyinfo | grep dimensions:

E aqui usamos a saída de "xdpyinfo" para redimensionar uma imagem de modo a preencher completamente o fundo da janela X.

  screen_size=`xdpyinfo | sed '/dimensions:/!d;s/^[^0-9]*//;s/ pixels.*//'`
  magick display  -resize $screen_size! -window root photo.jpg

Controle Remoto do Display

O display fornece uma opção especial "[-remote](https://imagemagick.org/command-line-options/#remote)". Ela procurará um comando "magick display" já em execução e então passará os argumentos fornecidos a ele. Por exemplo...

  magick display wizard: &
  sleep 5
  magick display -remote logo: &

Exibirá a imagem "wizard" embutida em um comando em segundo plano. O script então esperará 5 segundos antes de substituí-la pela imagem "logo" embutida. Observe que, se nenhum comando "magick display" estiver em execução, o comando atual abrirá uma janela e não sairá. Assim, você também deve colocar os comandos "display -remote" em segundo plano, como precaução. No momento, você não pode solicitar que um "magick display" remoto saia. Assim, a melhor maneira de fechar o display remoto é matar o processo em execução, ou 'excluir' a janela do display usando algum comando do X window. Por exemplo (usando o comando não relacionado ao IM "xdotool")...

  xdotool search -class "display" windowkill

animate -- Mostrar uma animação de imagens

De muitas formas, o "magick animate" e o "[display](#display)" são extremamente semelhantes. No entanto, o "[display](#display)" mostra apenas as imagens no arquivo de imagem fornecido 'como estão', sem alterações, adicionando uma pausa mínima de 2 segundos entre cada quadro para a entrada do usuário. O "magick animate", por outro lado, aplicará quaisquer Configurações de Animação GIF que estejam salvas com a imagem, e exibirá cada imagem apenas de acordo com suas configurações de 'atraso de tempo', voltando ao início para repetir a animação. Em outras palavras, o "magick animate" 'anima' formatos de animação adequadamente, enquanto o "[display](#display)" não. No entanto, por causa disso, a tela virtual da primeira imagem controlará o tamanho da imagem de saída, e as outras imagens serão sobrepostas nessa área de imagem. É claro que, como as imagens são animadas, você tem um controle fino sobre o tempo de exibição da imagem, usando opções como "[-delay](https://imagemagick.org/command-line-options/#delay)". O comando também tem um argumento extra "[-pause](https://imagemagick.org/command-line-options/#pause)" para adicionar uma pausa extra no final do laço de animação, além do que a configuração "[-delay](https://imagemagick.org/command-line-options/#delay)" do quadro final especificar. Por exemplo, você pode usar o "magick animate" para gerar uma Comparação por Cintilação de duas imagens muito semelhantes, usando algo como..

  magick image1.png image2.png -scale 400% miff:- |\
     magick animate -delay 50 -loop 0 -

Escrevi um script para tirar proveito desse método, chamado "[flicker_cmp](../static/img/scripts/flicker_cmp)", e o acho extremamente útil para captar mudanças muito sutis na intensidade de pixel que, de outra forma, eu não perceberia.

compare -- Procurar por Diferenças

Todas as informações atuais sobre isso estão na seção Página de Comparação de Imagens dos Exemplos do IM.

stream -- processamento em pipeline de imagens enormes

O "magick stream" é um programa especial projetado para lidar com a extração de uma parte de um arquivo de imagem muito grande. É o único programa desse tipo dentro do ImageMagick; todos os outros leem as imagens completamente para a memória antes de processá-las (a exceção são as imagens JPEG via "[-size](https://imagemagick.org/command-line-options/#size)", pois essa opção é passada para a biblioteca delegada JPEG). Você pode selecionar uma parte da imagem com a configuração "[-extract](https://imagemagick.org/command-line-options/#extract)". E você pode especificar a profundidade dos bytes brutos com a configuração "[-depth](https://imagemagick.org/command-line-options/#depth)". E, finalmente, você pode selecionar quais canais de cor extrair usando a opção "[-channel](https://imagemagick.org/command-line-options/#channel)". No entanto, o "magick stream" só gerará os bytes de cor brutos da imagem (formato RAW) conforme definido pela profundidade da imagem, então você pode precisar canalizar a saída do segmento extraído para o convert. Por exemplo... |

  magick stream -map rgb -storage-type char -extract 100x100+200+100 logo: - |\
    magick -depth 8 -size 100x100 rgb:-   magick stream_wand.gif

Para mais informações e exemplos, veja Manipulação de Imagens Realmente Enormes.

import -- ler imagens da exibição na tela

O comando "magick import" é um programa especial que pode ser usado para capturar e extrair imagens de uma exibição do X windows. Por exemplo, vamos fazê-lo capturar e imprimir uma janela que você selecione da sua exibição...

  magick import -page A4 -gravity center ps:- | lpr

Na verdade, ele é raramente usado, pois o formato de arquivo especial "[X:](files.html#x)" também fornece exatamente a mesma funcionalidade de dentro do comando magick. A única diferença entre os dois é que o "magick import" tem mais configurações específicas do X window do que o formato "[X:](files.html#x)", como especificar a exibição, a tela e/ou o ID da janela de onde a imagem deve ser capturada. Outras opções incluem o controle do 'bipe' da exibição e capturas repetidas. Se nenhuma janela específica for especificada, o mouse pode ser usado para selecionar quais partes da exibição o usuário deseja capturar como uma imagem.

• Se um único clique do mouse for usado, toda a janela em que se clicou é capturada e retornada como uma imagem. Observe que, se quaisquer outras janelas na exibição estiverem obscurecendo parte da janela selecionada, então você capturará uma imagem em que as outras janelas obscurecedoras estão obscurecendo a janela selecionada sendo capturada.
• Um clique na janela root, ou selecionar "-window root", retornará a tela inteira.
• Se um clique e arraste do mouse for usado, uma seção Recortada de toda a tela é retornada, o que, é claro, também significa que a localização (deslocamento da tela virtual) em toda a exibição (tela virtual, ou página, tamanho) também é retornada.

Outras opções permitem que você evite a interação humana com o mouse, capturando a tela inteira ("-window root"), ou uma janela específica, dado um título de janela, ou um ID de janela X, que você pode encontrar usando o utilitário do X window "xwininfo". Você também pode reduzir a área da janela selecionada usando "[-extract](https://imagemagick.org/command-line-options/#extract)". Veja também o formato de entrada especial, "[X:](files.html#x)", como alternativa ao uso do "magick import".

    Note to import from the Windows clipboard use
      magick clipboard:myimage image.png
    and not "import"

conjure -- linguagem de script experimental do IM

Foi originalmente projetada para permitir o uso programado do ImageMagick, com o uso de múltiplas listas de imagens, mas as melhorias feitas no "magick" do IM v6 fizeram com que essa API experimental caísse em desuso. É uma linguagem baseada em XML. Embora, se você quiser XML, o SVG possa ser melhor para suas necessidades. Na minha opinião, usar o script "magick conjure" é provavelmente melhor e mais fácil ao lidar com listas de múltiplas imagens. E está sendo usado, embora não muito amplamente, devido à falta de exemplos e suporte por parte dos usuários.

Listas de Imagens...

Um dos pontos mais importantes a lembrar com o ImageMagick, e que confunde tanto novos usuários quanto usuários experientes, é que...

O ImageMagick trabalha com Listas Ordenadas de Imagens, não com imagens individuais

Ou seja, o IM lida não apenas com uma imagem, mas potencialmente com uma lista ordenada de imagens, sejam elas imagens individuais separadas, um conjunto de imagens que se sobrepõem umas às outras, ou os quadros de uma animação. Além disso, em geral, todos os operadores de imagem serão aplicados a todas as imagens na lista atual. Assim, se você usar um operador "[-draw](https://imagemagick.org/command-line-options/#draw)", ele não desenhará apenas na última imagem da lista, como muitos novos usuários assumiriam, mas desenhará em todas as outras imagens na lista de imagens atual, e o faz para cada imagem, por vez. Operadores de Camada de Imagem, como "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" e "[-layers](https://imagemagick.org/command-line-options/#layers)", substituirão cada imagem na lista por uma nova imagem modificada de acordo com as outras imagens na lista. Eles podem até adicionar ou remover imagens extras! Além disso, Operadores de Lista de Imagem, como "[-append](https://imagemagick.org/command-line-options/#append)", "[-mosaic](https://imagemagick.org/command-line-options/#mosaic)" e "[-fx](https://imagemagick.org/command-line-options/#fx)", substituirão TODAS as imagens na lista de imagens atual pela imagem combinada resultante. Ou seja, isso destruirá todas as imagens, a menos que elas tenham sido previamente salvas usando Parênteses, e Imagens Clonadas tenham sido usadas. Veja Operadores de Lista de Imagem abaixo para exemplos práticos. Por fim, quando uma nova imagem é lida ou criada, o IM apenas adiciona essa nova imagem ao final da lista de imagens atual (que sempre existe). Alguns formatos (como o GIF) podem, na verdade, adicionar múltiplas imagens à lista de imagens atual, a menos que um Modificador de Leitura de Indexação especial seja adicionado ao nome do arquivo de entrada, para limitar o que é lido. Ao salvar imagens, o IM salvará toda a lista de imagens que está na memória no momento da escrita. Se o formato de imagem permitir, o IM gravará TODAS as imagens em um único arquivo. Se o formato NÃO permitir múltiplas imagens (por exemplo, JPEG), ele gravará as imagens em arquivos separados (Veja Gravando Múltiplas Imagens).

Parênteses -- processar imagens 'paralelamente'

Com a formalização das opções de linha de comando, a ordem de processamento agora é exatamente previsível, e também se tornou possível adicionar parênteses (ou colchetes) ao processamento de imagem. Esse tem sido um recurso desejado pelos usuários do IM por muito tempo, e permite que você faça coisas nunca antes possíveis em um único comando. O colchete de abertura '(' iniciará, na prática, uma nova lista de imagens, na qual todos os operadores incluídos trabalharão. O colchete de fechamento correspondente ')' então adicionará a lista de imagens resultante (que pode ser mais de uma imagem, ou nenhuma) ao final da lista de imagens anterior. Em outras palavras, usar parênteses significa...

"Preciso fazer um pouco de trabalho em uma lista de imagens separada
antes de adicionar os resultados ao final da lista anterior."

Isso permite que você trabalhe em um subconjunto de imagens, como um bloco de rascunho, e então adicione o resultado de volta à lista de imagens principal sem afetar as imagens que você já leu previamente ou nas quais esteve trabalhando. Vamos ver alguns exemplos simples... |

  magick  eye.gif  storm.gif  -negate  +append  cmd_negate.gif

Como você pode ver, o operador "[-negate](https://imagemagick.org/command-line-options/#negate)" negou em cor ambas as imagens, pois ambas estavam na lista de imagens atual na memória naquele momento. Mas, ao adicionar parênteses, podemos limitar a negação apenas à segunda imagem... |

  magick  eye.gif \(  storm.gif  -negate \) +append  cmd_bracket.gif

Como a imagem "storm.gif" é lida em uma lista de imagens separada da primeira imagem (gerada pelo operador de lista de imagens "("), ela pode ser negada sem afetar a primeira imagem. Então podemos adicionar o resultado à lista de imagens principal (esse é o operador ")"), antes de anexar as duas imagens juntas como antes. | _Os parênteses devem ser fornecidos como um argumento separado. Ou seja, você deve separá-los dos outros argumentos por espaços. Você não pode adicioná-los colados aos argumentos vizinhos. Em outras palavras, no argumento de linha de comando do IM "\(+clone " está errado, enquanto " \( +clone " está correto.

Além disso, no último exemplo precisei colocar uma barra invertida '\' antes dos parênteses. Isso porque, ao usar o IM em uma máquina UNIX (linux), os parênteses têm significado especial para o shell da linha de comando. Assim, preciso escapar, ou colocar entre aspas, os símbolos de colchete, quando os uso.

Scripts DOS do Windows não exigem que os parênteses sejam escapados com barra invertida. Veja Scripts DOS do Windows para esta e outras diferenças em relação aos scripts do linux.

_
---|---
Os parênteses também tornam possível fazer algo não previamente possível em um único comando "magick". Gerar arranjos de imagens! |

  magick eye.gif news.gif  +append \
         \( storm.gif tree.gif +append \)   -append  cmd_array.gif

Arranjos como este eram, é claro, possíveis usando o "magick montage" (veja Modo de Concatenação do Montage), mas usar um comando separado torna os scripts de processamento de imagem mais complexos. É claro que, se você quiser fazer o comando parecer mais com um arranjo em si, está livre para adicionar alguns parênteses extras. |

  magick \( eye.gif    news.gif  +append \) \
          \( storm.gif  tree.gif  +append \) \
          -append  cmd_array2.gif

O primeiro conjunto de parênteses não é estritamente necessário, e adiciona uma pequena quantidade de trabalho extra ao processamento interno do IM, mas deixa claro o que o comando está fazendo, separando as etapas de processamento. Também pode ser mais fácil para os scripts de processamento de imagem realizar cada etapa de processamento como um parêntese separado, como meio de separar as etapas de processamento que ele aplica.

Parênteses e Configurações

As 'configurações' de opção não são afetadas pelos parênteses, e continuarão através dos operadores de imagem entre parênteses, até que a configuração seja alterada ou desligada. Por exemplo... |

  magick -pointsize 24 \
          -font Candice label:Outside \
          \(              label:Inside \
             -font Gecko  label:Inside \) \
          label:Outside       -append   cmd_settings.gif

Observe como a primeira configuração "-font Candice" NÃO é redefinida de volta para sua configuração padrão quando os parênteses são abertos, enquanto a segunda "-font Gecko" não é substituída pela configuração de fonte original quando você sai dos parênteses. Em outras palavras...

Os parênteses criam apenas uma Sequência de Imagens separada.
Eles não limitam as configurações, apenas as imagens sendo trabalhadas.

A partir do IM v6.4.1-4, a nova opção de controle operacional "[-respect-parentheses](https://imagemagick.org/command-line-options/#respect_parenthesis)" pode substituir esse comportamento. Quando fornecida no início de um comando do IM, ela fará com que os parênteses também salvem e recuperem as configurações anteriores que foram fornecidas. Isso significa que quaisquer configurações fornecidas dentro dos parênteses só permanecerão definidas até o fim dos parênteses. Por exemplo... |

  magick -respect-parentheses   -pointsize 24 \
          -font Candice label:Outside \
          \(              label:Inside \
             -font Gecko  label:Inside \) \
          label:Outside       -append   cmd_settings2.gif

Como você pode ver, quando os parênteses terminaram, a configuração de fonte foi restaurada para a fonte 'Candice' anterior, em vez da fonte 'Gecko' que foi definida dentro dos parênteses. Isso pode ser muito útil quando você precisa alterar muitas configurações, por apenas um curto período...

  magick -respect-parentheses \
          -font Arial   label:"This is a line of plain text." \
          \( -font Candice -pointsize 16 -fill red -undercolor lightblue \
              label:"A line using a lot of different settings." \) \
          label:"Text is back to normal -- like Magick\!" \
          -append  cmd_settings_lots.gif

Operadores de Lista de Imagem

Com a maior ênfase do IM nas sequências de imagens, especialmente dentro de parênteses, não é surpresa que um conjunto de novos operadores de imagem tenha sido fornecido para manipular as listas de imagens.

Os argumentos para esses operadores são números que indexam a lista de imagens, começando com zero ('0') para a primeira imagem, e um ('1') para a segunda imagem, e assim por diante. No entanto, se você fornecer um índice negativo, as imagens são referenciadas a partir do final (última imagem adicionada) da lista de imagens. Ou seja, um índice de '-1' é a última imagem na lista de imagens atual (geralmente a última imagem lida ou criada), '-2' para a penúltima, e assim por diante.

-delete {index_range_list}

O operador de lista "[-delete](https://imagemagick.org/command-line-options/#delete)" é o mais simples dos operadores de lista de imagem; ele apenas exclui imagens da lista de imagens atual. |

  magick font_[0-3].gif -delete 1 +append  seq_delete.gif

A forma 'mais' do operador, "[+delete](https://imagemagick.org/command-line-options/#delete)", não recebe argumento, e apenas exclui a última imagem na lista de imagens atual. O operador "[-delete](https://imagemagick.org/command-line-options/#delete)" também aceitará uma lista de números separados por vírgula, ou um intervalo de números a serem excluídos. |

  magick font_[0-7].gif -delete 1-4,6 +append  seq_delete2.gif

Ou excluir tudo (e adicionar uma nova imagem)... |

  magick font_[0-7].gif -delete 0--1  tree.gif seq_delete3.gif

O argumento '0--1' significa excluir imagens da primeira imagem (índice 0) até a última imagem (índice -1). Em outras palavras, TODAS as imagens na lista de imagens atual. A imagem tree foi então adicionada para dar ao IM um resultado real, de modo a evitar um erro do tipo 'no image'. Uma imagem de saída "[NULL:](files.html#null)" também poderia ter sido usada, para não produzir saída. Se um índice de imagem não existir, ou um intervalo de números estiver invertido, o "[-delete](https://imagemagick.org/command-line-options/#delete)" ignorará silenciosamente aquela exclusão de imagem específica. Por exemplo, o argumento '-25' tentará excluir a 25ª última imagem na lista de imagens, mas não fará nada silenciosamente se menos de 25 imagens estiverem presentes. Assim, você pode gerar uma animação rolante de 24 imagens usando uma sequência como...

  magick animation.gif  new_frame.gif  -delete -25  animation_new.gif

No entanto, nenhuma imagem será excluída se o número de imagens for 24 ou menos. Como resultado, a animação crescerá em um quadro toda vez que o comando for executado, até que um máximo de 24 quadros seja atingido. Depois disso, o quadro mais antigo (primeiro) será excluído enquanto um novo quadro é adicionado. A partir do IM v6.3.4, o "[-delete](https://imagemagick.org/command-line-options/#delete)" não excluirá imagens que resultem na inversão do intervalo numerado. Isso significa que o último exemplo poderia ser reescrito assim...

  magick long_animation.gif  new_frame.gif  -delete 0--25  animation_new.gif

Desta vez, o "[-delete](https://imagemagick.org/command-line-options/#delete)" excluirá todas as imagens entre a primeira e a 25ª última imagem, deixando no máximo 24 imagens na lista. Se apenas 24 ou menos imagens estiverem presentes, o intervalo de imagens fornecido a ser excluído será efetivamente invertido, e o operador "[-delete](https://imagemagick.org/command-line-options/#delete)" não excluirá nada.

-insert {index}

A operação "[-insert](https://imagemagick.org/command-line-options/#insert)" é, de certa forma, o oposto de "[-delete](https://imagemagick.org/command-line-options/#delete)". Ela pegará a última imagem na lista de imagens atual e a inserirá de modo que fique posicionada no índice fornecido. |

  magick font_[0-3].gif tree.gif -insert 1 +append seq_insert.gif

Você pode pensar no índice de inserção como o número de imagens que devem aparecer antes do ponto onde a imagem foi inserida. É claro que a imagem que estava naquele índice (e todas as imagens depois dela) será empurrada para a próxima posição de índice para abrir espaço para a nova imagem. Se uma posição de índice negativa for usada, a posição de inserção é calculada após a imagem sendo inserida ser removida do final da lista. Ou seja, ela agirá como se a imagem sendo inserida não fizesse parte da lista de imagens original. Assim, "-insert -2" 'rolará' as últimas três imagens, colocando duas imagens entre a imagem recém-inserida e o final da lista de imagens. |

  magick font_[0-3].gif tree.gif -insert -2 +append seq_insert2.gif

A forma com mais "[+insert](https://imagemagick.org/command-line-options/#insert)" moverá a última imagem para a frente da lista de imagens (índice 0), efetivamente rolando toda a lista de imagens em um quadro. |

  magick font_[0-3].gif tree.gif +insert +append seq_insert3.gif

Para fazer o inverso do acima (mover uma imagem para o final da lista de imagens), pode-se primeiro usar "[-duplicate](https://imagemagick.org/command-line-options/#duplicate) 1,0" para copiar a primeira imagem, depois usar "[-delete](https://imagemagick.org/command-line-options/#delete) 0" para excluir a primeira imagem.

-swap {index}[,{index}]

Simplificando, "[-swap](https://imagemagick.org/command-line-options/#swap)" trocará as posições de duas imagens na lista de imagens atual. Por exemplo, "-swap 0,2" trocará a primeira e a terceira imagens na lista de imagens atual. |

  magick font_[0-3].gif  -swap 0,2  +append  seq_swap.gif

A forma com mais desta opção, "[+swap](https://imagemagick.org/command-line-options/#swap)", trocará as duas últimas imagens na lista de imagens atual. Em outras palavras, é equivalente a "-swap -2,-1". |

  magick font_[0-3].gif  +swap  +append  seq_swap2.gif

Provavelmente o uso mais comum desse operador é trocar duas imagens antes de serem usadas por um operador de camada de imagem, como "[-composite](https://imagemagick.org/command-line-options/#composite)", "[-flatten](https://imagemagick.org/command-line-options/#flatten)", "[-append](https://imagemagick.org/command-line-options/#append)" ou "[-fx](https://imagemagick.org/command-line-options/#fx)". |

  magick tree.gif  frame.gif   +swap \
          -gravity center  -composite   framed_tree.gif

A partir do IM v6.4, um "[-swap](https://imagemagick.org/command-line-options/#swap)" com um único número trocará a última imagem com o número fornecido. Ou seja, "-swap 1" é equivalente a "-swap 1,-1". |

  magick font_[0-3].gif  -swap 1  +append  seq_swap3.gif

-reverse

O operador "[-reverse](https://imagemagick.org/command-line-options/#reverse)" (adicionado no IM v6.3.4) simplesmente inverterá a ordem de toda a lista de imagens. |

  magick font_[0-3].gif -reverse  +append seq_reverse.gif

É basicamente um Operador Swap definitivo.

-clone {index_range_list}

Este operador de lista de imagem é um pouco diferente. Dado um número de lista de imagens, "[-clone](https://imagemagick.org/command-line-options/#clone)" fará uma cópia de uma imagem que tenha sido salva pelo operador 'colchete de abertura' ou 'parêntese'. Ou seja...

O Clone só deve ser usado dentro de parênteses

A razão para isso é que ele permite que você extraia uma cópia de uma imagem da última lista de imagens salva (empilhada), para que você possa processá-la ainda mais. Por exemplo. |

  magick font_[0-2].gif \( -clone 1 -rotate 90 \) +append  seq_clone.gif

A forma 'mais' sem argumento, "+clone", apenas fará uma cópia da última imagem da lista de imagens salva (empilhada), para que você possa processá-la ainda mais |

  magick font_[0-2].gif \( +clone -flip \) +append  seq_clone2.gif

A partir do lançamento da versão 6.2.2, o operador "[-clone](https://imagemagick.org/command-line-options/#clone)" receberá uma lista de imagens separadas por vírgula, ou um intervalo de índices da forma '_{index}-{index}_'. |

  magick font_[0-2].gif \( -clone 1-2 \) +append  seq_clone_range.gif

É claro que índices negativos ainda se comportam exatamente como você esperaria. Por exemplo, para duplicar toda a lista de imagens, você pode especificá-la usando os números '0' (primeira imagem) e '-1' (última imagem), ou seja, usando o intervalo '0--1'. Pode parecer estranho, mas faz sentido e funciona bem. |

  magick font_[0-2].gif \( -clone 0--1 \) +append  seq_clone_all.gif

Quando você usa uma lista de índices separados por vírgula, as imagens são extraídas na ordem que você especifica. |

  magick font_[0-2].gif \( -clone 2,0,1 \) +append  seq_clone_list.gif

Se as imagens em um intervalo estiverem invertidas (após os índices negativos serem convertidos em um índice de imagem real), as imagens extraídas também são invertidas, como parte do processo. |

  magick font_[0-2].gif \( -clone 2-0 \) +append  seq_clone_reversed.gif

O Operador Clone Image pode ser usado sem parênteses, e apenas copiará imagens da lista de imagens atual e as anexará diretamente. No entanto, este não é seu uso pretendido e deve ser desencorajado, pois produzirá um resultado diferente se você posteriormente cercar aquele conjunto de operações com parênteses. Além disso, nos exemplos acima, estou gerando clones e os anexando à lista de imagens atual, para demonstrar o operador. Na realidade, eu deveria estar usando o Operador Duplicate Image para duplicar imagens na lista de imagens atual. Você também deveria, pois isso deixará mais claro o que você está tentando fazer. O Registrador de Memória de Imagem MPR: também pode ser usado para clonar imagens e estava disponível no IM v5. Na verdade, ele ainda é um método útil para clonar e armazenar toda uma lista de imagens (de comprimento desconhecido) para uso posterior, e não apenas uma única imagem individual, como os operadores de lista de imagem acima fazem.

-duplicate {count}[,{index_range}]

Você pode usar "[-duplicate](https://imagemagick.org/command-line-options/#duplicate)" para gerar cópias extras (clones) de uma imagem, a partir da lista de imagens atual (adicionado no IM v6.6.8-7). As novas imagens são adicionadas ao final da lista. Ao contrário do (e mais antigo) Operador Clone anterior, ele não requer o uso de parênteses. Por exemplo, para fazer N cópias extras de uma imagem (totalizando N+1), você pode fazer isto... |

  magick font_5.gif   -duplicate 4   +append seq_duplicate.gif

Observe que este operador pode gerar centenas de imagens muito rapidamente; no entanto, até que as imagens sejam processadas, as imagens são simplesmente 'clones' umas das outras, compartilhando os dados de imagem reais entre elas. Assim, as imagens duplicadas são muito eficientes em memória. Se mais de uma imagem estiver presente, a última imagem é duplicada N vezes... |

  magick font_[0-1].gif   -duplicate 3   +append seq_dup_n.gif

Se você quiser apenas duplicar a última imagem uma vez, pode usar a forma 'mais' do argumento. |

  magick font_[0-3].gif  +duplicate   +append seq_dup_last.gif

Se você quiser selecionar uma imagem específica para duplicação múltiplas vezes, pode especificar o índice da imagem como um segundo argumento. |

  magick font_[0-2].gif  -duplicate 2,0  +append seq_dup_index.gif

A parte de índice do argumento pode conter uma lista ou intervalo de índices de imagem a serem duplicados N vezes. Por exemplo, duplicar toda a lista duas vezes para criar três vezes o número original de imagens...

  magick font_[0-4].gif  -duplicate 2,0--1  +append seq_dup_list.gif

Uma lista de animação do tipo Ciclo de Patrulha também é fácil de criar usando uma lista de imagens que é invertida. |

  magick font_[0-9].gif -duplicate 1,-2-1 \
          -set delay 50 -set dispose previous -loop 0  seq_reverse_anim.gif

Observe que não copiei toda a lista de imagens, mas pulei a cópia da primeira (0) e da última (-1) imagem, tornando os índices de imagem -2 a 1. Se sua versão do IM for mais antiga que a v6.6.8-7, você ainda pode gerar imagens duplicadas, com o Operador Clone Image, mas apenas um conjunto de imagens de cada vez. Ou, usando uma técnica que basicamente faz uso indevido do Operador Color Morph, gerar múltiplas imagens duplicadas. O truque é primeiro fazer um clone para gerar duas imagens idênticas, depois usar "[-morph](https://imagemagick.org/command-line-options/#morph)" para gerar as N-2 imagens finais entre elas. |

  magick font_7.gif \( +clone \) -morph 3  +append seq_dup_morph.gif

Observe, no entanto, que ao fazer uso indevido do Operador Color Morph, as imagens estão, na verdade, sendo processadas, então leva tempo para o morph realmente processar as imagens (produzindo nenhuma alteração). Além disso, as imagens criadas conterão cópias reais dos dados originais, e não clones simples que economizam memória.

Combinando Operações de Sequência de Imagens

Usando esses operadores, você pode extrair uma cópia de uma imagem específica, modificá-la e retornar essa imagem de volta para onde a pegou. Por exemplo, aqui faço um "[-clone](https://imagemagick.org/command-line-options/#clone)" da 2ª imagem (índice de imagem '1'), giro as cores das imagens de azul para vermelho, depois substituo a imagem original pela modificada, primeiro fazendo "[-delete](https://imagemagick.org/command-line-options/#delete)" e "[-insert](https://imagemagick.org/command-line-options/#insert)" a nova. |

  magick font_[0-3].gif  \( -clone 1  -modulate 100,100,166 \) \
          -delete 1  -insert 1    +append seq_update_1.gif

Outra maneira que parece ter se tornado mais comum é usar "[-swap](https://imagemagick.org/command-line-options/#swap)" para substituir a imagem original, depois "[+delete](https://imagemagick.org/command-line-options/#delete)" a imagem antiga que agora está no final. Isso requer apenas que você forneça a posição da imagem duas vezes, em vez de três. Uma para clonar, e uma para substituir a imagem modificada. |

  magick font_[0-3].gif  \( -clone 2  -modulate 100,100,166 \) \
          -swap 2  +delete     +append seq_update_2.gif

Essas técnicas são continuadas abaixo na próxima seção sobre Processamento de Imagem Complexo e Depuração.

Processamento de Imagem Complexo e Depuração

Graças à adição dos Operadores de Sequência de Imagens (veja acima), você não precisa mais processar imagens uma etapa de cada vez, salvando a imagem e relendo-a novamente a cada vez. Em vez disso, você agora pode simplesmente manter a imagem intermediária na memória e continuar processando-a. Isso economiza muito tempo, tanto na conversão de imagens para um formato de arquivo, quanto na E/S real para salvar a imagem em um disco lento. Esse tipo de comando de processamento de imagem pode se tornar muito longo e complexo. Assim, é melhor escrever o comando em scripts, e tentar colocar cada operação principal em uma linha separada, para facilitar a programação e a edição. Veja Dicas para Melhores Scripts de Shell/PHP do ImageMagick. Por exemplo, aqui passo por toda uma sequência complexa de processamento para gerar um botão vermelho sobre um fundo preto. |

  magick -size 30x30 xc:black -fill white  -draw 'circle 15,15 5,15' \
          \( +clone -shade 110x90 -normalize -negate -alpha Off \) \
          \( +clone -clone -2 -compose Plus -composite \) \
          \( -clone 0 -shade 110x50 -normalize -alpha Off \) \
          \( +clone -gamma 1,0,0 \) \
          \( -clone 2,-1  -compose Multiply -composite \) \
          -append  seq_process_fx.gif

Cada linha do comando magick gera uma nova imagem, exceto a última linha, onde apenas Anexei todas as imagens de trabalho juntas para gerar os resultados de todas as etapas de processamento, em vez de apenas a imagem final. Essa técnica permite que você acompanhe o que cada etapa (envolta em parênteses) do comando muito complexo produziu, e permite uma depuração mais fácil de cada etapa de um processo. Observe como ele usa apenas o tamanho e a forma da imagem inicial para gerar a forma inicial do botão, então você está livre para usar qualquer forma ou imagem que quiser! O restante do comando o processará exatamente como antes. É claro que você normalmente Excluiria todas as imagens de trabalho temporárias. Ou seja, eu substituiria a última linha no exemplo acima por algo assim...

          -delete 0--2  seq_process_result.gif

Outras maneiras de verificar os resultados é canalizar o resultado para o comando display, de modo a visualizar os resultados na tela, em vez de salvá-los em um arquivo de imagem. Ou seja, use algo assim para a última linha...

          +append  miff:- | display -

Alternativamente, em vez de "[display](#display)", você pode usar 'show:', que exibirá a imagem resultante na tela e então permitirá que o comando original continue ou saia. Veja Show, Saída de Exibição de Imagem para mais informações.

          +append  show:

Na verdade, você nem precisa do "[+append](https://imagemagick.org/command-line-options/#append)", caso em que o IM mostrará cada imagem em sequência, ao pressionar a 'barra de espaço'. Você pode até ficar mais sofisticado usando o comando "[montage](#montage)" para visualizar os resultados de uma maneira mais agradável...

          miff:- | montage - -bordercolor blue -border 1 -geometry +2+2 show:

Esse tipo de processamento de imagem também permite a fácil visualização de imagens intermediárias, imediatamente após a imagem ter sido criada. Basicamente, você pode inserir linhas como esta entre as instruções "\( ... \)".

          \( +clone -write show: +delete \)\

O IM continuará automaticamente o processamento assim que essa imagem intermediária tiver sido exibida para fins de visualização. Veja Show, Saída de Exibição de Imagem. Alternativamente, ao inserir esta linha, você pode exibir todas as imagens atuais geradas até aquele ponto no processamento...

          \( -clone 0--1 -append -write show: +delete \)\

Depois de ter as etapas de processamento de imagem depuradas e ajustadas, você pode otimizar o código, de modo a não usar tantas etapas de parênteses, bem como menos Imagens Clonadas, resultando em menos imagens intermediárias para Excluir no final. Lembre-se também de que a "Composição de Imagem", e/ou o "Achatamento de Camadas", mescla múltiplas imagens juntas, para deixar apenas a única imagem resultante, o que pode reduzir o número geral de imagens intermediárias na memória. |

  magick -font Ravie -pointsize 48 -background black -fill white \
          label:'IM' -bordercolor black -border 5  seq_label.gif

  magick seq_label.gif -alpha Off \
          \( +clone  -shade 110x90 -normalize -negate \
             +clone  -compose Plus -composite \) \
          \( -clone 0 -shade 110x50 -normalize -gamma 1,0,0 -alpha Set \) \
          -delete 0 +swap  -compose Multiply -composite  seq_button.gif

A capacidade do ImageMagick de processar qualquer imagem, de uma maneira padrão, programada e automatizada, usando múltiplas etapas, tudo em um único comando, é o que torna o IM uma ferramenta tão poderosa. Você pode programar uma operação muito complexa, depois aplicá-la a muitas imagens. Os operadores de lista de imagem e os parênteses simplesmente tornaram o IM uma ordem de magnitude mais poderoso, permitindo que você escreva programas de manipulação de imagem mais complexos, com menos comandos. Para outro exemplo de como programar um processo de imagem complexo, veja o exemplo Marcadores 3-D Programados a partir de Formas. Veja também Dicas para Melhores Scripts de Shell/PHP do ImageMagick, sobre maneiras de melhorar seus scripts de processamento de imagem, tanto para edição e compreensão mais fáceis, quanto para que outros possam acompanhar o que você fez.

Metadados de Imagem: Atributos, Propriedades e Artefatos

Até agora, olhamos as imagens e o conteúdo ou dados reais que compõem a imagem. Mas as imagens são mais do que apenas 'dados de imagem'. Existem muitos atributos ou metadados que também fazem parte de uma imagem, e afetam seu processamento e como outros programas devem manipulá-la. Por exemplo, uma imagem poderia ter um 'deslocamento' ou ser parte de uma 'tela virtual' (página) maior. Ou seja, uma única imagem pode ser apenas uma pequena parte de uma imagem maior, composta por uma série de outras imagens, para formar 'camadas' ou uma 'animação'. O IM também anexa muitas 'configurações' especiais que são usadas por muitos operadores de processamento de imagem para modificar como eles funcionam. Por exemplo, a 'cor de fundo' a ser usada. Algumas delas são configurações globais, que são as mesmas em toda uma lista de imagens, enquanto outras podem ser diferentes para cada imagem dentro da lista. Então, que tipo de coisas também fazem parte de uma imagem? Muitas coisas...

• Metadados de imagem que são tipicamente (embora nem sempre) salvos com a imagem nos formatos de arquivo de imagem. Por exemplo: perfis, rótulos, legendas e comentários, e informações de tela virtual (página). Estas são todas configurações por imagem, e podem ser diferentes para cada imagem na lista de imagens atual.
• Configurações globais usadas por muitos operadores de processamento de imagem diferentes, mas geralmente não salvas com a imagem: Cores como background, bordercolor, fill e mattecolor, também font e pointsize, gravity, método de composição, manipulação de canal de cor, profundidade de bits de leitura/escrita dos valores de cor.
• Configurações e defines de especialista, usados para controlar a operação mais profunda e de mais baixo nível de operadores de processamento de imagem específicos. Por exemplo: viewport de distorção, argumentos especiais de método de composição,
• Como a imagem deve ser realmente armazenada na memória dentro do ImageMagick: por exemplo, como RGB ou CMYK. Se um canal alfa está presente, e habilitado ou não, também a paleta que uma imagem pode ter tido quando lida. No entanto, algumas dessas configurações de armazenamento são codificadas fixamente em tempo de compilação (como a Quality dos valores de cor em memória).
• Algumas configurações operacionais gerais do IM, como configurações de depuração ou verbose, tipicamente controlando a saída de informações ou o tratamento de erros.

Ou seja, muita informação que pode ser salva, e/ou afetar como as imagens são processadas. E embora elas possam se enquadrar em vários grupos, o quão bem o ImageMagick lida com cada uma dessas coisas, e se elas são globais ou específicas da imagem, depende muito da coisa específica envolvida. Sim, estou sendo vago, porque até você chegar aos detalhes, é muito difícil não ser. Também pode ser muito confuso. Todos esses valores são armazenados com as imagens em memória de três maneiras diferentes...

Atributos

Estes são armazenados como itens de estrutura de dados especiais para cada imagem, geralmente de modo a permitir acesso rápido e direto pelos vários operadores de processamento de imagem. Por exemplo: tamanho da imagem, geometria da tela virtual, cores de background, fill, stroke, matte, pointsize, density, font, compose, interpolate, método virtual-pixel, blocos de perfil, configurações de atraso de tempo e descarte; e muitas outras coisas. Observe que algumas delas são 'específicas' de cada imagem, enquanto outras são tratadas como uma configuração 'global' que é definida com o mesmo valor em todas as imagens pela interface CLI, embora ainda sejam armazenadas como parte de cada imagem individual. Os atributos são tipicamente modificados usando as muitas opções, como parte do processamento de imagem normal, ou mais geralmente usando Set.

Propriedades

Estas são um conjunto de forma livre de strings chave-valor que são anexadas a cada imagem individualmente. Cada imagem pode ter um conjunto de strings completamente diferente. Essencialmente, elas são itens de metadados que não precisam ser acessados ou decodificados regularmente, ou são usados de alguma maneira especial. Exemplos típicos disso são: strings de label, caption e comment; datas de criação e modificação; strings definidas pelo usuário; resultados de alguns operadores. Os usuários podem usar Set para definir ou alterar estes, desde que a 'chave' não corresponda a algum 'atributo' conhecido.

Artefatos

Este é um conjunto global de strings de forma livre que é comum a todas as imagens. É usado para conter configurações globais de forma livre que definem ou modificam a leitura e o processamento de todas as imagens. Um exemplo disso é a configuração "verbose", que faz com que algumas operações gerem informações gerais sobre suas ações, incluindo uma saída mais verbosa do magick identify. Os usuários podem modificar esses valores globais usando Define (veja abaixo), ou com um caso especial do Set, (veja Usando Set "Option:" para Definir um Artefato).

Compreender esses três métodos de armazenamento é a chave para saber como o tratamento de configurações e metadados funciona dentro do ImageMagick. E permite que você faça algumas técnicas de processamento de imagem muito avançadas e normalmente difíceis de alcançar.

Definindo/Alterando Atributos/Propriedades de Imagem

Metadados Simples são atributos de imagem que frequentemente têm a maior importância para o processamento de imagem. Tão importantes que são decodificados e disponibilizados na estrutura de dados da imagem para permitir uso rápido pelos operadores de processamento de imagem. Tais dados são geralmente modificados de duas maneiras. Uma alteração direta dos metadados da imagem à medida que uma imagem é lida ou criada. Ou como uma modificação de metadados de uma imagem que já está na memória. Por exemplo, "-label 'string'" definirá o comment em cada imagem que é lida ou criada depois que essa configuração foi definida. No entanto, "-set label 'string'" alterará os metadados de 'label' de todas as imagens na lista de imagens atual, já na memória. A razão para os dois métodos é devida à compatibilidade retroativa histórica e à conveniência. Basicamente, "-label" tem sido tradicionalmente definido ANTES de a imagem à qual é aplicado ser lida. Ele só afeta as imagens que são lidas (ou criadas) depois de ter sido definido, ou alterado. Por exemplo....

  magick -label one  image_one.png \
          -label two  image_two.png     output_image_list

Por outro lado, o operador "[-set](https://imagemagick.org/command-line-options/#set)" altera TODAS as imagens que estão na lista de imagens atual, incluindo as previamente lidas. Assim, você geralmente deve usar parênteses para limitar a qual imagem está aplicando a opção, a menos que queira aplicá-la a TODAS as imagens lidas até agora.

  magick \( image_one.png -set label one \) \
          \( image_two.png -set label two \)  output_image_list

Você pode anular a definição da configuração usando "+label", caso em que os metadados de label serão deixados intactos quando a imagem é lida ou criada. Se a imagem lida também não tiver um label, o IM recorrerá a algum padrão lógico. Para label, esse é apenas a string vazia. Você pode ver exemplos mais detalhados e específicos de ambos os métodos em Rotulagem de Imagens com Montage, que faz uso intenso disso para fins de rotulagem. Essa 'dualidade' de definição de metadados de imagem também existe para outras opções. Isso inclui... "[-comment](https://imagemagick.org/command-line-options/#comment)", "[-caption](https://imagemagick.org/command-line-options/#comment)", "[-page](https://imagemagick.org/command-line-options/#page)", "[-dispose](https://imagemagick.org/command-line-options/#dispose)" e "[-delay](https://imagemagick.org/command-line-options/#delay)". A configuração de tamanho da tela virtual e deslocamento da imagem (página), no entanto, também tem um terceiro método, usando um operador especial "[-repage](https://imagemagick.org/command-line-options/#repage)" (veja Tela Virtual abaixo).
Por exemplo, aqui uso todos os métodos de configuração disponíveis para definir o 'deslocamento da tela virtual' ou 'página' das imagens individuais, à medida que crio uma Animação a partir delas... |

  magick -delay 100 -dispose Background \
            -page 100x100+5+10  eye.gif  \
            -page +35+30        news.gif  \
            \( storm.gif  -set page +62+50 \) \
            \( tree.gif   -repage   +10+55 \) \
          -loop 0  animation_page.gif

Como você pode ver, o método tradicional (não-set) é mais simples ao criar uma lista de múltiplas imagens a partir de arquivos de imagem separados. Mas os operadores "[-set](https://imagemagick.org/command-line-options/#set)" ou o especializado "[-repage](https://imagemagick.org/command-line-options/#repage)" são melhores quando você precisa alterar uma imagem que já foi lida para a memória, ou foi criada por algum método de processamento de imagem complexo. Por exemplo, para alterar o deslocamento da imagem da terceira imagem (índice de imagem '2', ou a 'tree') no último exemplo... |

  magick animation_page.gif \
          \( -clone 2 -set page +55+10 \) -swap 2  +delete \
          animation_mod.gif

Para um exemplo mais extremo de extração e modificação de imagens individuais em uma lista de imagens, veja Modificação Quadro a Quadro de uma Animação. Aqui está outro exemplo usando "[-set](https://imagemagick.org/command-line-options/#set)" para especificar um comentário em todas as imagens, e então modificar uma imagem específica.

  magick xc: -duplicate 9 \
              -set comment 'T minus %[fx:n-t]' \
              \( -clone 7 -set comment 'We have ignition!' \) -swap 7 +delete \
              -format "image #%p : %c" info:

Você pode usar "[mpr:](files.html#mpr)" como uma maneira alternativa de definir atributos em imagens na memória. Por exemplo, aqui pegamos uma imagem com um comentário 'Bad', que está na memória, e substituímos o comentário por um 'Good'...

  magick -comment 'Bad Comment' rose: \
          -write mpr:rose +delete \
          -comment Good   mpr:rose  rose.jpg


  magick identify -format "image comment = %c" rose.jpg

Isso funciona, mas é extremamente desajeitado e doloroso de usar, especialmente ao lidar com múltiplas imagens, como uma animação. Na verdade, esta é a única maneira de alterar metadados em imagens no IM versão 5. (Eca!)

Atributos Globais Gerais

Em Construção

Most of these attributes are generally set globally either before or after
reading images into memory (it makes no difference).  They are typically used
as a general control of the later image processing operations.

 * Many settings are simpley globally saved for use as needed
     -fill  -background  -bordercolor  -strokecolor  -mattecolor  -quantize
     +dither  -channels  -size  -gravity  -units  -density  -font  -pointsize
     -tile

 * Some settings affect the way an image is saved to disk, or the meta-data
   saved with the image.  This includes
     -loop  -compression  -quality  -depth
     -density  -background

 * -compose is awkward, as it can only be set globally. But if unset
   then individual images can have a different setting (for layering).

   Most of these however can be turned off, (using a + version) which
   causes the operator to retrieve the setting from image meta-data
   (eg: +background falls back to the original images meta-data if present)
   but more generally it falls back to some default value. (eg:
   +gravity falls back to 'None' to mean no gravity has been set).

   A few of these also get saved with images when written. Specifically
   the GIF format will save an the -background and -bordercolor as part of the
   images attributes, however these are normally ignored by programs which
   read these images.

You may have noticed that some settings are used in multiple places.
for example  -density

  * used in reading in many vector format images like
    Postscript, PDF, and WMF image formats.
  * also in special image generators such as label: caption: and text:
  * used as part of font drawing in -annotate -draw and -polaroid  operators.
  * And finally some formats save the density or resolution as part
    of the the image file format. For example postscript wrapped raster
    images, JPEG, and TIFF.

Is it any wonder then why settings can be so confusing.

Tela Virtual e os Operadores Page e Repage

+repage

Sem argumentos, redefinirá a tela virtual da imagem para a própria imagem real. Ou seja, apenas limpa qualquer informação de tela virtual que a imagem possa ter. Isso é frequentemente importante após aplicar os operadores de subdivisão de imagem, como Recorte e Aparo. É especialmente importante na remoção de tamanho e deslocamentos da tela virtual antes de salvar nos formatos de arquivo de imagem GIF ou PNG, pois muitos navegadores usam a informação de tela/deslocamento como parte da exibição da imagem.

-repage WxH

Altera o tamanho da tela virtual das imagens existentes, mas não redefine a posição da imagem nessa tela. Observe que fornecer este argumento a "[-page](https://imagemagick.org/command-line-options/#page)" ou "[-set](https://imagemagick.org/command-line-options/#set) page" redefinirá a localização das imagens para '+0+0', o que provavelmente não é desejado..

-repage +X+Y

Apenas move a imagem na tela virtual para esta localização absoluta sem alterar o tamanho da tela das imagens.

-repage +X+Y\!

Faz um movimento relativo da imagem na tela virtual, adicionando os números fornecidos (positivos ou negativos) à posição de deslocamento existente das imagens.

-repage 0x0

Tenta encontrar o melhor tamanho de tela virtual que contenha toda a imagem. No entanto, isso falhará para imagens com um deslocamento negativo, pois não há como especificar uma tela virtual com componentes negativos. Para evitar problemas, ele usará o tamanho da imagem real como o menor tamanho de tela possível. Ou seja, nunca atribuirá uma tela virtual com dimensões zero.

-repage 0x0+X+Y

Move o deslocamento das imagens, depois redimensiona a tela virtual para melhor caber na nova localização das imagens.

-repage 0x0+0+0

Equivalente a um "[+repage](https://imagemagick.org/command-line-options/#repage)" ou "[+set](https://imagemagick.org/command-line-options/#set) page" ou um "[-set](https://imagemagick.org/command-line-options/#set) page 0x0". Toda a informação de tela virtual e deslocamento é removida.

-repage WxH+X+Y

Equivalente a um "[-set](https://imagemagick.org/command-line-options/#set) page WxH+X+Y". Ou seja, apenas atribui os valores fornecidos diretamente.

Set e Propriedades por Imagem

No entanto, o IM não pode criar uma opção para lidar com cada configuração possível que uma imagem pode ter. Isso seria simplesmente impossível. Não apenas isso, mas os usuários frequentemente gostam de adicionar ou definir suas próprias configurações. Por causa disso, a opção "[-set](https://imagemagick.org/command-line-options/#set)" pode, na verdade, definir QUALQUER configuração com QUALQUER valor. Se a configuração não for um atributo especificamente conhecido de uma imagem (a ser salvo de uma forma que permita acesso rápido pelos operadores), ela é salva na imagem como uma 'Propriedade' (um array de strings), e será listada perto do final de uma saída verbosa do "magick identify", ou recuperada e expandida usando Escapes de Porcentagem. A imagem rose embutida, por exemplo, gera automaticamente três 'propriedades': duas strings de data, e um 'hash de assinatura'. A isso, também adicionei minha própria configuração de 'propriedade' definida pelo usuário.

  magick rose:  -set my_property my_value   -verbose info: |\
    sed -n '/Artifacts/q; /Properties/,$ p'

Alguns operadores de processamento de imagem até retornam valores de interesse especial como 'propriedades' de imagem. Eles não são necessários por outros operadores, então não são armazenados como um 'atributo', mas são salvos como uma string de 'propriedade' para possível uso pelo usuário. Por exemplo, o pointsize final selecionado por um Rótulo de Melhor Ajuste será salvo como uma propriedade de imagem especial. |

  magick -size 100x label:Anthony  -verbose -identify  property_label.gif |\
    sed -n '/Artifacts/q; /Properties/,$ p'

|

| Observe que o geradorlabel: em si também define um atributo 'label', que por acaso é salvo como uma string de propriedade.
---|---
| _Todas as 'propriedades' são salvas como um tipo de dado de string de forma livre, e armazenadas como metadados de imagem.

Por causa disso, nem todos os 'atributos' são salvos como 'propriedades', pois muitos atributos precisam ser salvos e usados diretamente como dados numéricos pelos operadores de processamento de imagem. Um exemplo disso é o atributo de 'page' da tela virtual._
---|---
Aqui uso uma configuração "[-format](https://imagemagick.org/command-line-options/#format)" do identify para fazer o IM gerar o pointsize do rótulo que ele criou e descartou. |

  magick -size 100x label:Anthony \
          -format 'pointsize = %[label:pointsize]pts' info:

Usar essa informação para gerar uma nova imagem de rótulo é complicado e será examinado abaixo. Uma das configurações definidas pelo usuário mais úteis que você pode usar é a configuração "filename:". Por exemplo...

  magick rose: -set filename:my_area '%wx%h' 'rose-%[filename:my_area].png'

O acima gerará uma imagem chamada "rose-70x46.png". Apenas configurações definidas pelo usuário prefixadas com a string "filename:" podem ser usadas dentro do nome do arquivo de saída, como medida de segurança, embora qualquer nome possa ser usado. Para mais exemplos disso, veja Escapes de Porcentagem de Nome de Arquivo.

Define e Artefatos Globais

  -define jpeg:size=300x200
  -define jpeg:preserve-settings=1
  -define jpeg:optimize-coding=true

Opções de Distorção de Imagem, como...

  -define distort:scale=2
  -define distort:viewport=44x44+15+0

Controles de Filtro de Redimensionamento, como

  -define filter:blur=0.75
  -define filter:support=1.25

Alguns defines de artefato têm atalhos porque são usados muito regularmente pelos usuários. Por exemplo, o controle operacional "[-verbose](https://imagemagick.org/command-line-options/#verbose)" (veja abaixo) é, na verdade, equivalente a usar "-define verbose", e assim criar um artefato 'verbose'. Por exemplo...

  magick xc: -verbose info: |\
    sed -n '/Tainted:/q; /Artifacts:/,$ p'

Decorre, então, que a forma com mais "[+verbose](https://imagemagick.org/command-line-options/#verbose)" apenas remove o artefato 'verbose', e é, portanto, equivalente a "+define verbose".

Artefatos e Escapes de Porcentagem Adiados

Os artefatos também são frequentemente usados para conter atributos especiais que devem ser atribuídos a imagens que são lidas, depois que o define foi fornecido. A configuração "[-label](https://imagemagick.org/command-line-options/#label)" também apenas define um artefato com o argumento fornecido pelo usuário. Esse artefato é então convertido em uma Configuração ou Propriedade 'label' depois que uma nova imagem foi lida ou criada. Por exemplo, criando uma imagem "rose:" com um label definido

  magick -label "%wx%h"  rose: -verbose info:  |\
      sed -n '/Tainted:/q; /Properties:/,$ p'

Ou seja, "[-label](https://imagemagick.org/command-line-options/#label)" primeiro definiu o artefato 'label' mostrado. Mais tarde, quando a imagem rose foi criada (e seus atributos de tamanho eram conhecidos), o IM converteu esse artefato global em uma 'propriedade' específica da imagem, e só então expandiu quaisquer Escapes de Porcentagem naquele momento. Isso é conhecido como Escapes de Porcentagem Adiados. A mesma coisa acontece com algumas outras opções de configuração, como "[-comment](https://imagemagick.org/command-line-options/#comment)" e "[-caption](https://imagemagick.org/command-line-options/#caption)" também. É por causa dos Escapes de Porcentagem Adiados que "[-define](https://imagemagick.org/command-line-options/#define)" salvará apenas as strings, enquanto o operador "[-set](https://imagemagick.org/command-line-options/#set)" fará a expansão.

Usando Set "option:" para Definir um Artefato

Mostramos acima como você pode usar "[-set](https://imagemagick.org/command-line-options/#set)" para Propriedades pessoais de propósito especial, em uma base por imagem. Por exemplo... |

  magick -size 80x40 xc:  -set myinfo 'I love IM!' \
          -gravity center -annotate 0x0 '%[myinfo]' \
          property_annotate.gif

Mas, como as Propriedades são anexadas a imagens específicas, você não pode usá-las na criação de novas imagens. Por exemplo, isto falhará... |

  magick rose: -set myinfo 'I love IM!'  label:'== %[myinfo] ==' \
          -gravity center  -append   property_append_fail.gif

Como você pode ver, a propriedade 'myinfo' não foi encontrada ou incluída no label anexado. Por outro lado, os Artefatos definidos globalmente estão disponíveis para os geradores de imagem. Eles têm que estar, para que os geradores de imagem ou os codificadores de arquivo de imagem possam lê-los para várias configurações de controle. Assim, usar um "[-define](https://imagemagick.org/command-line-options/#define)" funcionará como esperado. |

  magick rose: -define myinfo='I love IM!'  label:'== %[myinfo] ==' \
          -gravity center  -append   artifact_append.gif

Então, como você pode criar um label usando uma propriedade ou atributo de imagem? A opção "[-define](https://imagemagick.org/command-line-options/#define)" atualmente não permite o uso de propriedades de imagem! O truque é usar um prefixo especial "option:" ao usar a opção "[-set](https://imagemagick.org/command-line-options/#set)". Essa adição faz com que "[-set](https://imagemagick.org/command-line-options/#set)" defina um 'artefato' com o nome que segue o prefixo. Por exemplo, isto é equivalente ao último exemplo. |

  magick rose: -set option:myinfo 'I love IM!'  label:'== %[myinfo] ==' \
          -gravity center  -append   property_option_append.gif

Mais importante, a opção "[-set](https://imagemagick.org/command-line-options/#set)" expandirá os Escapes de Porcentagem. Isso significa que, se tivermos alguma Propriedade por imagem, podemos convertê-la em um Artefato global. Por exemplo, aqui crio um label, depois converto a propriedade 'label:pointsize' que o gerador de imagem "label:" criou, em um artefato global 'my_pointsize'. Como artefato, essa informação está disponível quando crio uma segunda imagem de label. Depois anexo os dois labels juntos (com uma linha 'gray' separadora). Um exemplo muito engenhoso. |

  magick -size 100x -gravity center label:Anthony \
          -set option:my_pointsize '%[label:pointsize]' \
          -set option:my_height '%h' \
          -size 100x1 xc:gray \
          -size 100x label:'at %[my_pointsize]pt and %[my_height]px high' \
          -append  property_append.gif

Observe a colocação do "-set option:..." acima. Se você o colocasse DEPOIS da criação do "xc:gray", seria essa imagem que seria usada para definir o artefato global. Ou seja, porque apenas as propriedades da última imagem definem o valor armazenado no artefato global. A razão é que apenas a última imagem é usada para definir o artefato. Na verdade, o que realmente acontece é que "[-set](https://imagemagick.org/command-line-options/#set)" é aplicado a cada imagem na lista de imagens atual, mesmo que esteja gerando um artefato global. Assim, cada imagem atribuirá suas próprias propriedades ao artefato global, substituindo os valores atribuídos anteriormente. Quando terminar, apenas a última imagem terá 'definido' o artefato. | No momento, o 'escape FX' não tem como ler propriedades ou artefatos. E assim, você atualmente não pode fazer aritmética com tais valores.
---|---

Tipo de Imagem ao Ler e Escrever

O operador/configuração "[-type](https://imagemagick.org/command-line-options/#type)" define o estilo ou espaço de cor a ser usado quando uma imagem está sendo lida ou escrita, para garantir que a imagem resultante (na memória, ou no arquivo de imagem) seja o que você espera que ela seja. Como parte disso, ele pode fazer algumas modificações de Espaço de Cor no momento da E/S de arquivo, embora apenas para garantir que a imagem esteja em uma forma que era esperada. Por exemplo, "[-type](https://imagemagick.org/command-line-options/#type)" tem uma configuração especial 'bilevel' que pode ser usada para converter e salvar imagens como uma imagem monocromática de duas cores para alguns formatos de imagem. Da mesma forma, 'TrueColor' e 'TrueColorAlpha' podem ser usados para forçar uma imagem TIFF a ser salva como uma imagem RGB de cor completa, mesmo que a imagem seja, na verdade, puramente em escala de cinza. Outras configurações incluem 'GrayScale' e 'GrayScaleAlpha', que garantirão que a imagem escrita seja apenas em escala de cinza (sem ou com transparência, respectivamente). Ou 'Palette' para forçar o uso de um mapa de cores indexado em formatos que suportam essa opção. Durante a leitura de formatos de arquivo de imagem, uma configuração "[-type](https://imagemagick.org/command-line-options/#type)" de 'TrueColorAlpha' forçará uma imagem JPEG sendo lida a ter um canal 'Alpha' adicionado ao seu armazenamento em memória, mesmo que o próprio formato JPEG não possa lidar com transparência. Ao escrever em um formato de arquivo PNG, definir um "[-type](https://imagemagick.org/command-line-options/#type)" de 'Pallette' o forçará a usar um formato de imagem interno PNG indexado por cor "PNG8'. Da mesma forma, usar "BiLevel" forçará o IM a aplicar dithering a imagens coloridas para preto e branco para a maioria dos formatos de arquivo de imagem. Infelizmente, o significado exato e as capacidades de "[-type](https://imagemagick.org/command-line-options/#type)" dependem do formato de imagem específico que você está lendo ou escrevendo. Veja as várias áreas de exemplos de Formatos de Arquivo de Imagem. Para exemplos específicos de PNG, veja Formatos de saída PNG.

Controlando a Qualidade das Imagens

Depth - Profundidade de Bits do Formato de Arquivo

Quality e Depth são dois termos frequentemente discutidos nos fóruns de discussão e nestas páginas de exemplos, então gostaria de explicá-los um pouco. Quality é uma configuração de tempo de compilação no ImageMagick, e é usada para determinar o tamanho dos valores usados para armazenar imagens na memória do IM e durante o processamento. Basicamente, significa a Qualidade de Processamento para a qual um IM específico foi compilado. O Depth é o tamanho dos valores usados quando uma imagem é lida ou salva de/para um Formato de Arquivo de Imagem. É, como tal, mais altamente variável, e controlado pela configuração "[-depth](https://imagemagick.org/command-line-options/#depth)", ou pela 'profundidade' original da imagem que foi lida. Mais sobre isso em um momento. Lembre-se...

Quality é o tamanho do valor 'em memória', e é compilado no IM.
Depth é o tamanho do valor do formato de arquivo, e é variável.

Agora, a maioria dos formatos de imagem são de profundidade 8. Ou seja, eles usam 8 bits (ou um valor de 0 a 2⁸-1) para conter cada valor de cor usado na imagem. Isso é um valor de 0 a 255 para o vermelho, 0 a 255 para o verde, e 0 a 255 para o canal azul. Mais usualmente, esse tipo de imagem é referido como imagens de 24 bits (ou seja, "bits por pixel", NÃO "bits por valor", como usado pela configuração "[-depth](https://imagemagick.org/command-line-options/#depth)"). Isso inclui formatos como o JPEG). Se o canal alfa também estiver envolvido, então você obtém 4 x 8 bits de valor, ou uma imagem de 32 bits/pixel. Isso é o que uma imagem PNG tipicamente usará, embora tais imagens também possam ser salvas usando 16 bits por valor. O que muitas pessoas chamam de imagens de 8 bits (8 bits/pixel) são, na verdade, imagens com uma paleta ou mapa de cores de 8 bits (dando um limite máximo de 256 cores em toda a imagem). Os dados de pixel reais são um valor de índice de 8 bits (0-255), que é então usado para buscar a cor daquele pixel na tabela de cores. Ou seja, o 'rasterizado' (array de pixels) é apenas um índice usado para buscar a cor real do pixel em uma tabela separada de cores. Em outras palavras, embora uma imagem de 8 bits também tenha uma profundidade de 8 bits, os 8 bits são um índice em uma tabela de busca de cor, e não uma cor real. As imagens GIF são um bom exemplo disso. A transparência em tais imagens é geralmente tratada especificando uma cor específica como representando a transparência (definida usando a configuração de metadados "[-transparent-color](https://imagemagick.org/command-line-options/#transparent-color)"), como no formato GIF, ou usando um perfil especial para um número específico de cores na tabela de cores (como usado por algumas imagens PNG8 (que também é uma imagem indexada por cor, como o GIF). Em geral...

24 bit images are : 3 x 8 bit values - 3 color channels only
32 bit images are : 4 x 8 bit values - 3 colors + Alpha channel
8 bit images are : 8 bit color indexed image, with a 256 color limit

Como a maioria dos formatos de imagem só salva valores de cor em uma profundidade de 8 bits/valor, muitas pessoas instalaram o IM usando um nível 'Q' ou de Quality de profundidade 8, que requer muito menos memória e processa imagens mais rápido do que uma versão Q16 mais normal do IM. Frequentemente, 3 ou mais vezes mais rápido. Essas versões Q8 funcionam bem para processamento geral de imagem (recorte, etc.) e conversão entre formatos, e também podem funcionar bem para gerar imagens simples, anotar ou sobrepor imagens. No entanto, embora um IM de baixa qualidade seja mais rápido e mais eficiente em memória, ele não funciona bem quando você começa a usar sequências complexas de operações envolvendo múltiplas mudanças de cor, redimensionamento, escurecimento, clareamento, correção de cor por gamma ou histograma, etc.. No Q8, as imagens intermediárias na memória permanecerão armazenadas como qualidade de 8 bits, e assim múltiplas operações introduzirão, cada uma, pequenas distorções incrementais de cor. O resultado pode ser efeitos de arredondamento, especialmente para cores extremas próximas ao branco e ao preto. (veja abaixo).

Quality - Qualidade de Bits em Memória

Lembre-se, Quality é uma configuração de tempo de compilação no ImageMagick, e é usada para determinar o tamanho dos valores usados para armazenar imagens na memória do IM e durante o processamento. Ela não pode ser alterada, exceto recompilando o ImageMagick a partir das fontes. Um ImageMagick 'Q16' (o padrão do IMv7) usará, portanto, pelo menos o dobro de memória para conter a mesma quantidade de dados de imagem que uma versão 'Q8' do ImageMagick e, dependendo da sua CPU, será muito mais lento, embora nos processadores de hoje isso não seja muito provável. Da mesma forma, você pode compilar versões 'Q32' e 'Q64', embora estas não sejam muito comuns, e sejam tipicamente usadas apenas em processamento de imagem de altíssimo nível. Veja também a nova opção de qualidade de compilação HDRI abaixo. Um ImageMagick 'Q16' também permite que você salve mais informação de bits para cada valor de pixel. Ou seja, os valores de cor são salvos como inteiros variando em valores de '0' a '2^_quality_ -1'. Esse último valor é conhecido na programação do IM como o 'QuantumRange' atual (ou o nome antigo obsoleto 'MaxRGB'). Quanto maior a configuração de Quality, usada ao compilar o IM, mais precisos são os valores de cor ao armazenar a imagem na memória. Isso significa que, se no processamento de uma imagem você gerar muitas variações pequenas e sutis de cor, então essas variações serão preservadas no armazenamento em memória do ImageMagick, e podem ser usadas em etapas de processamento posteriores. Operações como redimensionamento, filtros de ruído, desfoque, nitidez, médias, modificações globais de cor, gamma e histograma, ou muitas operações complexas de composição de imagem, podem todas produzir erros de cor indesejados em um IM Q8, criando artefatos de cor muito distintos na imagem resultante. É claro que salvar a imagem final em um formato de imagem de 'depth' de 8 bits 'quantizará' esses valores de cor de volta para 8 bits, mas durante o processamento da imagem na memória, a qualidade intermediária da imagem é preservada. Alguns formatos estão disponíveis que preservam a informação de nível de qualidade mais alta usada pelo IM. Por exemplo, o formato MIFF do IM, o formato TXT de pixels enumerados, bem como os formatos de imagem NetPBM. No entanto, embora uma versão Q8 do IM permita que você gere imagens de profundidade de 16 bits, tal imagem ainda terá apenas informação equivalente à profundidade de 8 bits, pois a qualidade simplesmente não está presente na memória, para ser salva. | _Se o IM ler uma imagem usando valores de 8 bits (muitos formatos de imagem o fazem), a 'profundidade' das imagens será definida como 8 bits, e ao salvar, o IM normalmente salvará a imagem nessa mesma profundidade de valor de 8 bits, mesmo que você processe a imagem usando uma versão Q16 do IM. Você pode substituir essa configuração ou limpar a configuração "[-depth](https://imagemagick.org/command-line-options/#depth)" para aquela imagem, para que o IM a salve na melhor profundidade possível para a imagem corresponder à qualidade em memória do IM.

Observe também que muitos operadores que geram cores extras, como o Redimensionamento de Imagem, também redefinirão a 'profundidade' da imagem na memória para a configuração de qualidade de tempo de compilação, de modo que o IM então tentará salvá-la em uma profundidade maior, se possível.

_
---|---

HDRI - qualidade de ponto flutuante

HDRI, ou Imagem de Alta Faixa Dinâmica, foi originalmente projetada para representar mais naturalmente a capacidade de nossos olhos de ver simultaneamente áreas claras e escuras de uma cena. Em termos práticos de processamento de imagem, ela faz muito mais do que isso. Uma versão HDRI do IM (a compilação padrão) é compilada para usar valores de ponto flutuante para imagens armazenadas na memória, para permitir que você realize um tratamento HDRI mais exato das operações de imagem, de modo a impedir que tais operações 'cortem' as cores da imagem nos extremos. O HDRI usa a mesma faixa de cor que a Configuração de Quality padrão de tempo de compilação para o armazenamento em memória. Ou seja, os valores ainda variam de '0' até a 'Quantum Range', significando do preto ao branco. Mas os valores são salvos usando ponto flutuante ('doubles' em termos de programação C) em vez de inteiros, de modo que os efeitos de 'quantum' do arredondamento de valores para inteiros não serão vistos. Os valores também não são 'cortados' quando vão além da 'Quantum Range' ou para negativos. Basicamente, você perde muito menos informação entre as etapas de processamento. O HDRI é, portanto, vital quando você planeja usar um processamento matemático extremamente pesado de imagens, envolvendo o uso temporário de valores negativos, ou escalonamento forte para valores muito pequenos ou muito grandes. É especialmente importante para usuários que querem fazer pleno uso das capacidades de Transformadas Rápidas de Fourier (FFT), e é aqui que você verá a maioria dos exemplos de uma versão HDRI do IM, nestas páginas. Para informações sobre como compilar uma versão HDRI do IM, veja Habilitando HDRI no ImageMagick no site principal do IM, também para informações específicas do Windows e do Ubuntu Linux, veja Discussão de Anúncio das Transformadas de Fourier nos fóruns de usuários. Um operador importante que deve ser mantido em mente ao usar HDRI é "[-clamp](https://imagemagick.org/command-line-options/#clamp)". Essa opção cortará os valores em uma imagem que caiam fora da faixa normal para imagens. Ou seja, qualquer valor negativo será cortado para zero, e qualquer valor maior que a 'QuantumRange' será definido para esse valor. No entanto, ela NÃO 'arredonda' os valores de ponto flutuante para inteiros.

Efeitos de Quantum, HDRI vs não-HDRI

Arredondamento de Quantum... Por exemplo, aqui uso os operadores Level e Reverse Level para comprimir a faixa de cor de uma imagem de gradiente de modo que ela use apenas os valores de 0 a 15, e então a descomprimo novamente. O gradiente resultante também é exibido como um perfil de imagem (usando o script "[im_profile](../static/img/scripts/im_profile)") para facilitar o acompanhamento. |

  # Using a normal non-HDRI version of IM...
  magick -size 20x600 gradient:  -rotate 90 \
          +level 0,15  -level 0,15  level_rounding.png
  im_profile -s level_rounding.png  level_rounding_pf.gif

Observe o severo arredondamento (efeitos de quantum) que agora é visível, formando degraus no perfil do gradiente. Como apenas 16 valores de nível de cinza foram usados, você efetivamente converteu a imagem para uma profundidade de cor de apenas 4 bits! Observe que esse tipo de problema de Arredondamento de Quantum torna-se muito comum em uma versão IM Q8, apenas fazendo múltiplas tarefas de processamento de imagem, além de um redimensionamento e recorte básicos de imagens. Algo que o IM Q16, mais normal, resolve com seu uso extra de memória. O Arredondamento de Quantum só se torna um problema para o IM Q16 quando você usa um processamento de imagem realmente pesado, como Transformadas Rápidas de Fourier (FFT) ou a mesclagem de imagens contendo tempos de exposição diferentes (intensidade de luz) para gerar Imagens de Alta Faixa Dinâmica. É, afinal, por isso que o HDRI foi adicionado ao ImageMagick em primeiro lugar. Queima e Corte... E aqui 'estico' o gradiente de modo que os valores de cor preto e branco originais vão bem além da "Quantum Range", antes de serem restaurados novamente. |

  # Using a normal non-HDRI version of IM...
  magick -size 20x600 gradient:  -rotate 90 \
          -level 20%  +level 20%    level_clipping.png
  im_profile -s level_clipping.png  level_clipping_pf.gif

Você pode ver que um IM normal perde a informação em ambas as extremidades. Os valores da extremidade inferior são 'queimados' à medida que os valores se tornam negativos, enquanto os valores superiores são 'cortados' à medida que vão além dos limites máximos da 'Quantum Range' dos inteiros usados para armazenar os valores. Resultado da versão HDRI do ImageMagick... Repetir essas duas operações usando uma versão HDRI do ImageMagick não produzirá nenhum dos arredondamentos, queimas ou cortes acima dos resultados, mas terá um custo extra em termos de memória (doubles precisam de mais espaço que inteiros). Em termos de velocidade, não custa muito, e pode até ser mais rápido em muitos dos hardwares de computador modernos de hoje, devido aos aceleradores de ponto flutuante.

  # Using HDRI version of IM...
  magick -size 20x600 gradient:  -rotate 90 \
          +level 0,15  -level 0,15  level_rounding_hdri.png
  magick -size 20x600 gradient:  -rotate 90 \
          -level 20%  +level 20%    level_clipping_hdri.png
  im_profile -s level_rounding_hdri.png  level_rounding_hdri_pf.gif
  im_profile -s level_clipping_hdri.png  level_clipping_hdri_pf.gif

Como você pode ver, o gradiente permanece perfeitamente intacto, mesmo após a compressão ou o esticamento pesado da imagem e de volta.

Clamp para Impor os Limites da Imagem em HDRI

Você pode forçar uma imagem HDRI a ser 'cortada' pela faixa normal de valores de imagem usando "[-clamp](https://imagemagick.org/command-line-options/#clamp)" entre as duas opções de level. Por exemplo... |

  # Using a HDRI version of IM...
  magick -size 20x600 gradient:  -rotate 90 \
          -level 20%    -clamp   +level 20%   level_hdri_clamp.png
  im_profile -s level_hdri_clamp.png  level_hdri_clamp_pf.gif

O uso de "[-clamp](https://imagemagick.org/command-line-options/#clamp)" acima basicamente gerou a mesma imagem que eu teria obtido com uma versão não-HDRI normal do ImageMagick. No entanto, esta imagem não seria exatamente a mesma que um resultado não-HDRI, pois, embora "[-clamp](https://imagemagick.org/command-line-options/#clamp)" queime e corte os valores na imagem, ele não adiciona efeitos de arredondamento de quantum. Assim, os valores só estão sendo arredondados para inteiros durante o salvamento final em um formato de arquivo de imagem não-HDRI. A opção "[-clamp](https://imagemagick.org/command-line-options/#clamp)" pode ser de importância vital ao usar HDRI, para alcançar o resultado que você deseja.

Formatos de Arquivo HDRI

É claro que salvar uma imagem que contém valores muito pequenos, grandes ou negativos em um formato de arquivo de imagem normal também resultará em corte, quantização e até redução de cor, pelas mesmas razões acima. Assim, se você precisar salvar imagens que não foram 'normalizadas' de volta para uma escala de 0 a 'Quantum Range', então precisará usar um dos raros formatos de arquivo de imagem de ponto flutuante. Alguns formatos de imagem que podem lidar com valores de ponto flutuante (sem corte ou arredondamento) incluem o NetPBM PFM. Este é o único formato de arquivo de imagem que não requer nenhuma opção especial extra.
Outros formatos de arquivo de imagem também podem ser usados, mas requerem uma opção especial para especificar que o arquivo deve salvar valores de ponto flutuante. Especificamente, você precisa especificar a opção de codificador "**-define quantum:format=floating-point**" para solicitar valores de ponto flutuante nesses formatos de arquivo. A configuração "-depth" também pode ser usada para definir que tipo de valores de ponto flutuante são usados. Se "-depth 32" ou menos (o padrão na maioria das versões do IM) for usado, então "floats" normais são usados. Mas se "-depth 64" for definido, então "doubles" são usados para os dados de ponto flutuante escritos em, ou lidos de, o formato de arquivo de imagem. Os formatos de arquivo de imagem que podem usar essa flag especial para salvar valores de ponto flutuante incluem... TIFF, FITS e MIFF. O formato de arquivo de dados brutos RGB também salvará (e lerá) ponto flutuante, embora esse formato não salve o tamanho da imagem, e você precise especificar as configurações de ponto flutuante também para a leitura.
Outra opção de codificador especial é "-define quantum:scale=65535.0". Esta será multiplicada com o valor lido do arquivo de imagem, de modo a escalar o valor de um valor de ponto flutuante normalizado de 0.0 a 1.0, para a faixa de valor interna de 0.0 a 65535.0. Então, se você obtiver uma imagem quase preto puro ao ler uma imagem de ponto flutuante, tente adicionar esta opção para escalar os valores sendo lidos para a faixa apropriada.
O formato de arquivo direto de memória-para-disco MPC também salvará valores de ponto flutuante usados por uma versão HDRI do IM, e não precisará de nenhuma flag especial. Mas, como com qualquer arquivo de imagem MPC, apenas a mesma versão exata (compilação específica) do IM na mesma máquina lerá corretamente tal arquivo. Assim, ele só é bom para arquivos temporários de 'leitura rápida' para processamento de imagem programado, e não para armazenamento de longo prazo.

Qual nível Q devo usar

Em resumo, que tipo de ImageMagick devo usar? Q8, Q16, HDRI? Q8 tem uma pegada de memória menor, pois os valores de imagem são salvos na memória como valores de 8 bits, assim como a maioria dos formatos de arquivo de imagem. Para composição básica, conversão de formato de imagem, 'redimensionamento único' simples, ou desenho em imagens, então o Q8 é 'bom o suficiente'. Q16 dobra a pegada de memória, pois os valores de cor são salvos em valores de 16 bits (maior precisão). Mas se você planeja fazer um processamento de imagem pesado envolvendo muitos níveis de operações, como 'mudança de espaço de cor (mesmo apenas sRGB de/para RGB), redimensionamento, distorções, desfoque, sombras, etc., tudo na mesma imagem, no mesmo comando (o que é recomendado pela mesma razão), então ter 16 bits é melhor, pois preservará a menor precisão das imagens entre as etapas de processamento. Você também pode, então, salvar em formatos de arquivo de 16 bits (PNG, MIFF, PbmPlus) entre comandos, mesmo que o salvamento final seja de volta para um formato de arquivo de imagem de 8 bits como ICO e JPEG. (Este é o padrão por essa razão) O próximo nível é o Q16 HDRI, que leva a precisão a valores de ponto flutuante de 32 bits, o que permite que você lide com valores de imagem que se tornam muito pequenos ou muito grandes sem os efeitos de arredondamento e corte das imagens. Você pode até lidar com valores negativos, especialmente em alguns espaços de cor. Essencialmente, ele é usado para impedir a perda de dados de imagem ao processar imagens em extremos, como ao usar imagens HDRI, Transformadas de Fourier, ou apenas altos níveis de compressão, expansão que você pode obter no processamento matemático de dados brutos. É isso, em poucas palavras. O Q16 é um bom meio-termo para a maioria das operações envolvendo distorções e composições de múltiplas imagens e efeitos de processamento de imagem. Q8 se a memória estiver apertada, mas você estiver fazendo apenas operações simples, HDRI se você estiver fazendo operações extremas.

Densidade ou Resolução da Imagem

A Density de uma imagem é a resolução espacial (de espaço) da imagem. Ou seja, a densidade (geralmente expressa como dpi, ou pontos por polegada) de uma imagem define o quão distantes (ou quão grandes) estão os pixels individuais, e assim o tamanho geral da imagem em termos do mundo real, e geralmente é usada para a exibição ou impressão da imagem em um dispositivo do mundo real. É apenas algum número armazenado com a imagem para dizer aos dispositivos de saída, como impressoras e displays, quantos pontos (ou pixels) por polegada a imagem deve ser exibida, OU, para formatos vetoriais como postscript, PDF, MWF e SVG, a escala de pixel para desenhar usando quaisquer coordenadas do mundo real que possam ser usadas dentro da imagem. É completamente irrelevante para o tamanho de pixel real das imagens, ou para a Quality em memória e o Depth do formato de arquivo de salvamento, que define a 'resolução' de cor da imagem. Você pode definir a resolução ou densidade de uma imagem à medida que ela está sendo lida pelo IM usando a função "[-density](https://imagemagick.org/command-line-options/#density)", antes de ler ou escrever a imagem, ou usando "[-set](https://imagemagick.org/command-line-options/#set) density" após ler a imagem. Uma configuração "[-units](https://imagemagick.org/command-line-options/#units)" pode ser usada para definir se o número de densidade é expresso nos termos padrão (de impressão tradicional) de 'PixelsPerInch' ou em unidades métricas mais modernas de 'PixelsPerCentimeter' (o PNG usa o último). Por exemplo, uma imagem de 200x200 pixels a 600 dpi será, portanto, exibida em um quadrado de 1/3 de polegada em termos do mundo real. Por outro lado, uma imagem muito menor de 72x72 pixels a 72 dpi será exibida em um quadrado de 1 polegada, no mundo real, embora sua qualidade espacial não seja muito boa em comparação. A primeira sendo 'qualidade de foto', enquanto a última sendo 'resolução de display'. Em termos práticos, uma imagem de 72dpi parecerá 'digital' ou 'pontilhada' em uma impressora. Por outro lado, uma grande foto digital moderna tirada a uma imagem de 1200dpi provavelmente precisaria ser reamostrada para exibi-la em um display, ou você pode ver apenas uma pequena parte da imagem. Para mais informações sobre Resolução e Densidade de imagens, veja as notas sobre o Operador de Redimensionamento Resample. Para informações sobre Resolução e Densidade para Texto e Fontes, veja Pointsize e Tamanho Real da Fonte.

Photoshop e Densidade

O editor de imagem "Photoshop" salva uma cópia extra da resolução das imagens em um perfil separado (chamado '8BIM') na imagem, no qual o IM NÃO tocará. Assim, se você alterar a resolução de uma imagem com o IM, provavelmente também deve remover os perfis da imagem antes de carregá-la de volta no "photoshop", ou você pode não ver nenhuma mudança de densidade. Você pode remover apenas esse perfil de uma imagem usando "+profile 8bim". A partir de uma Discussão do Fórum do IM, Jesper Nilsson (também conhecido como stroker) sugere que você use o programa "[exiftool](http://www.sno.phy.queensu.ca/~phil/exiftool/)' para modificar diretamente as Tags do Photoshop da imagem. Por exemplo

  exiftool -g -Photoshop:XResolution=300 -Photoshop:YResolution=300 file.tif

Testes de Velocidade Baseados na Quality

Alguns testes de velocidade foram submetidos ao Fórum do IM, velocidade Q8 vs. Q16 (& HDRI). Resultados aproximados do artigo acima

• A quantidade de memória usada por pixel por canal é como você esperaria. Q8 - 1 byte, Q16 - 2 bytes, Q32 & qualquer HDRI - 4 bytes, Q64 (HDRI) - 8 bytes.
• 64 bits tem melhorias de precisão significativas para operações de ponto flutuante, mas o mesmo ocorre com qualquer outra versão HDRI do ImageMagick.
• Em termos de velocidade, Q8, Q16 e HDRI têm todos aproximadamente a mesma velocidade (presumindo que o computador tenha uma MPU de ponto flutuante), Q32 cerca de 25% mais lento, e Q64 (HDRI) cerca de 50% mais lento.

| Observe que o Q64 usa automaticamente "double long floats", em vez de inteiros de 64 bits. É uma espécie de HDRI de precisão dupla, mas, embora muito preciso, é o mais lento de todas as configurações de qualidade em memória, e o mais intensivo em memória.
---|---
| _A velocidade real dependerá das especificações do seu computador, e de você ter ou não um Coprocessador Matemático. Se não for importante, usar o Q16 padrão, ou o HDRI padrão, é provavelmente melhor.

Se for importante, então você deve fazer testes similares de velocidade, no seu equipamento, mas usando as operações que você tipicamente espera usar no seu processamento de imagem.

_
---|---

Controles Especiais do ImageMagick

O IM também tem algumas opções especiais que ele usa para controlar seu funcionamento operacional, o relatório de informações e para fins de depuração. -version | Gera qual versão do IM, a qualidade de imagem que ele está usando, e quando foi compilado. O IM sairá implicitamente após gerar essa informação. | | No IMv7, "[-version](https://imagemagick.org/command-line-options/#version)" sairá se for a ÚNICA opção na linha de comando. Ou seja, tornará o argumento final de 'escrita implícita' opcional. Se quaisquer outros argumentos estiverem presentes, OU se foi lido de um script (arquivo ou pipeline), o comando magick não sairá, mas continuará.
---|---
-list | Esta é uma opção apenas informativa e listará os itens solicitados, e então sairá. Ou seja, você não pode usá-la com nenhuma outra opção, ou processamento de imagem. Ela é puramente fornecida para fins informativos, especialmente em scripts, para verificar as opções de entrada e se o IM tem certas opções implementadas. O argumento fornecido define qual informação você deseja listar. Por exemplo, uma lista de nomes de 'color' que você pode usar, (como usados por ("[-fill](https://imagemagick.org/command-line-options/#fill)", "[-background](https://imagemagick.org/command-line-options/#background)", "[-mattecolor](https://imagemagick.org/command-line-options/#mattecolor)", "[-bordercolor](https://imagemagick.org/command-line-options/#bordercolor)"). Enquanto 'font' lista as fontes que são especificamente conhecidas pelo IM. Aqui estão apenas algumas das listas mais interessantes... | list | quais listas o "[-list](https://imagemagick.org/command-line-options/#list)" pode listar!
---|---
font | Fontes conhecidas (o IM também conhece fontes X e PS)
type | tipos de imagem de arquivo ("[-type](https://imagemagick.org/command-line-options/#type)" )(após o IM v6.3.5-7)
ou a lista de fontes (antes dessa versão do IM)
color | nomes de cores conhecidos para várias opções de cor.
dispose | todas as configurações de descarte GIF ("[-dispose](https://imagemagick.org/command-line-options/#dispose)")
compose | composições alfa que estão disponíveis (inclui métodos internos)
layers | quais métodos de múltiplas imagens "[-layers](https://imagemagick.org/command-line-options/#layers)" foram implementados
distort | Os métodos de distorção de imagem disponíveis.
morphology | Os métodos morfológicos de imagem disponíveis.
kernel | Os kernels morfológicos/de convolução que estão disponíveis.
command | quais opções de linha de comando (tanto configurações quanto operadores) estão disponíveis
configure | quais foram os parâmetros de configuração usados para compilar o ImageMagick
Essa última configuração de 'list', 'Configure', é muito importante, pois lhe dirá quais bibliotecas e delegados estavam disponíveis quando o IM foi compilado. Ela também inclui o número de lançamento 'point', que estava faltando na saída normal de "[-version](https://imagemagick.org/command-line-options/#version)" de versões mais antigas. (Veja Tratamento de Versão em Scripts para um exemplo de uso dessa informação. O IM sairá implicitamente após gerar essa informação. | No IMv7, "[-list](https://imagemagick.org/command-line-options/#list)" sairá se for a ÚNICA opção na linha de comando. Ou seja, tornará o argumento final de 'escrita implícita' opcional. Se quaisquer outros argumentos estiverem presentes, OU se foi lido de um script (arquivo ou pipeline), o comando magick não sairá, mas continuará.
---|---
-verbose | Relata informações extras sobre algumas das operações mais complexas.
Por exemplo, "[-segment](https://imagemagick.org/command-line-options/#segment)", que gera muitos detalhes de quantização de cor.
E "[-distort](https://imagemagick.org/command-line-options/#distort)", gerando informações extras e equivalentes 'FX' da distorção de imagem solicitada. Também monitora o número de mudanças ao iterar uma operação "[-morphology](https://imagemagick.org/command-line-options/#morphology)". Isso é especialmente útil para gerar informações de imagem mais detalhadas a partir das saídas "[info:](files.html#info)" e "[-identify](https://imagemagick.org/command-line-options/#identify)". Você pode desligar a configuração usando a forma 'mais' da opção, "[+verbose](https://imagemagick.org/command-line-options/#verbose)".
-regard
-warnings | O '-regard-warnings' tornará fatais alguns avisos informativos sobre alguns formatos de arquivo de imagem. Ele também faz com que o IM retorne um status de saída adequado de acordo com tais condições de erro. Pode ser usado em scripts para 'sanitizar' arquivos de imagem fornecidos por fontes não controladas. Ou seja, esta opção fará o IM falhar e sair, se a imagem JPEG ou TIFF não estiver correta, completa, ou contiver perfis 'desconhecidos'.
-precision {number} | Controla o número de dígitos significativos.
Quando o IM gera valores de ponto flutuante em resposta a várias solicitações de depuração, verbose ou formatação, esta configuração define o quão preciso você quer essa saída. Por padrão, ela limitará tais números a 6 dígitos significativos, mas este operador aumentará ou diminuirá esse padrão. A configuração padrão de 6 também pode ser modificada usando a variável de ambiente 'MAGICK_PRECISION'. Ela afeta a saída de...

• O comando verbose "[identify](#identify)" ou as configurações "[-identify](https://imagemagick.org/command-line-options/#identify)", "[-print](https://imagemagick.org/command-line-options/#print)" e "[-format](https://imagemagick.org/command-line-options/#format)".
• A saída 'debug()' de um operador "[-fx](https://imagemagick.org/command-line-options/#fx)" e o escape de string '%[fx:...]'. (Veja FX, Operador de Processamento de Imagem DIY
• Os valores de ponto flutuante de um kernel "[-morphology](https://imagemagick.org/command-line-options/#morphology)" quando "-set option:showkernel 1" tiver sido habilitado. Veja Exibindo o Kernel.

-quiet | Não relata mensagens de aviso informativas. Apenas erros adequados, como erros de E/S, ou opções inválidas, etc. Isso é especialmente útil para "[-crop](https://imagemagick.org/command-line-options/#crop)" ou "[-trim](https://imagemagick.org/command-line-options/#trim)" e "[-layers](https://imagemagick.org/command-line-options/#layers) optimize", que normalmente relatam avisos de 'missed images', quando o operador não produziria nenhuma imagem 'real' como resultado. Isso também silenciará os codificadores de alguns formatos de arquivo de imagem complexos que podem conter 'unknown chunks', que o IM normalmente ignoraria. Por exemplo, quando o IM está lendo imagens TIFF, ou formatos de vídeo MPEG (AVI) estranhos.
-respect
-parenthesis | Faz com que os parênteses não apenas salvem e restaurem a lista de imagens atual, mas também todas as configurações operacionais atuais sejam salvas e restauradas. Isso significa que, quando fornecido, quaisquer configurações definidas dentro dos parênteses serão redefinidas quando os parênteses terminarem. Veja os exemplos em Parênteses e Configurações acima.
-ping | Para o comando "identify". O IM tentará evitar ler e decodificar completamente o formato de arquivo de imagem completo para informações básicas, como o tamanho das imagens.
-monitor | Relata uma porcentagem do processamento durante cada estágio do processamento de imagem, especialmente para tarefas de processamento de imagem muito grandes ou longas. Em uma API de nível inferior, você usaria SetImageInfoProgressMonitor() ou SetImageProgressMonitor()
-debug | Relata de forma verbosa exatamente o que o IM está fazendo, em várias áreas. O argumento é uma lista de opções separadas por vírgula, como... | exception | O que o IM não está entendendo sobre o comando
---|---
cache | Veja quanto espaço em disco o IM está colocando em cache
configure | Mostra as tentativas de busca do IM para encontrar seus arquivos de configuração.
trace | Relata os pontos de rastreamento no início de cada função de biblioteca
annotate | Relata as métricas de fonte quando uma fonte é usada com "[-annotate](https://imagemagick.org/command-line-options/#annotate)".
command | IMv7 -- mostra as opções de linha de comando (ou script) à medida que estão sendo processadas. Ex: processamento de opções.
all | Mostra cada ponto de rastreamento durante o processamento
Isso é muito, muito, MUITO verboso e não recomendado
Se "[-debug](https://imagemagick.org/command-line-options/#debug)" for usado, a localização da saída de log é controlada pelo arquivo "log.xml". Por padrão, isso é definido como "console". Para fazê-lo salvar em um arquivo, altere <log output="console"/> para <log output="file"/> Para uso na linha de comando e em API, você também pode definir uma variável de ambiente para definir o nível de depuração usando ações pelo IM.

  export MAGICK_DEBUG=all

Limiting image size (quick note)

To prevent excess memory usage, set your memory limit to say 16GB. Now set
the disk limit to 4GB. ImageMagick will exit if the disk limit is exceeded,
with a "cache resource exhausted" exception.