ImageMagick Usage Examples (Unofficial Translation)
⚠️ Este é um site de tradução não oficial, sem relação com a ImageMagick Studio LLC. Para informações oficiais, consulte a página original (https://usage.imagemagick.org/anim_basics/index.html).

Exemplos do ImageMagick -- Fundamentos de Animação

Prefácio e Índice dos Exemplos do ImageMagick
Animações GIF e Metadados de Animação
Métodos de Supressão de Quadros

Animações GIF e Metadados de Animação

A forma padrão como o ImageMagick trata a saída de uma lista de imagens é gerar uma imagem de múltiplas páginas. No formato de imagem GIF, porém, isso assume a forma especial de uma 'animação GIF'. | 

  magick -delay 100  -size 100x100 xc:SkyBlue \
          -page +5+10  balloon.gif   -page +35+30 medical.gif  \
          -page +62+50 present.gif   -page +10+55 shading.gif  \
          -loop 0  animation.gif

[IM Output]
Aqui está um exemplo de 'brilho' mais avançado que usa um script de shell "[star_field](../static/img/scripts/star_field) ". Esse script foi desenvolvido a partir dos meus experimentos gerando campos de estrelas aleatórios. | 

  star_field 70x46  stars1.gif
  star_field 70x46  stars2.gif
  star_field 70x46  stars3.gif
  magick rose:  -compose Screen \
          \( -clone 0 stars1.gif -composite \) \
          \( -clone 0 stars2.gif -composite \) \
          \( -clone 0 stars3.gif -composite \) \
          -delete 0 -set delay 25 -layers Optimize rose_sparkle.gif
  rm stars[123].gif

[IM Output]
Basicamente, três campos de estrelas aleatórios são gerados, no tamanho certo, e depois sobrepostos à nossa imagem, o "rose:" embutido do IM, usando uma composição alfa '[Screen](compose.html#screen)' para clarear a imagem com os padrões de estrelas informados. O conjunto inteiro é então passado pelo otimizador geral de animação GIF do IM. O exemplo acima pode parecer complexo, pois usa alguns recursos avançados do IM que ainda não apresentei, mas o resultado é uma animação de três quadros relativamente simples, porém bem otimizada. Você também pode ver algumas das animações mais complexas que foram criadas usando scripts de shell simples em Animações de Distorção. Há algumas configurações extras do IM que foram criadas especificamente para uso em animações GIF, e conhecê-las é o primeiro passo para o mundo das animações GIF… [**-dispose**](https://imagemagick.org/command-line-options/#dispose) {method}

| O que as imagens seguintes devem fazer com os resultados anteriores da animação GIF. As opções válidas são 'Undefined', '[None](#none)', '[Previous](#previous)', e '[Background](#background). (Veja abaixo a explicação das configurações)
[**-loop**](https://imagemagick.org/command-line-options/#loop) {number} | Número de vezes que a animação GIF deve percorrer a sequência de imagens antes de parar. É uma configuração de saída de 'gravação de imagem', portanto pode ser definida em qualquer ponto da linha de comando, embora apenas a última definição desse tipo seja usada. Normalmente ela é definida por padrão como zero (laço infinito); no entanto, se qualquer imagem lida tiver um valor diferente, essa configuração assumirá o valor daquela imagem. Por isso, recomendo que você sempre defina "[-loop](https://imagemagick.org/command-line-options/#loop)" ao criar uma animação GIF, depois que todas as imagens tiverem sido lidas. Para mais informações, veja O Fim do Laço abaixo.
[**-delay**](https://imagemagick.org/command-line-options/#delay) {time} | Define o atraso de tempo (em 1/100 de segundo) para pausar após desenhar as imagens que forem lidas ou criadas depois que essa configuração for definida. Você pode especificar uma escala diferente para o atraso de tempo indicando uma escala 'x' (dada em ticks por segundo). Por exemplo, '10x1' são 10 ticks de 1 segundo, enquanto '10x100' são 10 ticks de um centésimo de segundo. Basicamente, o 'x' equivale a um sinal de fração '/'. Por exemplo, especificar '1x160' definirá um atraso apropriado para 160 quadros por segundo. | | Os atrasos de animação GIF precisam ser especificados em centésimos de segundo para funcionar corretamente, e é por isso que essa é a unidade de tempo padrão. O fator 'x' é usado mais para gerar outros formatos mais parecidos com vídeo, como MNG e AVI.
---|---
[**-set**](https://imagemagick.org/command-line-options/#set) dispose {method} [**-set**](https://imagemagick.org/command-line-options/#set) delay {time}
| Enquanto as configurações de opção anteriores definem atributos de imagem em imagens recém-criadas ou lidas depois que aquela opção é dada, a opção "[-set](https://imagemagick.org/command-line-options/#set)" é um operador que permite definir atributos de imagem em todas as imagens que já estão na sequência de imagens atual. Isso permite alterar a configuração ao longo de toda uma animação, ou apenas de um único quadro, depois que as imagens foram carregadas ou modificadas.
[**-page**](https://imagemagick.org/command-line-options/#page) {w}x{h}+{x}+{y}
| Isto permite definir a posição de deslocamento da imagem que está prestes a ser lida. Como esta é uma opção de configuração, ela só se aplica à geometria que você fornece às imagens que seguem a configuração. Não afeta as imagens já lidas na memória. Se não for fornecida, ou for desativada com "[+page](https://imagemagick.org/command-line-options/#page)", o deslocamento da imagem lida será preservado. Se a imagem não tiver deslocamento, ela será posicionada em '+0+0', ou seja, no canto superior esquerdo da tela de trabalho ou 'página'. Também pode ser usada para definir uma tela de trabalho maior, especificando uma largura 'x' altura. Apenas a configuração de largura e altura de página da primeira imagem da sequência será usada para definir o tamanho geral da tela da animação GIF; todas as outras configurações de tamanho de página serão ignoradas quando a animação for finalmente gravada. Quando uma animação GIF é lida, o tamanho da tela é definido em todos os quadros da animação. As animações MNG podem salvar deslocamentos de quadro, mas não salvam tamanhos de tela. O tamanho da primeira imagem define o tamanho da tela de toda a animação. | | _O formato de imagem GIF não pode especificar um deslocamento negativo para imagens em uma tela. Se você tentar usar um deslocamento negativo, o IM o redefinirá como zero quando aquela imagem (ou quadro de animação) for gravada em um arquivo GIF.

Deslocamentos positivos maiores que a tela da imagem são perfeitamente aceitáveis, mas podem fazer com que a imagem não apareça na área de desenho da tela quando exibida. Como um programa de exibição de animação GIF trata isso é indefinido. Recomenda-se cautela._
---|---
[**-repage**](https://imagemagick.org/command-line-options/#repage) {w}x{h}+{x}+{y}
| Isto é exatamente como "[-page](https://imagemagick.org/command-line-options/#page)", exceto que é um operador de imagem em vez de uma configuração. Isso significa que você pode usá-lo para alterar ou redefinir a 'geometria de página' de uma imagem ou quadro de animação que já foi lido na memória. A forma mais simples "[+repage](https://imagemagick.org/command-line-options/#repage)" apenas redefine a 'geometria de página' de todas as imagens para o deslocamento zero e o tamanho real da imagem em cada quadro da sequência de imagens atual. Essa operação é vital quando você está extraindo os quadros individuais de uma animação (veja os Exemplos de Adjoin abaixo). No entanto, "[+repage](https://imagemagick.org/command-line-options/#repage)" destruirá muitas informações de posicionamento armazenadas em cada imagem; por isso, você provavelmente também deve extrair essas informações para um arquivo separado para reutilização posterior. Veja Informações da Lista de Animação abaixo.

Ponto Importante

NÃO salve diretamente em GIF as animações intermediárias cujo processamento você ainda não terminou. Você pode usar o formato interno MIFF do IM como formato de arquivo temporário, caso queira trabalhar em uma animação em uma série de passos de processamento separados. Repito…

Não use GIF como formato de arquivo intermediário; use MIFF em vez disso

Se você cometesse o grande erro de salvar em GIF, apenas teria piorado a animação resultante, pois o IM teria realizado uma Quantização de Cores automática para reduzir o número de cores presentes. Não só isso, mas o fez em cada quadro de forma completamente independente de todos os outros quadros, tornando qualquer processamento posterior, em especial qualquer otimização de GIF, muito mais difícil. Resolver isso é um problema complexo e de vários níveis, examinado na próxima seção, Otimização de Animação.

Métodos de Supressão de Quadros

A primeira coisa com que as pessoas que criam animações GIF têm dificuldade é a configuração "[-dispose](https://imagemagick.org/command-line-options/#dispose)". Isso não surpreende, pois é uma configuração complexa. Pior ainda, muitos programas de animação, incluindo muitos navegadores web, nem sempre tratam corretamente a configuração de metadados de supressão do GIF. No entanto, usar a supressão certa pode fazer uma grande diferença em quão bem sua animação funciona e é otimizada. A primeira coisa a lembrar no ImageMagick é que quase todas as opções especiais de animação são configurações de leitura de imagem. Ou seja, elas são aplicadas às imagens lidas depois que a configuração é dada. A configuração "[-loop](https://imagemagick.org/command-line-options/#loop)" é a única normalmente usada depois que a animação foi concluída, logo antes de a animação ser salva. A tarefa básica de "[-dispose](https://imagemagick.org/command-line-options/#dispose)" define como uma imagem deve ser removida, depois de ter sido exibida por seu período de tempo "[-delay](https://imagemagick.org/command-line-options/#delay)". Ou seja, você precisa fornecer as configurações "[-dispose](https://imagemagick.org/command-line-options/#dispose)" e "[-delay](https://imagemagick.org/command-line-options/#delay)" de uma imagem antes de ler a imagem daquele quadro. Mas a ação é aplicada depois que aquela imagem é exibida. Isso é um pouco contraintuitivo, mas faz sentido pela maneira como o IM opera sobre as imagens. Se você lembrar disso, não deverá ter problemas. As formas 'mais' dessas opções, como a maioria das outras configurações no IM, impedem que a configuração seja aplicada a quaisquer imagens que estejam sendo lidas. Isso significa que, se você não especificar uma configuração, a imagem do quadro continuará a usar a configuração que foi lida com a imagem (se houver). Isso pode ser importante mais tarde, quando você quiser ler uma animação GIF para processamento posterior. Ou ao mesclar uma animação GIF em outra (a técnica de animação mais difícil).

Dispose None - cada quadro sobreposto em sequência

A configuração "[-dispose](https://imagemagick.org/command-line-options/#dispose)" padrão para animações GIF é '**Undefined**', que a maioria dos programas de animação trata da mesma forma que uma configuração de supressão '**None**'. Basicamente, isso diz ao computador para simplesmente deixar o que quer que seja sobreposto por este quadro específico. Ou, mais precisamente, 'não fazer nada'. Observe, porém, que toda a tela é sempre limpa ao final da sequência de animação, antes de ela repetir em laço. Aqui, por exemplo, está uma animação padrão de 'supressão None'… | 

  magick -delay 100 -dispose None \
              -page 100x100+5+10  balloon.gif  \
              -page +35+30 medical.gif  \
              -page +62+50 present.gif  \
              -page +10+55 shading.gif  \
          -loop 0  anim_none.gif

[IM Output]
Esta técnica de supressão é ideal para animações que não envolvem nenhuma forma de transparência, como animações desenhadas sobre um fundo sólido ou com padrão. | 

  magick -dispose none  -delay 100 \
                -size 100x100 xc:SkyBlue +antialias \
                -fill DodgerBlue -draw 'circle 50,50 15,25' \
                -page +5+10  balloon.gif  \
                -page +35+30 medical.gif  \
                -page +62+50 present.gif  \
                -page +10+55 shading.gif  \
          -loop 0  canvas_none.gif

[IM Output]
Observe que esta técnica só pode adicionar cores visíveis a uma animação. Ela nunca pode, de fato, tornar qualquer parte de uma animação transparente novamente. (Veja Animações de Sobreposição abaixo). Para também lidar com a transparência, é preciso usar um dos outros tipos de métodos de supressão.

Dispose Previous - preserva a tela de fundo

O método de supressão '**Previous**' é relativamente simples. Quando a imagem atual termina, retorna a tela ao aspecto que tinha antes de a imagem ser sobreposta. Se a imagem do quadro anterior também usou um método de supressão 'Previous', o resultado será o mesmo que era antes daquele quadro… etc… etc… etc… Por exemplo, nesta animação, cada um dos quadros posteriores retornará ao primeiro quadro da imagem, que tem uma configuração de supressão '[None](#none)', antes de sobrepor a imagem associada àquele quadro. O resultado é uma tela de fundo que tem apenas a imagem de cada quadro sobreposta somente pela duração daquela imagem… | 

  magick -dispose none  -delay 0 \
                -size 100x100 xc:SkyBlue +antialias \
                -fill DodgerBlue -draw 'circle 50,50 15,25' \
          -dispose previous -delay 100 \
                -page +5+10  balloon.gif  \
                -page +35+30 medical.gif  \
                -page +62+50 present.gif  \
                -page +10+55 shading.gif  \
          -loop 0  canvas_prev.gif

[IM Output]
Observe o método "[-dispose](https://imagemagick.org/command-line-options/#dispose)" '[None](#none)' usado na primeira imagem. Isso é importante; do contrário, o quadro 'previous' voltaria até a tela vazia original que existia antes do primeiro quadro. Observe também que usei um "[-delay](https://imagemagick.org/command-line-options/#delay)" de '0' na animação acima. Isso diz para não esperar antes de sobrepor o primeiro quadro sobre esta 'tela de fundo'. Sem isso, você veria um breve atraso, exibindo apenas a imagem da tela sem nada por cima. É claro que ainda preciso definir um "[-delay](https://imagemagick.org/command-line-options/#delay)" mais longo para as imagens posteriores; caso contrário, elas apareceriam e desapareceriam num piscar de olhos e, de passagem, consumiriam muitos ciclos de CPU do espectador. O uso do método de supressão 'Previous' pode estar sujeito a uma leve cintilação ou pausa em alguns navegadores web, especialmente em máquinas mais lentas. Embora isso seja bastante raro hoje em dia, a cintilação em si ainda está presente e é algo que considero um bug. Veja Quadros com Atraso Zero abaixo para mais detalhes. Poucas animações fazem uso de um estilo de animação com supressão previous; a razão é que é muito difícil para os computadores otimizá-lo. O problema é: qual quadro o computador deve escolher para se tornar a imagem de fundo? É simples para nós, humanos, descobrir a melhor imagem a usar, mas difícil para um computador decidir. A melhor imagem de fundo a usar em uma animação pode nem sequer estar destinada a ser exibida, como no exemplo atual, e por isso pode não existir em uma versão não otimizada daquela animação.

Dispose Background - limpa até o fundo

Embora os dois primeiros métodos "[-dispose](https://imagemagick.org/command-line-options/#dispose)" sejam relativamente simples, o '**Background**' é provavelmente o mais difícil de entender. Quando o atraso de tempo de um determinado quadro termina, a área que foi sobreposta por aquele quadro é limpa. Não a tela inteira, apenas a área que foi sobreposta. Feito isso, a tela resultante é o que passa para o próximo quadro da animação, para ser sobreposto pela imagem daquele quadro. Aqui, por exemplo, apenas substituímos cada quadro pelo quadro seguinte. | 

  magick -delay 100 -dispose Background \
              -page 100x100+5+10  balloon.gif  \
              -page +35+30 medical.gif  \
              -page +62+50 present.gif  \
              -page +10+55 shading.gif  \
          -loop 0  anim_bgnd.gif

[IM Output]
Para que você possa ver exatamente o que está acontecendo, vamos adicionar uma imagem de tela inicial à animação, para que você veja como um 'Background' de fato 'suprime' aquele quadro da exibição da animação. | 

  magick -delay 100 -dispose none \
                -size 100x100 xc:SkyBlue +antialias \
                -fill DodgerBlue -draw 'circle 50,50 15,25' \
          -dispose background \
                -page +5+10  balloon.gif  \
                -page +35+30 medical.gif  \
                -page +62+50 present.gif  \
                -page +10+55 shading.gif  \
          -loop 0  canvas_bgnd.gif

[IM Output]
Como você pode ver, à medida que cada quadro sobreposto é suprimido, a área daquele quadro é limpa para transparência, antes de a próxima imagem ser sobreposta. É esta a importância deste método de supressão do GIF, pois é a única forma de as animações GIF limparem qualquer pixel independentemente do histórico de quadros de uma animação. A única outra forma de limpar pixels é usar '[Previous](#previous)' para voltar a um quadro em que aqueles pixels estavam limpos. Mas isso depende de conhecer o histórico da sequência de animação, o que torna muito mais difícil para os computadores otimizar. | _Há quem pense que, em vez de limpar a área sobreposta para a cor transparente, esta supressão deveria limpá-la para a configuração de metadados de cor de 'fundo' armazenada na animação GIF. De fato, o antigo navegador "Netscape" (versões 2 e 3) fazia exatamente isso. Mas então ele também não implementava corretamente o método de supressão 'Previous'.

Por outro lado, a tela inicial também deveria ser definida a partir da cor de 'fundo' do formato, e isso também não é feito. No entanto, todos os navegadores web modernos limpam apenas a área que foi sobreposta por último para transparência; por isso, esta é agora a prática aceita, e o que o IM agora segue._
---|---
| _Antes da versão 6.2.6-1 do IM, as operações "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" e "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)" do IM não tratavam animações que usavam supressão 'Background' para tornar pixels transparentes, como fazem todos os principais navegadores web. Veja Bugs de Animação para exemplos e detalhes.

Essas funções, no entanto, funcionavam bem quando nenhuma limpeza de pixel era aplicada ou pretendida. Isso agora foi corrigido para "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)", e o método "[-layers](https://imagemagick.org/command-line-options/#layers) [OptimizeFrame](anim_opt.html#optframe)' foi criado para substituir o uso de "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)" como função de otimização de quadros de animação GIF._
---|---

Estudando Animações

Antes de podermos continuar com os fundamentos da animação GIF, seus tipos, otimizações e técnicas de tratamento, precisamos de algumas técnicas para estudar animações existentes.

Identify - informações sobre uma animação

Ora, uma animação consiste em muitas informações compactadas em cada quadro individual. Você pode ver parte dessas informações usando o comando "[identify](basics.html#identify)" padrão do IM. 

  magick identify canvas_prev.gif

[IM Text]

| Se você não viu uma saída como a acima, seu IM está um pouco antigo, e você realmente deveria atualizar sua versão instalada do ImageMagick para a mais recente. Se não o fizer, estará perdendo muitos dos novos avanços no tratamento e controle das animações GIF pelo IM.
---|---
Como você pode ver, a imagem real salva para o segundo quadro e os posteriores tem apenas 32x32 pixels, mas todos os quadros ficam sobre uma 'tela virtual' de 100x100 pixels, com um 'deslocamento virtual' nessa tela maior. Para ver mais dos vários fragmentos de metadados presentes, você precisa usar alguns dos Formatos de Escape por Porcentagem mais especializados para fazer o IM produzi-los. 

  magick identify -format "%f canvas=%Wx%H size=%wx%h offset=%X%Y %D %Tcs\n" \
           canvas_prev.gif

[IM Text]

O que mostra claramente não só o tamanho da tela, o tamanho da imagem e o deslocamento, mas também a supressão e os atrasos de tempo usados para cada quadro individual. Observe como o primeiro quadro tem a supressão e o atraso de tempo diferentes que foram necessários para o uso adequado do método de supressão 'Previous' posterior.

Adjoin - dividir uma animação em quadros

Ora, como você viu acima, o ImageMagick, por padrão, tentará salvar várias imagens em um único arquivo se o formato de arquivo permitir. No entanto, como discutido em Escrever uma Lista de Múltiplas Imagens, o IM permite usar a configuração "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)" para instruí-lo a salvar cada imagem em disco como uma imagem individual separada. Por exemplo, aqui lemos uma das animações GIF e produzimos as imagens de quadro individuais na sequência de animação. 

  magick canvas_prev.gif -scene 1 +adjoin  frame_%03d.gif

[IM Output] [IM Output] [IM Output] [IM Output] [IM Output]

Se você examinasse as imagens reais acima, descobriria que, embora a maioria dos navegadores web mostre uma área maior de 100x100, na qual cada subquadro aparece. Na verdade, a maioria das imagens reais exibidas tem realmente apenas 32x32 pixels, tal como mostrado nos comandos 'identify' anteriores acima. Ou seja, a maior parte da área é apenas uma tela na qual nada é desenhado, conhecida como a 'geometria de página' da imagem ou 'tela virtual'. A primeira imagem da animação define essa 'tela' maior, e todos os outros quadros definem uma posição de 'deslocamento' nessa tela maior. Essa informação extra é preservada nos quadros salvos pela configuração "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)". Assim, você pode reconstruir facilmente a animação GIF. Não só a informação de página é preservada em cada imagem de quadro separada, mas também qualquer configuração de atraso, laço e supressão GIF é preservada. Isso significa que, para reconstruir a animação, basta ler todas as imagens. | 

  magick frame_???.gif  anim_rebuilt.gif

[IM Output]
Às vezes, porém, você não quer preservar essa informação de geometria de página. Por exemplo, se quiser usar os quadros individuais para outros projetos. Você pode redefinir o tamanho e o deslocamento da página usando a opção "[+repage](https://imagemagick.org/command-line-options/#repage)", para remover a informação de 'tela virtual', deixando apenas a imagem real.
Normalmente, ao extrair as subimagens de uma animação, você também costuma redefinir as configurações de atraso e supressão das imagens, para garantir que elas não interfiram na edição e na exibição. Por exemplo, aqui removo a tela virtual e o deslocamento indesejados e redefino os atrasos de temporização e as supressões. 

  magick canvas_prev.gif  +repage  -set delay 0   -set dispose None \
          +adjoin  repage_%03d.gif

[IM Output] [IM Output] [IM Output] [IM Output] [IM Output]

É claro que, se você descartar esses metadados, precisa de alguma forma de registrar e editar esses dados. Veja Informações da Lista de Animação (abaixo) para um script que extrai as subimagens e salva os metadados da animação, em um formato que pode ser usado para reconstruir a animação.

Coalesce - preencher os quadros por completo

Ver uma animação na forma de subquadros, porém, geralmente não é muito útil em uma animação típica. Por um lado, uma animação altamente otimizada pode consistir em muitas partes bem pequenas, sem nenhuma indicação visual de como elas se encaixam. Ela também pode ter muito outro 'ruído' adicionado para a Otimização de Compressão, a fim de reduzir o tamanho total do arquivo da animação. Por exemplo, é muito difícil descobrir o que esta animação realmente fez apenas olhando os subquadros individuais da animação. 

  magick script_k.gif  +repage  +adjoin  script_k_%02d.gif

[IM Output] [IM Output] [IM Output] [IM Output] [IM Output] [IM Output] [IM Output] [IM Output] [IM Output] [IM Output] [IM Output]

A operação "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" basicamente converte uma imagem em exatamente o que a animação deveria parecer depois que o quadro anterior foi corretamente suprimido e o próximo subquadro sobreposto. Ou seja, em vez de uma sequência de animação em que cada quadro representa apenas as mudanças sobrepostas ao quadro 'suprimido' anterior. Este operador cria uma visão completa da animação em cada ponto, um pouco como uma verdadeira tira de filme, em vez de uma sequência de animação. Tal sequência, conhecida como Animação Coalescida, é muito mais fácil de estudar, editar, modificar e reotimizar. Aqui, por exemplo, geraremos uma montagem da mesma sequência de animação 'confusa' que mostrei acima, mas desta vez usaremos "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" nas sequências, para que você possa ver o que realmente está acontecendo. | 

  montage script_k.gif -coalesce \
          -tile x1 -frame 4 -geometry '+2+2' \
          -background none -bordercolor none coalesce_k_montage.gif

[IM Output]

[IM Output]

Como você pode ver, o resultado é como uma tira de filme da animação, permitindo ver claramente como as peças anteriores se encaixam para formar uma letra 'K' desenhada à mão. A partir da versão 6.2.6 do IM, o comando "magick montage" passou a entender o uso de "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)", permitindo criar uma imagem em estilo 'tira de filme' dos quadros da animação, exatamente como mostrado acima. Esta versão também continha correções para o coalesce, e qualquer trabalho com animação GIF deve ser feito pelo menos com esta versão (ou, melhor ainda, com a mais recente). Uma técnica de montagem ainda melhor para examinar animações é apresentada na próxima seção de exemplos.
A configuração "[-dispose](https://imagemagick.org/command-line-options/#dispose)" de uma sequência de imagens coalescida é, na verdade, irrelevante em uma Animação Coalescida. No entanto, para tranquilidade dos usuários, o operador "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" definirá a configuração "[-dispose](https://imagemagick.org/command-line-options/#dispose)" de cada quadro como '[None](#none)' ou '[Background](#background)', conforme apropriado, para que a sequência de imagens coalescida continue a animar corretamente (como mostrado acima). _Um quadro com supressão '[Background](#background)' significa que o próximo quadro precisava limpar pelo menos um ou mais pixels para ser exibido corretamente.

Assim, animações em que "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" adicionou uma supressão '[Background](#background)' significam que a animação não pode ser salva como uma simples Animação de Sobreposição (veja abaixo).

Tecnicamente, você pode definir todas as configurações de supressão de uma sequência de imagens coalescida como '[Background](#background)' ou '[Previous](#previous)' para gerar uma Animação de Quadros Apagados (veja abaixo). Embora nem todas as animações se otimizem bem nessa forma._
---|---
Há também alguns usos não relacionados a animação do operador "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)". Veja Coalesce e Achatamento Progressivo para exemplos desses usos.

Montagem de Quadros de Animação - o script "gif_anim_montage"

Embora o operador "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)" permita extrair as imagens reais de uma animação e "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" permita ver os quadros resultantes da animação, ambos os métodos omitem muitas informações sobre a animação. Com uma manipulação bem cuidadosa das imagens da animação, você pode exibir os quadros de modo a mostrar não só os quadros reais, mas também o posicionamento desses quadros na tela maior. Aqui está um desses métodos de exibir uma animação. 

  magick -dispose Background   script_k.gif  -alpha set \
          -compose Copy -bordercolor black -border 1x1 -compose Over \
          -coalesce  -bordercolor none   -frame 4x4+2+2 \
          -bordercolor none -border 2x2 +append  script_k_parts.gif

[IM Output]

Aqui você pode ver claramente como a animação funciona. Cada imagem de subquadro é posicionada de modo a se somar a todas as sobreposições anteriores. O resultado é uma imagem que cresce lentamente. Cada quadro também é bem menor que a 'tela virtual' na qual está posicionado. Uso muito esta técnica de exibição durante o desenvolvimento e a depuração de animações GIF; por isso, converti-a em um script de shell "[gif_anim_montage](../static/img/scripts/gif_anim_montage) " e o ampliei para também listar alguns dos detalhes acima de cada quadro da animação. 

  gif_anim_montage   script_k.gif   script_k_frames.gif

[IM Output]

Observe as variações nas temporizações usadas em vários quadros, para pausar como se a caneta estivesse sendo levantada da página e reposicionada. Animações com temporização variável podem estar entre as mais interessantes, mas também são mais difíceis de tratar, como você verá em páginas posteriores dos Exemplos do IM. O script "[gif_anim_montage](../static/img/scripts/gif_anim_montage)" também tem a opção especial '-u', que coloca por baixo uma cópia semitransparente da animação coalescida. Isso permite ver como os novos subquadros modificam a animação exibida. 

  gif_anim_montage  -u  script_k.gif  script_k_frames.png

[IM Output]

É claro que isto tem pixels semitransparentes, por isso foi necessário um formato de imagem 'PNG', OU você poderia usar uma das muitas opções de 'fundo' que esse script também oferece, permitindo usar formatos GIF ou até JPEG para a imagem-resumo resultante da animação. Outras opções permitem definir o número de linhas ou colunas a usar, além de definir vários fundos não transparentes, ou usar uma caixa vermelha em vez do preto padrão. Este script será muito usado nas próximas páginas dos Exemplos do IM. Sugestões e comentários são bem-vindos.

Informações da Lista de Animação - opções usadas para construir uma animação

Como observei, usar "[+adjoin](https://imagemagick.org/command-line-options/#adjoin)" e "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)", bem como "[+repage](https://imagemagick.org/command-line-options/#repage)", são todos métodos úteis de extrair e examinar animações GIF. No entanto, todos eles destroem, no processo, informações sobre a animação original. Você pode ver essa informação extra sobre enquadramento, atrasos de tempo, supressão de quadros, etc., usando o comando "magick identify" do IM com a opção "[-verbose](https://imagemagick.org/command-line-options/#verbose)". Contudo, eu, e provavelmente a maioria dos outros usuários, acho a saída desse comando avassaladora e não realmente utilizável de forma direta. É aqui que entra outro script de shell especial que escrevi. O script "[gif2anim](../static/img/scripts/gif2anim) " separa os quadros individuais da animação, mas também descobre exatamente de quais opções "magick" do IM você precisaria para reconstruir a animação a partir dessas imagens. Você pode pensar em "[gif2anim](../static/img/scripts/gif2anim)" como um desmontador de animação, que produz um resumo da animação em termos de opções do IM. Por exemplo, vamos decodificar o exemplo de animação que temos usado para recuperar as configurações "magick" originais usadas para criá-lo, bem como as imagens individuais utilizadas… | 

  gif2anim canvas_prev.gif

[IM Text]

[IM Output]
[IM Output]
[IM Output]
[IM Output]
[IM Output]

Por padrão, o script "[gif2anim](../static/img/scripts/gif2anim)" usa o mesmo nome de arquivo base para as imagens individuais e para o arquivo de opções ".anim". Assim, o arquivo de sequência de animação gerado pelo comando acima é chamado "[canvas_prev.anim](https://usage.imagemagick.org/anim_basics/canvas_prev.anim)", com as imagens de quadro individuais "[canvas_prev_001.gif](../static/img/anim_basics/canvas_prev_001.gif)" a "[canvas_prev_005.gif](../static/img/anim_basics/canvas_prev_005.gif)". Se você examinar os resultados mais de perto, verá que ele de fato conseguiu recriar as opções originais que usei quando criei esta animação GIF pela primeira vez (Veja Animação Dispose Previous). Além disso, embora não seja importante para de fato gerar uma animação, o tamanho e as temporizações dos quadros sobrepostos também são listados como comentário, para facilitar o estudo. Em vez de salvar os resultados em um arquivo, você pode simplesmente listar as opções da sequência de animação na tela usando uma opção "-l". Ou seja, apenas produzir o arquivo de sequência de animação, em vez de salvá-lo ou de salvar as imagens de quadro individuais da animação. 

  gif2anim -l canvas_prev.gif

Dado um arquivo ".anim" e as imagens de enquadramento individuais, um script complementar "[anim2gif](../static/img/scripts/anim2gif) " pode ser usado para reconstruir a animação. | 

  anim2gif canvas_prev.anim

[IM Output]
O "[anim2gif](../static/img/scripts/anim2gif)", por padrão, recria a animação GIF com um sufixo "_anim.gif". Você pode ver que a animação "[canvas_prev_anim.gif](../static/img/anim_basics/canvas_prev_anim.gif)" resultante gerada parece e funciona exatamente como a animação original. Este script simplesmente substitui a string especial "BASENAME" usada no "arquivo de sequência de animação", remove todos os comentários e então apenas passa as opções de convert restantes ao comando "magick". Em outras palavras, ele trata o arquivo acima como uma espécie de script 'convert' com comentários. A razão de se ter usado uma string especial é que isso permite especificar um nome de arquivo base diferente do nome do próprio arquivo ".anim". Dessa forma, você pode usar um conjunto completamente diferente de imagens de quadro, como versões modificadas do original, para recriar uma animação diferente a partir da antiga. Este é um recurso muito útil, que será usado em processamentos de animação mais complexos. (Veja Concatenar Animações Lado a Lado para um exemplo). Como o "[gif2anim](../static/img/scripts/gif2anim)", o script "[anim2gif](../static/img/scripts/anim2gif)" tem um bom número de opções úteis, para ajudar você a processar e modificar animações. Algumas dessas opções serão usadas mais tarde. Por exemplo, veja Concatenar Animações. Além disso, como o arquivo ".anim" é texto puro, você pode usá-lo para pegar as imagens decodificadas de uma animação e ajustar os metadados do GIF, como as temporizações, as posições, as seções repetidas de uma animação, ou adicionar novos quadros e imagens a uma animação. Afinal, foi por isso que escrevi originalmente os scripts, muito antes de me envolver com os exemplos do IM. Por ora, o "[gif2anim](../static/img/scripts/gif2anim)" será mais útil para examinar uma sequência de animação e ver exatamente o que está acontecendo, e as temporizações que estão sendo aplicadas entre os quadros.

Dispose Images - a forma de supressão GIF dos quadros

Este método especial "[-layers](https://imagemagick.org/command-line-options/#layers)", '**Dispose**', mostra como o quadro deveria parecer depois que o atraso de tempo termina e o método de supressão do GIF é aplicado, mas antes de a imagem do próximo quadro ser sobreposta. Em outras palavras, isto mostra exatamente o que a configuração do método "[-dispose](https://imagemagick.org/command-line-options/#dispose)" do GIF de fato faz ao quadro, permitindo descobrir exatamente o que está dando errado na sua animação. Por exemplo, aqui está como cada uma das nossas três Animações de Exemplo de Métodos de Supressão fica depois que o método de supressão de cada quadro é aplicado. Lembre-se de que cada uma dessas animações consiste em uma 'imagem de tela' que foi definida com uma configuração "[-dispose](https://imagemagick.org/command-line-options/#dispose)" '[None](#none)', seguida de quatro imagens menores sobrepostas e depois suprimidas pelos vários métodos de supressão do GIF. Animação de supressão '[None](#none)'… 

  magick canvas_none.gif -layers Dispose canvas_none_dispose.gif
  gif_anim_montage canvas_none_dispose.gif canvas_none_dispose_frames.gif

[IM Output]

Animação de supressão '[Previous](#previous)'… 

  magick canvas_prev.gif -layers Dispose canvas_prev_dispose.gif
  gif_anim_montage canvas_prev_dispose.gif canvas_prev_dispose_frames.gif

[IM Output]

Animação de supressão '[Background](#background)'… 

  magick canvas_bgnd.gif -layers Dispose canvas_bgnd_dispose.gif
  gif_anim_montage canvas_bgnd_dispose.gif canvas_bgnd_dispose_frames.gif

[IM Output]

Se você estudar o acima, poderá ver exatamente como cada um dos três métodos de supressão do GIF limpa da animação a imagem sobreposta daquele quadro. Observe que o primeiro quadro dessas três animações está sempre definido com uma supressão 'None', portanto permanecerá inalterado. É o efeito do método de supressão nos quadros posteriores que é importante. A operação "-layers Dispose" apenas gera a sequência 'coalescida' dos quadros de supressão. Ela não redefine a própria configuração de supressão, e por isso o resultado pode não animar corretamente. Para fazer o acima animar corretamente, defina todos os métodos de supressão como 'previous' ou 'background', ou você pode otimizar a animação antes de salvar.
_O aspecto do quadro final depois do método de supressão do GIF normalmente não tem consequência para uma animação GIF, pois toda a tela é completamente limpa antes de a animação repetir (entrar em laço). Se ela não 'entra em laço', mas para ao final da sequência de animação, então a supressão do quadro final não é aplicada.

Em outras palavras, a aparência do último quadro (após a supressão) como mostrado acima, ou mesmo a configuração de supressão real do último quadro, não tem qualquer efeito sobre uma animação GIF. O IM geralmente a define igual à do quadro anterior quando tenta descobrir um método de supressão apropriado, durante uma Otimização de Quadros de uma animação._
---|---

Deconstruct - relatar áreas de diferença entre quadros

A forma tradicional no ImageMagick de otimizar uma animação, tornando o resultado menor e mais rápido de baixar e animar, é aplicar "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)" à sua forma "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)". Isso não é mais recomendado. Em vez disso, você deve usar o Otimizador de GIF de Uso Geral. Este operador pega uma sequência coalescida de imagens (os quadros da animação tal como realmente aparecem quando exibidos) e compara a segunda imagem e as posteriores com a imagem anterior. Em seguida, substitui aquela imagem pela menor área retangular dos pixels que mudaram. Qualquer mudança de pixel conta, independentemente de ser uma mudança de cor (sobreposição) ou uma limpeza (apagamento). Isto é bastante simples e, para uma Animação de Sobreposição típica, gera uma Otimização de Quadros ótima para aquela animação. Uma Animação de Sobreposição, porém, usa apenas um método de supressão '[None](#none)'. Por exemplo, vamos pegar a animação previous coalescida que geramos acima, que por acaso forma uma Animação de Sobreposição, e passá-la pelo operador "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)". | 

  magick canvas_prev.gif   -coalesce     coalesce.gif
  magick coalesce.gif     -deconstruct   deconstruct.gif
  gif_anim_montage  coalesce.gif     coalesce_frames.gif
  gif_anim_montage  deconstruct.gif  deconstruct_frames.gif

[IM Output]
[IM Output]
[IM Output]
Uma 'animação de supressão previous', se você se lembra, limpa cada quadro até o último quadro que não teve supressão previous, neste caso a tela de fundo inicial. Como você pode ver, "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)" retornou a área que mudou de um quadro coalescido para o seguinte. Resultando em uma Animação de Sobreposição otimizada, que não requer nenhuma configuração de supressão especial. Isto está longe de ser tão ótimo quanto a animação original gerada à mão com que comecei, mas é útil por si só. Infelizmente, "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)" não entende absolutamente nada das configurações de "[-dispose](https://imagemagick.org/command-line-options/#dispose)" da animação GIF. Consequentemente, se você tentar isto em uma animação que limpa pixels de um quadro para o seguinte, como a animação 'com supressão background' que criamos acima (e mostrada à esquerda), ela falhará gravemente. | [IM Output]
---|---
Aqui pegamos a animação que acabamos de mostrar e a passamos por um ciclo de "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" e "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)". | 

  magick canvas_bgnd.gif  -coalesce  -deconstruct  deconstruct_erase.gif

[IM Output]
Como você pode ver, "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)" destrói lentamente a animação. Basicamente, "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)" foi projetado para simplesmente encontrar as diferenças entre camadas de imagem. Nunca foi projetado para otimizar animações corretamente e falhará para animações que precisam usar várias técnicas de supressão para limpar (apagar ou tornar transparentes) pixels sobrepostos anteriormente.

Frame Comparisons - comparação mais detalhada de quadros

Com o IM v6.2.6-2, foram adicionados vários métodos extras de comparação de quadros GIF. Eles eram necessários internamente para a otimização adequada de animações, mas foram considerados úteis o suficiente para serem disponibilizados na linha de comando e em outras interfaces de API.

Compare_Any

O método "[-layers](https://imagemagick.org/command-line-options/#layers)" '**CompareAny**' é, na verdade, exatamente igual a "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)". De fato, o operador "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)" é apenas um alias funcional do método 'CompareAny'. Vejamos novamente os resultados de imagem reais de um 'deconstruct' ou 'CompareAny' da animação 'com supressão background'. 

  magick canvas_bgnd.gif  -coalesce  canvas_bgnd_coal.gif
  gif_anim_montage canvas_bgnd_coal.gif canvas_bgnd_coal_frames.gif

  magick canvas_bgnd_coal.gif  -layers CompareAny   magick compare_any.gif
  gif_anim_montage compare_any.gif compare_any_frames.gif

[IM Output]
[IM Output]

Como você pode ver, a segunda imagem e as posteriores são a área retangular mínima que contém todos os pixels que mudaram, seja uma sobreposição de uma nova cor de pixel, seja uma limpeza de um pixel antigo para transparência.

Compare_Clear

O método "[-layers](https://imagemagick.org/command-line-options/#layers)" '**CompareClear**' mostra a menor área retangular que contém todos os pixels que precisaram ser limpos de um quadro para o seguinte. 

  magick canvas_bgnd_coal.gif -quiet -layers CompareClear compare_clear.gif
  gif_anim_montage compare_clear.gif compare_clear_frames.gif

[IM Output]

Observe que, como nenhum pixel foi limpo entre o primeiro e o segundo quadro, uma Missed Image especial foi gerada. A configuração "[-quiet](https://imagemagick.org/command-line-options/#quiet)" foi usada para instruir o IM a não emitir nenhum aviso sobre esta imagem. Se todos os quadros posteriores se tornarem imagens 'missed', então a animação GIF nunca limpa pixels, e a animação pode ser classificada como uma Animação de Sobreposição.

Compare_Overlay

O último método de comparação "[-layers](https://imagemagick.org/command-line-options/#layers)", '**CompareOverlay**', retorna a área de pixels que foram sobrepostos (adicionados ou com cor alterada, mas não limpos) desde o quadro anterior. 

  magick canvas_bgnd_coal.gif  -layers CompareOverlay  magick compare_overlay.gif
  gif_anim_montage compare_overlay.gif compare_overlay_frames.gif

[IM Output]

Isto é semelhante ao Método de Composição Alfa 'ChangeMask" específico do IM. No entanto, esse retorna apenas os pixels que mudam a imagem, em vez da área retangular que foi alterada. Veja também Otimização de Transparência. Nenhum dos métodos de comparação "[-layers](https://imagemagick.org/command-line-options/#layers)", nem o operador "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)", examina ou modifica o método de supressão GIF usado na imagem. Os resultados são apenas uma lista de imagens e não se destinam a ser usados como animações em si.
_Embora os operadores sejam projetados para trabalhar com uma sequência de imagens coalescida, eles aceitam uma sequência não coalescida de camadas de imagem sem produzir um erro.

Neste caso, cada quadro é sobreposto aos quadros sobrepostos anteriores usando um método de composição alfa '[Copy](compose.html#copy)', antes de os quadros serem comparados. Este método de composição alfa garante que qualquer transparência em uma camada também seja adicionada à imagem de destino. Sem isso, o acima não encontraria pixels que são limpos para transparência em uma sequência de imagens coalescida.

Observe que isto é diferente do método de composição '[Over](compose.html#over)' mais comum que o operador "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" usaria para tratar o ciclo de 'supressão/sobreposição' necessário para exibir uma animação GIF.

_
---|---

Tipos de Animações

A maioria das animações GIF que você encontra se enquadra em alguns tipos básicos de animação. Conhecer esses tipos permite entender como aquela animação está sendo exibida de um quadro para outro e pode permitir que você tome atalhos na forma de tratar e modificar a animação.

Animações Coalescidas

Uma 'Animação Coalescida ' é basicamente uma sequência de imagens que mostra como uma animação deveria parecer quando exibida a um usuário após cada ciclo de 'supressão/sobreposição'. As imagens são basicamente como você as veria se estivesse olhando uma verdadeira 'tira de filme' da animação. É a forma simplificada e completamente não otimizada de qualquer animação. Esta convenção de nomenclatura vem do nome do operador "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" do IM, usado para converter animações de supressão GIF em uma 'Animação Coalescida' não otimizada. A maioria dos formatos de vídeo (MPEG, AVI etc.) também são, na verdade, 'Animações Coalescidas' por sua própria natureza. No entanto, estes também tendem a não ter nenhum pixel transparente e, em geral, têm um atraso de tempo constante entre os quadros da animação. Uma animação GIF coalescida, porém, pode ter pixels transparentes e atrasos de tempo que variam muito, desde atrasos imediatos de '0' até muito rápidos, ou muito muito muito lentos. Qualquer configuração de supressão GIF em uma animação coalescida não tem nenhum significado; no entanto, o operador "[-coalesce](https://imagemagick.org/command-line-options/#coalesce)" definirá a supressão de forma apropriada para que a sequência de imagens resultante ainda possa funcionar como uma animação GIF válida. Formatos de vídeo que sempre substituem cada pixel de um quadro para o seguinte podem, em geral, simplesmente usar uma configuração de supressão GIF '[None](#none)' ou '[Undefined](#none)'. Aqui está um exemplo de uma animação que também é, por sua natureza, uma Animação Coalescida, além de uma exibição "[gif_anim_montage](../static/img/scripts/gif_anim_montage)" dos quadros individuais da animação. [IM Output] [IM Output]
A maioria das animações que não contêm, ou não usam, transparência, e que animam toda a tela, costumam ser salvas e distribuídas como Animações Coalescidas.

Animações de Sobreposição

Uma 'Animação de Sobreposição ' é aquela em que cada quadro de uma animação apenas sobrepõe novos pixels à animação atualmente exibida. Em outras palavras, em nenhum momento da animação é preciso limpar um pixel para transparência. Os quadros individuais podem conter transparência, seja como fundo, seja como parte de sua otimização, mas nunca limpam um pixel de volta para transparência. É claro que, se nenhuma transparência for usada, então a animação certamente poderá ser transformada em uma simples Animação de Sobreposição. Este é provavelmente o tipo mais simples de animação Otimizada por Quadros e um que não requer nenhum tratamento especial pelos clientes. Cada quadro mostrado ao usuário pode ser visto simplesmente como uma imagem 'achatada' de todos os quadros anteriores. Qualquer animação que use apenas um método de supressão GIF '[None](#none)' é uma 'Animação de Sobreposição'. O último exemplo, por exemplo, não é apenas uma 'Animação Totalmente Coalescida', mas também uma 'Animação de Sobreposição', embora nem todas essas 'Animações Totalmente Coalescidas' sejam 'Animações de Sobreposição'. Você pode testar se uma animação pode se tornar uma animação de sobreposição usando o método de camadas '[CompareClear](#compareclear)' em uma animação Coalescida e verificando se a segunda imagem e as posteriores são todas 'imagens missed'. Ou seja, nenhum pixel precisou ser limpo ou apagado de um quadro para o seguinte. De fato, se uma animação pode se tornar uma animação de sobreposição sem modificação, então o operador "[coalesce](#coalesce)" do IM usará apenas métodos de supressão '[None](#none)' para todos os quadros. Se não for o caso, então "[coalesce](#coalesce)" terá usado supressão '[Background](#background)' para pelo menos alguns dos quadros. Isso lhe dá então outro teste para a capacidade de 'apenas sobreposição'. As animações de sobreposição podem usar transparência, mas não têm nenhuma parte móvel sobre um fundo transparente. Por exemplo, a animação de uma letra 'K' desenhada à mão é uma animação de sobreposição, pois cada parte apenas adiciona ou altera partes existentes sobre um fundo transparente. Ela nunca adiciona nova transparência à imagem resultante (exceto como parte do primeiro quadro). [IM Output] [IM Output]
[IM Output] Isto não quer dizer que um objeto em movimento não possa ser tratado por uma animação de sobreposição; significa apenas que você precisa de um fundo não transparente para poder também 'apagar' as posições antigas das partes móveis sem precisar de transparência. Por exemplo, veja os quadros desta animação de "baixar o mundo para uma pasta"…

[IM Output]

É claro que, por precisar 'apagar' as partes antigas sobrepondo o fundo original, as subimagens sobrepostas são geralmente maiores e, portanto, o tamanho do arquivo da animação GIF costuma ser maior. Infelizmente, usar o operador Otimização de Quadros do IM pode, e muito provavelmente vai, transformar uma 'Animação de Sobreposição Coalescida' em algo que não é uma 'Animação de Sobreposição', na sua tentativa de encontrar um tamanho de arquivo GIF menor. No entanto, usando Deconstruct na animação em vez de usar a Otimização de Quadros, você pode garantir que a animação permaneça uma simples 'Animação de Sobreposição', mas só se a animação for realmente uma 'Animação de Sobreposição'. Se a animação não for uma 'Animação de Sobreposição', então a operação Deconstruct pode dar muito errado (veja Deconstruct acima). Com alguma habilidade humana, você ainda pode otimizar melhor uma animação de sobreposição, por exemplo, usando Dividir Atualizações de Quadro e aplicando alguma forma de Otimização de Compressão sem destruir o requisito de 'apenas sobreposição' da animação. Normalmente, as 'Animações de Sobreposição' não exibem nenhuma transparência (elas podem usá-la como parte da otimização, mas não a exibem). E se nenhuma transparência é exibida, então a animação certamente é uma 'Animação de Sobreposição'. Por que as 'Animações de Sobreposição' são tão importantes? Porque existe software por aí que se limita a este tipo de animação. É muito mais simples de tratar, pois só se realiza a sobreposição, sem necessidade de lidar com transparência ou de salvar o quadro anterior para tratar os métodos de supressão do GIF. Esse software é raro, mas existe.

Animações de Quadros Apagados

Quando uma animação usa apenas supressão GIF 'Previous' ou 'Background', você obtém um tipo muito especial de animação. Observe que, se apenas supressões 'Background' forem usadas, todos os quadros de uma animação são exibidos e então limpos antes de o próximo quadro ser exibido. Da mesma forma, quando apenas '[Previous](#previous)' são usadas, a animação é sempre retornada à tela limpa inicial antes de o próximo quadro ser exibido, resultando no mesmo efeito. O mesmo acontece se você usar apenas uma mistura dessas duas configurações de supressão. Ou seja, animações que usam apenas esses métodos de supressão terão quadros que são cópias completas do que deve ser exibido. Isto é, o quadro contém tudo o que será exibido ao usuário naquele momento. Isso não quer dizer que a animação seja uma 'Animação Totalmente Coalescida'. Pois o subquadro pode ser bem menor que a área da tela virtual da animação, mas tudo fora daquele quadro será considerado transparente (ou fundo), não contendo nada de importante. Por exemplo, dê uma olhada nesta animação de coelho correndo… [IM Output] [IM Output]
Observe que todo e qualquer subquadro é a imagem completa que é exibida. Nem mais, nem menos. Observe também que nenhum dos quadros realmente precisa usar toda a tela virtual da animação. E, por fim, observe como todas as supressões de quadro estão definidas como '[Previous](#previous)', que, por razões que você verá abaixo, é a configuração de supressão mais lógica a usar. Todas as configurações de supressão, porém, poderiam ter sido definidas como supressão '[Background](#background)', ou qualquer mistura das duas, sem alterar o resultado final. Por falta de um nome melhor, chamo tal animação de 'Animação de Quadros Apagados ', mas também já a vi ser chamada de 'Animação de Supressão Previous ou Background'. A única vez em que uma animação não é deste tipo é se pelo menos um quadro não vazio da animação usar um método de supressão '[None](#none)' ou 'Undefined' (mesma coisa). Esta animação é muito especial, pois pode lidar com qualquer quantidade de limpeza de transparência, em qualquer ponto da sequência de animação, ao contrário de uma Animação de Sobreposição. Mas ela também pode ser sobreposta a QUALQUER imagem de fundo estática muito rapidamente. Para isso, precisamos apertar um pouco a definição de uma 'Animação de Quadros Apagados'. Especificamente, precisamos garantir que todas as supressões estejam definidas como '[Previous](#previous)' (o que já é o caso no nosso exemplo). Feito isso, você pode simplesmente prefixar uma imagem (com atraso zero) para colocar um fundo por baixo. Por exemplo, vamos colocar nosso coelho sobre uma grama… 
  magick bunny_grass.gif bunny_anim.gif -loop 0  bunny_on_grass.gif

[IM Output]
Como você pode ver, isto é tão simples que muitas aplicações usam esses tipos de animação GIF para adicionar símbolos ou outros indicadores (cadeados de arquivo, smileys, estrelas, etc.) a objetos maiores. Animar tal animação GIF também é fácil, pois a aplicação pode simplesmente limpar a área para alguma imagem de fundo constante e simples, e sobrepor o próximo quadro da sequência. Não é preciso calcular supressões, nem acompanhar uma exibição 'previous', além da exibição de fundo estática e imutável. Esta é também a razão pela qual uma supressão '[Previous](#previous)' é a supressão preferida para uma Animação de Quadros Apagados. Ao contrário de uma Animação de Sobreposição, que é apenas um subconjunto especial das animações GIF, TODAS as animações podem ser salvas como uma Animação de Quadros Apagados. Basta coalescer a animação e, opcionalmente, aparar quaisquer bordas transparentes ao redor para otimizá-la por quadros, e redefinir as supressões. 

  magick any_animation.gif -coalesce -trim \
          -set dispose previous   cleared_frame_animation.gif

Você pode até reposicionar a animação sobre esse fundo… | 

  magick bunny_grass.gif \( bunny_anim.gif -repage 0x0+5+15\! \) \
          -loop 0  bunny_on_grass2.gif

[IM Output]
Assim, uma Animação de Quadros Apagados normalmente consiste em um objeto pequeno, em constante mudança ou movimento, sobre um fundo transparente. Elas são diretamente utilizáveis em páginas web, ou como símbolos animados, ou podem ser mescladas com outras animações para produzir animações muito mais complexas. Em resumo, este tipo de animação é um bom estilo para usar em uma biblioteca de partes animadas, para criar animações maiores e mais complexas.
Há, no entanto, um problema em adicionar fundo dessa maneira a animações GIF. Se você olhar os exemplos anteriores, provavelmente terá notado uma pausa significativa e incômoda na animação de movimento rápido. Ou seja, o coelho desapareceu por um momento, quando a animação entrou em laço e a imagem de fundo é recarregada. (Veja as notas em Quadros com Atraso Zero.) Embora isso não seja um problema para as aplicações que usam esta técnica para adicionar símbolos animados a objetos exibidos, pois de qualquer forma elas simplesmente não exibem aquele quadro 'intermediário'. Assim, se você estiver adicionando um fundo não transparente à animação GIF, então geralmente é uma boa ideia converter a simples Animação de Quadros Apagados em uma Animação de Sobreposição. Ou seja, adicionar esse fundo a cada quadro da animação, em vez de fornecer uma tela inicial. Você pode fazer isso de duas formas: Coalescendo a animação acima e depois excluindo o quadro de fundo com Atraso Zero, OU fazendo a Composição em Camadas da animação original sobre um Fundo Estático. Por exemplo…

| 

  magick bunny_grass.gif \( bunny_anim.gif -repage 0x0+5+15\! \) \
          -coalesce -delete 0 -deconstruct -loop 0  bunny_bgnd.gif
  gif_anim_montage  bunny_bgnd.gif  bunny_bgnd_frames.gif

[IM Output]
[IM Output]

Agora que todos os quadros são exibidos igualmente bem, nenhuma pausa pode ser vista quando o fundo é redefinido. A animação, porém, agora é uma Animação de Sobreposição com o fundo sendo 'redesenhado' devido ao movimento do objeto da animação, e por isso provavelmente tem um tamanho de arquivo um pouco maior. Veja Otimização de Transparência para uma continuação da otimização do resultado acima. | _O membro do fórum do IM el_supremo, Pete, contribuiu com um script equivalente em MagickWand, exemplo de Quadro Apagado sobre Fundo.

Este exemplo também é discutido em detalhe no Fórum do IM Criando uma Animação GIF de Quadros Apagados no MagickWand.

_
---|---

Animações de Supressão Mista - animações de múltiplos fundos

Não há nada que o impeça de misturar os vários métodos de supressão em uma única animação GIF. Na verdade, adicionar um fundo a uma Animação de Quadros Apagados faz exatamente isso. Usar métodos de supressão misturados não é tão simples para nós, humanos, mas fazê-lo pode permitir gerar algumas exibições animadas muito complexas. Em geral, elas são criadas como parte da Otimização de Quadros automática para uma animação específica. Apenas lembre-se de que o resultado não será diretamente utilizável para fins específicos como os tipos de animação anteriores. Na verdade, não se surpreenda se alguns programas de tratamento de GIF simplesmente não tratarem corretamente uma 'Animação de Supressão Mista'. Isso inclui alguns dos otimizadores de GIF disponíveis. Um exemplo típico de 'Animação de Supressão Mista' é um pequeno objeto em movimento que causa alguma mudança semipermanente, mas temporariamente estática, no fundo da animação. Uma bola atingindo uma alavanca seria um exemplo. 

_Procura-se um exemplo simples_

Da mesma forma, animações envolvendo dois objetos móveis muito pequenos sobre uma exibição transparente maior só podem ser bem otimizadas misturando as técnicas de supressão, de modo que cada objeto seja movido usando quadros de animação separados. 

FUTURO,
Uma animação mais complexa para estudo.
 * Começar com uma tela semitransparente
 * rodar um pouco de supressão 'previous'
 * deixar um quadro como uma nova 'tela'
 * mais animações previous
 * apagar essa 'adição' usando uma supressão 'background' definida como nova tela
 * continuar de volta ao ponto de partida.
Esta animação deve testar minuciosamente não só os métodos de supressão do IM
mas também os vários métodos de supressão dos navegadores.

Se você quiser contribuir com um exemplo do IM de tal animação, pode ter seu nome e o link da sua página inicial aqui!

O Fim do Laço - quando uma animação para

Muitas vezes considera-se uma boa ideia não fazer animações entrarem em laço para sempre, pois as máquinas cliente precisam trabalhar continuamente enquanto a animação ainda está animando. Por isso, é uma boa ideia pensar em quantas vezes sua animação de fato entra em laço. Basicamente…

Adicione um limite de laço às suas animações (se for prático)

Este é especialmente o caso de animações grandes usadas como logotipo no topo de uma página web. Dependendo do tempo total durante o qual uma animação roda, de 10 a 30 laços costumam ser suficientes para logotipos grandes. E você deve adicionar um limite de laço a todas essas animações, para ser gentil com seus usuários. Uma configuração de gravação "[-loop](https://imagemagick.org/command-line-options/#loop)" de 0 significa entrar em laço para sempre. É isto o que normalmente se usa, e tudo bem para animações pequenas. Alguns navegadores, porém, impõem uma parada quando uma animação atinge algum limite de laço interno (muitas vezes 256 laços). Para os Exemplos do IM, em geral usei uma configuração de gravação "[-loop](https://imagemagick.org/command-line-options/#loop)" de '0', significando 'entrar em laço para sempre', porque as animações podem aparecer em qualquer lugar de uma página. Isso significa que pode se passar algum tempo entre o momento em que o usuário carregou uma página e o momento em que ele finalmente olha e lê sobre uma animação GIF específica. Se eu usasse um número menor de 'laços', a animação já não estaria fazendo o que deveria demonstrar, perdendo sua eficácia. Para animações grandes em páginas de abertura de nível superior, pode-se usar um "[-loop](https://imagemagick.org/command-line-options/#loop)" de '1', o padrão normal de animação GIF. Isso significa percorrer a animação apenas uma vez e então parar. O que nos leva a uma pergunta muito importante… Parar onde? Alguns navegadores, como o antigo navegador "Netscape", reexibiam o primeiro quadro da animação. A maioria dos navegadores modernos, porém, simplesmente para no último quadro, ignorando a inútil configuração de supressão daquele quadro. O que uma aplicação específica faz, no entanto, cabe à aplicação, pois não há um verdadeiro padrão. Na verdade, até o uso dos metadados de 'loop' é, ele próprio, não padronizado, apenas algo que o antigo navegador "Netscape" implementou e que todos os navegadores posteriores copiaram. Por isso, se houver algum quadro específico no qual você quer que sua animação pare, digamos o quadro com o nome ou o logotipo da sua empresa, então é uma boa ideia tornar esse quadro tanto o primeiro quanto o último quadro de uma animação. Um desses quadros, porém, deve receber um 'atraso zero', para não afetar a duração total do tempo de laço da animação. Então, apenas para resumir…

Se limitar o laço, adicione o quadro de 'parada' como o primeiro E o último quadro.

Quadros Intermediários com Atraso Zero

Já vimos o uso de um quadro que tem 'atraso zero', em relação a uma Animação de Quadros Apagados. Também os usei para explicar as Supressões Previous e Background. Esses quadros especiais são, na verdade, muito mais comuns do que as pessoas provavelmente pensariam. Eles representam não só métodos para prefixar uma 'tela' de fundo a uma animação (tal como os usei acima). Mas também são indispensáveis para algumas das técnicas de Otimização de Quadros mais complexas, como Duplicação de Quadros e Dividir Atualizações de Quadro. Outro uso (muito antigo, anterior ao formato PNG) era permitir criar imagens GIF estáticas que contivessem mais do que o limite de 256 cores! Ou seja, cada quadro fornece 256 cores, e o quadro seguinte o próximo conjunto de 256 cores, todos com atraso zero e sem laço ao final. Obrigado a TLUL na discussão Criando GIFs não quantizados por apontar isso. Esses 'quadros intermediários com atraso zero ' não se destinam a ser exibidos a um usuário. Eles são apenas usados para criar efeitos especiais em imagens GIF que, de outra forma, não seriam possíveis ou que ficam mais bem otimizados do que ficariam sem eles. Em resumo…

Os Quadros com Atraso Zero são Quadros Intermediários,
Não se destinam a ser visíveis aos usuários.

O ImageMagick não só cria tal quadro em animações como parte de seu 'OptimizePlus' automático, mas também oferece uma maneira de removê-los usando o método de camadas 'RemoveZero'. Fique atento a eles, pois muitas vezes complicam o seu tratamento de Animações. Certo, então eles são importantes, e daí? Porque muitas aplicações não gostam deles, ou os tratam incorretamente. Elas consideram os 'Quadros com Atraso Zero' algo ruim, mesmo quando você os adiciona propositalmente às animações, por uma razão ou outra. Aqui está um resumo das aplicações que conheço, ou sobre as quais me contaram, que 'fazem a coisa errada'… Gimp | Não salva um 'Quadro com Atraso Zero'; sempre adiciona um atraso de tempo mínimo a qualquer quadro que tenha atraso de tempo zero. :-(

---|---
FireFox | Dá uma leve pausa não zero em tais quadros. Isto é presumivelmente para que animações que não têm nenhum atraso de tempo não consumam todos os ciclos de CPU do computador. Mas o "firefox" ainda não relaxa essa restrição se uma animação tiver um tempo de exibição total não zero.

Internet Explorer | Tem um atraso de tempo mínimo de 6 centissegundos e ignora qualquer atraso menor que isso. O Internet Explorer versão 8 também falha (reinicia imediatamente o laço) se algum quadro de imagem se estender além dos limites da animação definidos pelo primeiro quadro. Isso eu classificaria como um bug grave.
Por outro lado, o método de camadas 'RemoveZero' do ImageMagick faz a coisa certa e NÃO removerá nenhum quadro se TODAS as imagens tiverem um 'atraso de tempo zero'. De fato, este método de camadas emite um aviso se vir uma animação sem nenhum atraso de tempo. Isso nos leva a outra regra prática…

Nunca salve uma animação GIF (em laço) que não tenha nenhum 'atraso'

Fazer isso é uma prática muito ruim, e a razão pela qual a maioria das aplicações 'com bugs' acima faz o que faz, em vez do que deveria. Reclame com os donos se as vir. Reclame também com os desenvolvedores de aplicações, para que tratem corretamente os quadros com atraso zero. Mesmo que isso signifique não exibir aquele quadro de forma alguma, apenas usá-lo como preparação para o próximo quadro a exibir. Afinal, eles ficam na tela por tempo ZERO!

Original: https://usage.imagemagick.org/anim_basics/index.html