Exemplos do ImageMagick -- Diversos

Prefácio e Índice dos Exemplos do ImageMagick

Interpolação (Consulta de Cor Entre Pixels)

• Métodos Simples de Interpolação
• Bilinear, Mesh, Catrom, Spline
• Interpolação sobre um Fundo
• Interpolação de uma Linha Rotacionada

• Interpolação de uma Borda Rotacionada

  Pixels Virtuais (Consulta de Cor Fora da Imagem)

• Edge, Tile, Mirror, Transparent, Black, Gray, White, Background,
  HoriziontalTile, HoriziontalTileEdge, VerticalTile, VerticalTileEdge,
  CheckerTile, Random, Dither

• Pixels Virtuais e Infinitos
• Cores dos Pixels Virtuais
• Exemplos de Pixels Virtuais

• Efeitos de Implosão em Pixels Virtuais

  Manchas Aleatórias de Cor Sólida Uso dos Argumentos de Annotate Splice: Criando um Novo Operador de Imagem Border, Frame e o uso de BorderColor Teste dos Operadores de Lista Esta página consiste em exemplos que testam diversos aspectos do ImageMagick, mas que não se encaixam adequadamente nas discussões das outras páginas de exemplos (ao menos não formalmente). Também estão incluídas nesta página algumas tabelas que demonstram os resultados do argumento de versão com operadores específicos do IM. No entanto, outras pessoas também já fizeram isso, portanto, a menos que eu tenha algo a acrescentar, não tratarei mais do assunto.

Interpolação de Pixels ou Consulta de Cor Entre Pixels

A opção "[-interpolate](https://imagemagick.org/command-line-options/#interpolate)" é usada ao consultar uma cor em uma imagem de origem quando esse 'ponto de consulta' cai entre os pixels da imagem de origem. Isso ocorre em diversas operações de imagem, como "[-fx](https://imagemagick.org/command-line-options/#fx)" (Operador de Efeitos Especiais Faça-Você-Mesmo) e "[-distort](https://imagemagick.org/command-line-options/#distort)" (Operador de Distorção Geral de Imagem), além de outros operadores relacionados como as Distorções Circulares. Basicamente, a 'interpolação' informa ao IM como interpretar uma Consulta Direta de Cor de uma imagem quando o ponto não corresponde exatamente a um pixel real da imagem, mas cai no espaço entre pixels. Por exemplo, se você consultar a cor na posição de pixel 3,4, deverá obter a cor exata desse pixel. Mas o que o IM deveria retornar se você consultasse a cor de uma imagem no ponto 3.23,4.75? Deveria obter a cor do pixel em 3,4 ou em 3,5? ou talvez uma mistura das cores dos pixels vizinhos e, nesse caso, como as cores deveriam ser combinadas? A Interpolação de Pixels define o que o ImageMagick deve fazer ao consultar uma única cor em uma posição de ponto flutuante (em coordenadas de pixel). A interpolação é, de certo modo, semelhante à reamostragem de pixels, como a fornecida pelos Filtros de Reamostragem. A diferença essencial é que a reamostragem tem uma 'escala', 'área' ou 'janela' variável a partir da qual se retorna uma cor que representa todos os pixels da área. A interpolação não envolve nenhuma 'escala', apenas um único 'ponto' de consulta e apenas uma 'área' de tamanho fixo ao redor desse ponto a partir da qual se determina a cor a usar naquele ponto. É claro que a maioria dos algoritmos de reamostragem por área tende a degenerar em um método interpolativo quando a área de reamostragem atinge uma 'janela' de trabalho mínima, e isso ocorre naturalmente quando as imagens estão sendo ampliadas, ou superamostradas. É por isso que os Filtros Interpolados e os Filtros de Desfoque Gaussiano tendem a funcionar melhor para ampliar imagens. A interpolação é basicamente uma forma inferior de amostragem e é usada basicamente quando se deseja uma resposta simples e rápida para a pergunta 'qual é a cor'.

Métodos Simples de Interpolação

  for method in  integer nearest blend average average9 average16 ; do
    magick \( xc:red xc:blue +append \) \
            \( xc:yellow xc:cyan +append \) -append \
            -bordercolor black -border 1 \
            -filter point -interpolate $method \
            +distort SRT 20,0 ip_color_${method}.jpg
    magick xc: -bordercolor black -border 2 \
            -filter point -interpolate $method \
            +distort SRT 16,0 ip_pixel_${method}.jpg
  done

Integer	Nearest	Blend	Average	Average9	Average16

| Antes do IM v6.7.7-6, 'Average' era na verdade equivalente ao que agora é 'Average16'. Os outros dois interpoladores por média, bem como 'Blend' e 'Background', foram adicionados nessa ocasião.
---|---
Outro método simples de interpolação também é fornecido, 'Background ', que simplesmente retorna a cor de fundo atual para qualquer 'amostragem' da imagem de origem. De muitas maneiras isso é bastante inútil, pois tipicamente você acaba apenas com uma imagem lisa de cor sólida. Seu principal uso é como verificação de funções de reamostragem mais complexas, como uma Falha de Reamostragem, em que o filtro de reamostragem EWA (tipicamente usado a partir do Operador de Distorção Geral) recorre a uma consulta interpolada quando a reamostragem não encontra nenhum pixel em seu 'suporte' ou área de reamostragem. Definindo a interpolação como 'Background' e definindo uma cor de fundo que se destaque (como 'red'), você pode então procurar pixels na imagem resultante para ver onde a reamostragem 'falhou' ou 'perdeu todos os pixels da imagem de origem' por um motivo ou outro. Tipicamente devido a uma configuração de suporte pequena demais, ou por mexer nas opções avançadas de filtro. FUTURO: Possível opção futura de interpolação com seleção "aleatória" sobre a área interpolada. Poderia ser útil para efeitos interpolados sofisticados!

Bilinear

'Bilinear ' (ou interpolação linear) é o método de interpolação padrão e provavelmente uma das formas mais simples de obter um resultado interpolado de verdade, combinando as cores dos pixels ao redor do ponto de consulta ou amostragem. Aqui está um diagrama explicando como funciona a interpolação bilinear.

Ou seja, ela simplesmente conecta linhas retas nas direções ortogonais para localizar a cor do ponto de amostragem dado. O resultado também é equivalente a um Filtro de Reamostragem Triangular, quando usado com redimensionamento. |

  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap  -fx 'v.p{i/(w-1),j/(h-1)}' \
          interpolate_bilinear.jpg

|

  magick \( xc:white xc:black +append \) \
          \( xc:black xc:white +append \) -append \
          -size 100x100 xc: +swap -fx 'v.p{i/(w-1),j/(h-1)}' \
          interpolate_saddle.jpg

Esta última imagem mostra como um gradiente linear é formado ao longo das bordas entre os quatro pontos conhecidos e, em seguida, um segundo gradiente linear é formado entre essas bordas. Ou seja, as cores entre os pixels vizinhos são geradas usando gradientes lineares horizontal e vertical. Isso, por sua vez, produz um gradiente bidimensional curvo tipicamente conhecido como 'sela', pois é elevado em dois cantos opostos e rebaixado nos outros dois cantos. Você pode até usar este método para gerar de forma mais direta um gradiente linear inclinado a 45 graus, mas isso exige que você especifique a cor intermediária para os cantos diagonalmente opostos. |

  magick \( xc:blue xc:navy +append \) \
          \( xc:navy xc:black +append \) -append \
          -size 100x100 xc: +swap -fx 'v.p{i/(w-1),j/(h-1)}' \
          interpolate_45linear.jpg

O aspecto mais importante deste método de interpolação padrão é que o pixel central da imagem será sempre uma média das quatro cores dos cantos, com gradientes lineares perfeitos nas bordas e correspondência exata de cor nos cantos.

Mesh

  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap   -interpolate Mesh \
          -fx 'v.p{i/(w-1),j/(h-1)}'    interpolate_tri-mesh.jpg

Como você pode ver, o algoritmo 'Mesh' produziu quase exatamente o mesmo conjunto de interpolações de cor que '[Bilinear](#bilinear)'. No entanto, se invertermos as cores amarela e ciano... |

  magick \( xc:red xc:blue +append \) \
          \( xc:cyan xc:yellow +append \) -append \
          -size 100x100 xc: +swap   -interpolate Mesh \
          -fx 'v.p{i/(w-1),j/(h-1)}'    interpolate_tri-mesh2.jpg

Desta vez o algoritmo 'Mesh' decidiu que as cores 'blue' e 'cyan' eram os dois cantos mais próximos e criou um gradiente linear diagonalmente entre esses dois cantos. As demais cores então formam um gradiente triangular plano simples desta linha até os outros dois cantos. Isso pode parecer uma interpolação incomum, mas o método garante que bordas nítidas permaneçam bastante nítidas quando imagens coloridas são apenas levemente redimensionadas, rotacionadas ou cisalhadas. De fato, uma operação de Redimensionamento Adaptativo ("[-adaptive-resize](https://imagemagick.org/command-line-options/#adaptive-resize)") usa esse fato em pequenos redimensionamentos de imagem para reduzir o desfoque excessivo do resultado. Por exemplo, se tivermos um único canto 'branco', 'mesh' supõe que uma borda foi encontrada e ajusta as cores interpoladas para realçar essa borda. |

  magick \( xc:black xc:black +append \) \
          \( xc:white xc:black +append \) -append \
          -size 100x100 xc: +swap    -interpolate Mesh \
          -fx 'v.p{i/(w-1),j/(h-1)}'    interpolate_tri-mesh3.jpg

É claro que, se as cores produzem um gradiente razoavelmente consistente, a interpolação 'mesh' também produz um gradiente razoavelmente consistente. |

  magick \( xc:blue xc:navy +append \) \
          \( xc:black xc:black +append \) -append \
          -size 100x100 xc: +swap    -interpolate Mesh \
          -fx 'v.p{i/(w-1),j/(h-1)}'    interpolate_tri-mesh4.jpg

Como você pode ver, o resultado é um gradiente bastante razoável, embora, olhando com atenção, você consiga notar a junção diagonal dos dois triângulos separados. A mudança não é tão suave quanto a bilinear (que também não é exatamente suave), mas estas tampouco tentam preservar as bordas nítidas em imagens redimensionadas ou distorcidas.

Catrom (Catmull-Rom)

A opção 'Catrom' de "[-interpolate](https://imagemagick.org/command-line-options/#interpolate)" (geralmente conhecida de forma imprecisa como interpolação 'BiCubic') é mais complexa na determinação das cores de uma consulta de ponto. Basicamente, ela não olha apenas para as cores nos cantos da área entre pixels, mas vai além e olha para as cores para além desses pixels vizinhos mais próximos. Um total de 16 pixels em uma área 4x4 ao redor do ponto de amostragem. Basicamente, ela ajusta uma curva a toda a área envolvida, de modo a determinar a melhor cor geral a usar. Aqui está um diagrama que provavelmente explica melhor o processo...

E aqui estão as cores interpoladas para as nossas quatro cores padrão. |

  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap   -interpolate Catrom \
          -fx 'v.p{i/(w-1),j/(h-1)}'    interpolate_catrom.jpg

A imagem acima pode parecer muito semelhante a uma interpolação '[Bilinear](#bilinear)', porém o resultado tem uma curva de mesclagem mais suave em vez de linhas retas para produzir a cor interpolada. O que esta imagem não mostra, contudo, é o efeito dos demais pixels que cercam os nossos quatro vizinhos próximos. Para isso precisamos olhar uma área um pouco maior. Neste exemplo específico (muito pequeno), os pixels vizinhos são controlados pela opção de Pixel Virtual.

  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap -interpolate Catrom -virtual-pixel edge \
          -fx 'v.p{3*i/(w-1)-1, 3*j/(h-1)-1}'   interpolate_catrom_edge.jpg
  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap -interpolate Catrom -virtual-pixel White \
          -fx 'v.p{3*i/(w-1)-1, 3*j/(h-1)-1}'   interpolate_catrom_white.jpg
  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap -interpolate Catrom -virtual-pixel Black \
          -fx 'v.p{3*i/(w-1)-1, 3*j/(h-1)-1}'   interpolate_catrom_black.jpg

| Em uma imagem real, os efeitos dos Pixels Virtuais geralmente afetam apenas os resultados próximos às bordas da imagem. Como esta imagem tem apenas 2 pixels de largura, o exemplo acima é fortemente afetado. Não é esse o caso em imagens maiores e mais típicas.
---|---
Como você pode ver, a curva é fortemente influenciada pelas cores vizinhas, resultando em uma mudança de cor muito abrupta e nítida, ou em uma mudança de cor mais mesclada conforme definido pelas cores vizinhas. No entanto, você também pode observar que mudanças fortes nas cores dos pixels vizinhos podem produzir pequenas áreas com a inversa ou negativa dessas cores. Isso é um Artefato de Ringing e tipicamente só é visto em bordas extremamente nítidas de cores complementares em uma imagem real. | _Esse efeito de ringing em bordas de cor muito muito fortes pode acabar ceifado, resultando em uma linha de pixels horríveis. Esse problema pode ser evitado fazendo os redimensionamentos e a interpolação em um espaço de cor diferente do 'RGB', como os espaços de cor 'Lab' ou 'Luv'.

Para mais informações e exemplos deste problema, veja Redimensionamento no espaço de cor LAB.

_
---|---
| _Note que 'BiCubic' (o Filtro Cúbico interpolado) refere-se a uma família muito grande de filtros e, como tal, é muito impreciso em seu significado. Ainda assim, continua disponível, mas seu uso é desaconselhado, em favor de nomes mais exatos.

Depois do IM v6.7.7-7, 'BiCubic' é simplesmente um alias para 'Catrom', que é tipicamente considerado um bom 'interpolador cúbico' (b=0, c=1/2). Você deve usar o nome 'Catrom' em vez de 'BiCubic' para deixar claro o que está usando para interpolação.

Antes do IM v6.7.7-7, 'BiCubic' na verdade usava um filtro 'Cardinal Cubic' extremo (b=0, c=1) que tem um efeito de ringing negativo excessivamente forte. Isso foi completamente substituído por 'Catrom' e não está mais disponível como função interpolativa.

Antes do IM v6.3.5-3, 'BiCubic' era implementado como um interpolador cúbico 'Spline' muito desfocado. Esse filtro foi renomeado nesta versão do ImageMagick. (veja a seguir)

_
---|---

Spline

O método de interpolação 'Spline', assim como '[Catrom](#catrom)' acima, também usa os 16 pixels mais próximos. No entanto, esta é uma interpolação muito desfocada, semelhante à gaussiana. |

  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap   -interpolate spline \
          -fx 'v.p{i/(w-1),j/(h-1)}'    interpolate_spline.jpg

Como você pode ver, as cores nos cantos da interpolação 'Spline' acima ficam esmaecidas, pois a superfície interpolada não passa de fato pela cor original desses pixels. Essencialmente ela é excessivamente 'desfocada' e é mais corretamente conhecida como uma superfície 'B-Spline'. A superfície ainda é um tipo de Filtro Cúbico (b=1, c=0), pois é gerada usando uma técnica de curvas cúbicas por partes. No entanto, essa curva apenas se aproxima das cores originais dos pixels, especialmente em áreas de fortes mudanças de cor. Ou seja, uma consulta interpolada de uma posição de pixel inteira exata não retornará a cor real daquele pixel, mas um desfoque da cor com os pixels vizinhos. Isso é frequentemente visto como algo ruim, mas pode ser usado como uma função de suavização geral. Assim como '[Catrom](#catrom)', ela também é afetada pelos pixels vizinhos.

  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap -interpolate Spline -virtual-pixel edge \
          -fx 'v.p{3*i/(w-1)-1, 3*j/(h-1)-1}'   interpolate_spline_edge.jpg
  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap -interpolate Spline -virtual-pixel White \
          -fx 'v.p{3*i/(w-1)-1, 3*j/(h-1)-1}'   interpolate_spline_white.jpg
  magick \( xc:red xc:blue +append \) \
          \( xc:yellow xc:cyan +append \) -append \
          -size 100x100 xc: +swap -interpolate Spline -virtual-pixel Black \
          -fx 'v.p{3*i/(w-1)-1, 3*j/(h-1)-1}'   interpolate_spline_black.jpg

| Em uma imagem real, os efeitos dos Pixels Virtuais ocorrem apenas nas bordas da imagem. Com pixels reais cercando a área entre pixels a partir da qual a consulta está sendo feita.
---|---
Aqui você pode ver os efeitos do esmaecimento de cor que resulta do mau ajuste das curvas 'spline' às cores dos pixels. Os resultados são, em geral, bordas mais difusas nas áreas coloridas e nas linhas finas. No entanto, elas também nunca exibirão qualquer efeito de 'ringing' negativo que você pode obter com uma interpolação '[Catrom](#catrom)'.

Fundo da Interpolação

Como os efeitos da interpolação frequentemente se estendem por áreas maiores, aqui está uma ampliação dos quatro principais métodos de interpolação com pixels vizinhos brancos ou pretos.

  for method in   bilinear mesh catrom spline  ; do
    for vpixel in   white black  ; do
      magick \( xc:red xc:blue +append \) \
              \( xc:yellow xc:cyan +append \) -append \
         -size 100x100 xc: +swap -interpolate $method -virtual-pixel $vpixel \
         -fx 'v.p{3*i/(w-1)-1, 3*j/(h-1)-1}' ip_area_${method}_$vpixel.jpg
    done
  done

Bilinear	Mesh	Catrom	Spline

Como você pode ver, a cor de fundo vizinha não tem efeito real sobre as cores interpoladas por '[bilinear](#bilinear)'. Parece que ela é apenas sobreposta a qualquer cor de fundo presente. Você pode, no entanto, ver como '[mesh](#mesh)' gera bordas mais fortes e nítidas, mas pode decidir inverter a diagonal conforme a cor vizinha, quando esta está envolvida nas bordas da imagem. Observe a junção entre o vermelho e o azul, entre os fundos branco e preto, para ver essa 'inversão'. A curva interpolada de '[catrom](#catrom)' e '[spline](#spline)' é afetada pelos pixels vizinhos. Particularmente nos casos de teste que envolvem cores absolutas. E, por fim, a interpolação '[spline](#spline)' é na verdade apenas um desfoque semelhante ao gaussiano da imagem (usando um sigma de 0.65). Desfoque suficiente para eliminar qualquer efeito de 'ringing' ou de serrilhamento, embora tipicamente seja desfocada demais para a maioria dos usos. Veja Filtros Gaussianos.

Interpolação de uma Linha Rotacionada

Aqui demonstro os diversos métodos de interpolação criando uma imagem de uma linha vertical, usando uma distorção afim para rotacionar a linha em 17 graus e, em seguida, ampliando a visualização para que você possa ver os pixels de anti-serrilhamento gerados.

  magick -size 10x20 xc: -draw 'line 4,0 4,20' \
          -scale 50x100 ip_line_none.gif
  for method in integer nearest bilinear mesh catrom spline;  do
    magick -size 10x20 xc: -draw 'line 5,0 5,20' \
            -interpolate $method -filter point -distort SRT 17 \
            -scale 50x100 ip_line_${method}.gif
  done

Sem Rotação | |
Integer |
Nearest |
Bilinear |
Mesh |
Catrom |
Spline
---|---|---|---|---|---|---|---

Veja Rotacionando uma Linha Fina para um exemplo do uso do operador [-rotate](https://imagemagick.org/command-line-options/#rotate)" dessa forma, e os efeitos resultantes em nível de pixel.

Atualização: A partir do IMv6.7.3-4 o operador rotate agora usa internamente o Operador de Distorção, portanto o acima pode não ser mais verdadeiro.

_
---|---

Interpolação de uma Borda Rotacionada

Os resultados apresentam uma leve diferença quando a borda de uma área está sendo distorcida, em comparação com a de uma única linha de pixels.

  magick -size 10x20 xc: -draw 'rectangle 0,0 4,19' \
          -scale 50x100 ip_edge_none.gif
  for method in  integer nearest bilinear mesh catrom spline; do
    magick -size 10x20 xc: -draw 'rectangle 0,0 4,19' \
            -interpolate $method -filter point  -distort SRT -17 \
            -scale 50x100 ip_edge_${method}.gif
  done

Sem Rotação | |
Integer |
Nearest |
Bilinear |
Mesh |
Catrom |
Spline
---|---|---|---|---|---|---|---

O acima em geral fala por si. 'Bilinear' e 'Mesh' produzem bordas razoavelmente nítidas para rotações gerais, enquanto 'Catrom' produz uma borda mais nítida na imagem distorcida. 'Spline', porém, produz bordas mais difusas. A diferença entre 'Bilinear' e 'Mesh' é extremamente pequena nos casos acima. Os dois métodos só geram diferenças visíveis, de fato, em casos de ampliação extrema durante a operação de distorção. Fora isso, você verá apenas mudanças leves e quase imperceptíveis na intensidade dos pixels.

Pixels Virtuais — Consulta de Cor Fora da Imagem

Muitos operadores frequentemente precisam consultar cores que caem fora dos limites da própria imagem. Isso inclui os operadores de Desfoque de Imagens, Distorção Geral de Imagem, Operadores de Morfologia e Convolução, o Operador de Distorção Geral e até mesmo o antiquíssimo Operador de Implosão. Então, que cor deveria ser retornada se você pedir um pixel em -22,-3? Tal pixel não existe de fato, mas o valor de cor retornado pode ter efeitos de longo alcance sobre o efeito geral do seu processamento de imagem, especialmente as cores resultantes dos pixels próximos à borda real da imagem. A opção "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" define o que o IM deve retornar ao acessar um pixel fora dos limites normais da imagem. Por exemplo, aqui usamos o Operador FX Faça-Você-Mesmo "[-fx](https://imagemagick.org/command-line-options/#fx)" para 'consultar' e exibir todos os pixels dentro e ao redor da pequena imagem, de modo a ver o que a opção padrão "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" retornou. |

  magick -size 70x70 xc:  tree.gif \
                  -fx 'v.p[-19,-19]'  virtual_default.gif

A opção "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" 'Edge ' retorna a cor do pixel real mais próximo da localização 'virtual' solicitada. Ou seja, a cor da 'borda' mais próxima. Desta vez usarei uma Distorção de Imagem com viewport mais rápida para mostrar os pixels virtuais vizinhos, em vez do Operador FX, muito mais lento. O método de distorção "SRT 0" não distorce de fato o resultado da imagem, apenas observa quais pixels o operador de imagem realmente enxerga, especialmente os 'virtuais' que cercam a imagem de origem. |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel Edge -filter point   -distort SRT 0 \
          +repage  virtual_edge.gif

A opção de pixel virtual 'Edge' é a opção padrão, portanto o acima deve ser igual ao exemplo anterior. Essa opção geralmente tem o impacto mais mínimo (em termos de efeitos de borda) ao processar imagens. E é também por isso que foi escolhida como opção padrão. Isso é especialmente importante ao usar o Desfoque ou outros operadores de Morfologia e Convolução que usam uma 'vizinhança' de pixels para o processamento. É importante notar como a cor do pixel de canto acaba por preencher completamente as áreas diagonalmente adjacentes que cercam a imagem real. Isso pode fazer com que um único pixel de canto tenha um grande efeito sobre diversas transformações de imagem. Esse efeito de 'canto' é especialmente perceptível ao desfocar imagens. A opção VP 'Tile ' é muito útil para gerar e garantir que os efeitos de borda do processamento de imagem se enrolem ao redor dos limites da imagem. |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel Tile  -filter point  -distort SRT 0 \
          +repage virtual_tile.gif

Isso permite garantir que as imagens em que se trabalha permaneçam 'ladrilháveis', ou se tornem mais 'ladrilháveis' à medida que a imagem é modificada. Para mais exemplos, veja Modificando Imagens em Ladrilho. 'Mirror ' é muito semelhante a '[tile](#tile)' e pode ser melhor para alguns efeitos do que o padrão '[edge](#edge)'. |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel Mirror -filter point   -distort SRT 0 \
          +repage virtual_mirror.gif

Isso é particularmente útil para reduzir o efeito de borda e de canto de imagens que estão sendo desfocadas. No entanto, também pode gerar outros efeitos. | _Até o IM v6.5.0-1, apenas as imagens diretamente ligadas à imagem original eram espelhadas. Outras cópias virtuais, mais distantes da original, permaneciam sem espelhamento (padrão de ladrilho normal). Isso foi corrigido, de modo que todo o espaço da tela virtual agora é corretamente ladrilhado em espelho, não apenas as cópias virtuais vizinhas.

Isso só se torna importante ao usar o ladrilho em espelho com o Operador de Distorção Geral para ladrilhar em espelho uma área muito grande, como ao Contemplar Horizontes Distantes_
---|---
'Transparent ' apenas retorna a cor transparente para pixels fora dos limites reais da imagem. |

  magick tree.gif -alpha set  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel Transparent  -filter point  -distort SRT 0 \
          +repage virtual_trans.gif

O Operador Alpha 'set' acima é necessário para garantir que a imagem tenha um canal de matte ou alfa, de modo que a cor transparente seja preenchida corretamente. Sem essa opção, o acima poderia retornar uma cor 'preta' em vez de transparente, pois a cor 'none' ou 'preto totalmente transparente' é a cor transparente padrão. Por exemplo, aqui desligo a transparência por engano... |

  magick tree.gif  -alpha off  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel Transparent -filter point  -distort SRT 0 \
          +repage virtual_trans2.gif

A opção 'Transparent' é particularmente útil para distorções de imagem, em que a imagem distorcida será posteriormente 'colocada em camadas' para construir imagens maiores. Por exemplo, Cubos Afins 3D e Caixas em Perspectiva 3D. As opções 'white ', 'gray ' e 'black ' são semelhantes à opção 'Transparent' anterior. Elas apenas retornam aquela cor específica para qualquer pixel que caia fora dos limites. |

  magick tree.gif  -alpha off  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel White -filter point  -distort SRT 0 \
          +repage virtual_white.gif

|

  magick tree.gif  -alpha off  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel Gray -filter point  -distort SRT 0 \
          +repage virtual_gray.gif

|

  magick tree.gif  -alpha off  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel Black -filter point  -distort SRT 0 \
          +repage virtual_black.gif

Se você quiser qualquer outra cor simples, deve definir essa cor na opção "[-background](https://imagemagick.org/command-line-options/#background)" e usar a opção "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" 'Background '. |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel Background -background coral \
          -filter point -distort SRT 0     +repage virtual_bgnd.gif

A opção VP 'HorizontalTile ' foi adicionada no IM v6.4.2-6 como uma forma especial de ladrilhamento útil para distorções "[Arc](distorts.html#arc)" e "[Polar](distorts.html#polar)" completas de 360 graus. A imagem é ladrilhada apenas horizontalmente, enquanto os pixels virtuais acima e abaixo dos ladrilhos são definidos a partir da cor "[-background](https://imagemagick.org/command-line-options/#background)" atual. |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel HorizontalTile  -background coral \
          -filter point -distort SRT 0     +repage virtual_horizontal.gif

Isso permite garantir que as imagens que estão sendo transformadas permaneçam 'ladrilháveis' horizontalmente. Para mais exemplos, veja Modificando Imagens em Ladrilho. A 'HorizontalTileEdge ' (adicionada no IM v6.5.0-1) também ladrilha a imagem horizontalmente pelo espaço virtual, mas replica os pixels da borda lateral pelas demais partes do espaço da tela virtual. |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel HorizontalTileEdge  -background coral \
          -filter point -distort SRT 0     +repage virtual_horizontal_edge.gif

Esses dois métodos VP foram adicionados para um melhor tratamento das distorções de círculo completo '[Arc](../static/img/distorts#arc)' e '[Polar](../static/img/distorts#polar)', em que a imagem em círculo 'se enrola' e se une de ponta a ponta.
De modo semelhante, a opção VP 'VerticalTile ' (também adicionada no IM v6.4.2-6, por completude) ladrilha a imagem apenas verticalmente, com a cor "[-background](https://imagemagick.org/command-line-options/#background)" atual usada para preencher as laterais da imagem. |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel VerticalTile  -background coral \
          -filter point -distort SRT 0     +repage virtual_vertical.gif

A 'VerticalTileEdge ' foi adicionada no IM v6.5.0-1 e replica os pixels da borda lateral pelo restante do espaço da tela virtual. |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel VerticalTileEdge  -background coral \
          -filter point -distort SRT 0     +repage virtual_vertical_edge.gif

No IM v6.5.0-1 foi adicionada a 'CheckerTile ' para ladrilhar uma imagem como se preenchesse um padrão de tabuleiro de xadrez. Os outros quadrados são simplesmente preenchidos com a cor de fundo (que pode ser transparente). |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel CheckerTile  -background coral \
          -filter point -distort SRT 0     +repage virtual_checker.gif

Tornando o fundo transparente e sobrepondo essa imagem a outra imagem totalmente ladrilhada do mesmo tamanho, você pode dispor os dois ladrilhamentos em camadas para produzir um padrão de tabuleiro de xadrez intercalado das duas imagens. |

  magick -size 96x96 tile:balloon.gif \
          \( tree.gif -alpha set  -set option:distort:viewport 96x96 \
             -virtual-pixel CheckerTile  -background none \
             -filter point -distort SRT 0 \) \
          -flatten  virtual_checker_2.gif

Há também algumas opções "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" mais incomuns. 'random ' apenas escolhe um pixel aleatório da imagem para usar. |

  magick tree.gif  -set option:distort:viewport 70x70-19-19 \
          -virtual-pixel Random -filter point   -distort SRT 0 \
          +repage virtual_random.gif

Isso é frequentemente usado com "[-blur](https://imagemagick.org/command-line-options/#blur)" para gerar uma cor média de imagem áspera e mosqueada nos efeitos de borda resultantes que produz. Note que o valor do pixel não é consistente e produzirá um efeito diferente a cada consulta, e até a cada execução da operação, a menos que se forneça ao gerador de números aleatórios uma "[-seed](https://imagemagick.org/command-line-options/#seed)" inicial. Isso é especialmente ruim quando usado com o processamento de imagem por Convolução ou Morfologia, pois cada consulta ao longo da borda da imagem contribuirá com um valor diferente, mesmo que a mesma consulta de pixel tenha sido usada. Contudo, descobri que o padrão aleatório é muito bom para gerar um Horizonte em Perspectiva, pois o padrão apresenta um resultado mais desfocado à medida que você se aproxima do horizonte. O desfoque dá à textura aleatória resultante uma profundidade que, de outro modo, não seria visível ao usar uma simples cor sólida.
'dither ', porém, retorna um padrão de cores com pontilhamento ordenado baseado nos pixels dentro de 32x32 pixels da posição solicitada. Isso significa que, uma vez que você avance além de 32 pixels da imagem, o resultado será novamente apenas a cor do pixel de canto da imagem. É um pouco como uma fusão de '[edge](#edge)' e '[random](#random)'. |

  magick tree.gif  -set option:distort:viewport 120x120-44-44 \
          -virtual-pixel Dither -filter point  -distort SRT 0 \
          +repage virtual_dither.gif

No exemplo acima você pode ver que o amarelo do sol em um canto desta imagem de 32x32 pixels consegue ser selecionado até o canto inferior direito distante, mas não além disso. Ou seja, é o limite da 'vizinhança' de 32 pixels para a seleção de cor do pontilhamento ordenado. Se esta imagem fosse maior, a cor amarela do sol não alcançaria os outros cantos. Este padrão não é 'aleatório' e sempre gerará o mesmo resultado para a mesma imagem. Você poderia pensar nele como uma forma mais ordenada do VP '[random](#random)' perto da imagem, mas que passa a ter um efeito mais parecido com '[edge](#edge)' quando você processa além de 32 pixels da própria imagem.

Pixels Virtuais e Infinitos

Você pode ver os efeitos de "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" com muito mais clareza nos resultados do Operador de Distorção Geral, e especialmente com uma distorção em Perspectiva, que permite criar uma vista distorcida em direção a uma distância infinita. Por exemplo, aqui mostro os resultados de uma opção "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel) dither", em uma vista em perspectiva da árvore. Isso mostra como essa opção pode afetar os pixels retornados até o infinito.

  magick tree.gif -mattecolor DodgerBlue   -virtual-pixel dither \
          -set option:distort:viewport  150x100-50-50 \
          -distort perspective '0,0 9,0  31,0 38,0  0,31 0,18  31,31, 40,18' \
          perspective_dither.gif

Experimente o acima com outras opções "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" para ter uma ideia melhor de como funcionam. Alguns outros exemplos também podem ser vistos em Contemplar Horizontes Distantes. Note que o 'céu' na vista acima é na verdade gerado a partir da opção "[-mattecolor](https://imagemagick.org/command-line-options/#mattecolor)", que é usada pelo distort para representar áreas que são 'Inválidas', neste caso o 'céu' de uma distorção em perspectiva. Ele não veio da opção "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)".

Cores dos Pixels Virtuais

Nenhum dos métodos "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" retorna de fato uma cor diferente ou composta em relação ao que já está presente na imagem, a menos que essa cor tenha sido especificamente solicitada por meio de um dos métodos de cor sólida: '[background](#background)', '[transparent](#transparent)', '[background](#background)', '[black](#black)', '[white](#white)', '[gray](#gray)'; Ou seja, nenhuma cor nova é jamais gerada, embora uma cor específica possa ser adicionada (duas no caso do Operador de Distorção Geral). É claro que, se os pixels solicitados estiverem sendo Interpolados como Pixel ou Reamostrados por Área, como na vista distorcida em perspectiva acima, então esses métodos podem mesclar as cores retornadas conforme a opção "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" escolhida.

Efeitos dos Pixels Virtuais sobre os Operadores

Aqui exploro os efeitos da opção "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" com diversos operadores. "[-blur](https://imagemagick.org/command-line-options/#blur)"... |

  magick -size 70x70 xc:lightblue  -fill black -draw 'circle 35,65 25,55' \
          -virtual-pixel edge   -blur 0x8     vp_blur.png

|

    magick -size 70x70 xc:lightblue  -fill black -draw 'circle 35,65 25,55' \
            -virtual-pixel mirror  -blur 0x8  vp_blur_2.png

Note a seguir como a imagem pode ser contaminada de forma cruzada ao usar "[-blur](https://imagemagick.org/command-line-options/#blur)" com a opção "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" 'tile'. É claro que, se a imagem já fosse ladrilhável de início, isso pode ser desejável. |

  magick -size 70x70 xc:lightblue  -fill black -draw 'circle 35,65 25,55' \
          -virtual-pixel tile  -blur 0x8  vp_blur_3.png

Definir uma cor específica para o "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)" na imagem traz alguns efeitos e possibilidades muito interessantes. |

  magick -size 70x70 xc:lightblue  -fill black -draw 'circle 35,65 25,55' \
          -virtual-pixel background  -background blue \
          -blur 0x8     vp_blur_4.png

|

  magick -size 70x70 xc:lightblue  -fill black -draw 'circle 35,65 25,55' \
          -virtual-pixel transparent  -channel RGBA  -blur 0x8 \
          -background red  -flatten       vp_blur_5.png

Note como o fundo 'red' que coloquei atrás da imagem fica visível ao redor das bordas onde a imagem desfocada resultante fez uso dos pixels virtuais que cercam os pixels reais da imagem. "[-gaussian](https://imagemagick.org/command-line-options/#gaussian)" tem basicamente os mesmos resultados que "[-blur](https://imagemagick.org/command-line-options/#blur)", o que é compreensível, pois são matematicamente idênticos. |

  magick -size 70x70 xc:lightblue  -fill black -draw 'circle 35,65 25,55' \
          -virtual-pixel background   -background blue \
          -gaussian 0x8     vp_gaussian.png

No entanto, "[-radial-blur](https://imagemagick.org/command-line-options/#radial-blur)" (na verdade um desfoque rotacional) produz efeitos de borda mais interessantes... |

  magick -size 70x70 xc:lightblue \
     -virtual-pixel background  -background blue \
     -radial-blur 0x30    vp_radial.png

Este último, com a 'borda transparente' padrão, provavelmente gerará uma borda suave quando usado com ângulos maiores de desfoque radial. Pode produzir uma imagem de sobreposição com 'vinheta' mais limpa ou de borda suave do que outras técnicas. Veja Bordas Suaves e Desfocadas para exemplos do uso deste efeito. Note que "[-motion-blur](https://imagemagick.org/command-line-options/#motion-blur)" pode ser muito mal afetado por efeitos de borda. | Isso é agravado pelo fato de que "[-motion-blur](https://imagemagick.org/command-line-options/#motion-blur)" atualmente não compreende o uso de "[-channel](https://imagemagick.org/command-line-options/#channel)" para limitar seus efeitos a canais específicos.
---|---
|

  magick -size 70x70 xc:none  -virtual-pixel edge \
     -fill yellow  -stroke red  -strokewidth 3 -draw 'circle 45,55 35,45' \
     -channel RGBA -motion-blur 0x12+65  vp_motion.png

|

  magick -size 70x70 xc:none  -virtual-pixel transparent  \
     -fill yellow  -stroke red  -strokewidth 3  -draw 'circle 45,55 35,45' \
     -channel RGBA -motion-blur 0x12+65  vp_motion_2.png

|

  magick -size 70x70 xc:none  -virtual-pixel background -background blue \
     -fill yellow  -stroke red  -strokewidth 3  -draw 'circle 45,55 35,45' \
     -channel RGBA -motion-blur 0x12+65  vp_motion_3.png

Efeitos de Implosão dos Pixels Virtuais

Aqui estão alguns exemplos mais interessantes de várias implosões de valor alto (>1.0) usando diversas opções "-virtual-pixel".

  for v in edge tile mirror dither random gray; do
    for i in 2 5 10 50 500; do \
      magick koala.gif -virtual-pixel $v \
              -implode $i  implode_${v}_${i}.gif
    done
  done

Implode	Edge	Tile	Mirror	Dither	Random	Gray
2
5
10
50
500

A natureza 'pontilhada' dos resultados acima é um resultado direto da 'amostragem interpolada' direta usada pelo operador "-implode". Veja Consulta Interpolada Direta. Isso pode mudar em uma versão futura do IM, usando a Reamostragem por Área. Por ora, você precisará usar uma técnica de Superamostragem para melhorar os resultados. A opção 'edge' é a opção mais comum e padrão que se usa, para evitar a maioria dos efeitos estranhos. As outras (exceto 'background') essencialmente produzem um padrão replicado a partir dos pixels existentes na imagem, e os efeitos são muito variáveis. Note também como o argumento requer um aumento exponencial de tamanho para aumentos semelhantes nos efeitos. Além disso, para argumentos maiores que cerca de 200, pode aparecer um círculo preto no centro da imagem resultante. Isso é causado pelo limite matemático do computador ser atingido. Usar valores tão grandes é um efeito que não recomendamos que você use.

Manchas Aleatórias de Cor Sólida

Desfocando uma tela "plasma:fractal" e, em seguida, reduzindo as cores a valores muito baixos, você pode produzir imagens simples contendo áreas aleatórias de cores diferentes. No entanto, os resultados são muito variáveis conforme o número final de cores solicitado e a opção de Pixel Virtual (veja acima). Eu tinha duas opções para a imagem aleatória inicial neste experimento. Uma Imagem de Plasma Fractal e uma Imagem de Ruído Aleatório. A Imagem Aleatória, por sua natureza, produz uma imagem que pode (com a opção 'tile' de "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)") criar uma imagem mais ladrilhável. Enquanto a Imagem de Plasma tende a criar bordas retangulares em suas manchas de cor. Por outro lado, a Imagem de Plasma produz manchas, ou bolhas, de cores pastel bem agradáveis. Ao passo que a Imagem Aleatória tende a produzir tons horríveis de cinza médio. Por isso escolhi usar a Imagem de Plasma para estes experimentos.

  magick -size 80x80 plasma:fractal -normalize   spot_start.gif
  #magick -size 80x80 xc: +noise Random  \
  #        -virtual-pixel tile  -blur 0x5  -normalize  spot_start.gif

  for n in 2 3 4 5; do
    for v in  edge mirror tile white black; do
      magick spot_start.gif -virtual-pixel $v -blur 0x10 \
              +dither -colors $n  spot${n}_${v}.gif
    done
  done

Num Colors	Edge	Mirror	Tile	White	Black
2
3
4
5

As três primeiras imagens têm efeitos muito específicos sobre como as 'manchas' de cor interagem com as bordas da imagem. 'Edge' e 'Mirror' tendem a fazer com que as cores se juntem às bordas em ângulos de 90 graus. Uma opção 'Random' ou 'Dither' tem ligações semelhantes, mas mais fortes, das bolhas de cor às bordas da imagem, embora ambas também introduzam alguns efeitos de borda nítidos próximos às bordas da imagem. Um segundo ciclo de blur-quantize pode ser necessário para limpar e suavizar as bordas das manchas. A opção 'Tile' tende a permitir que as manchas se enrolem ao redor da imagem. No entanto, como a imagem de origem Plasma não é ela própria ladrilhável, o resultado é uma mudança geral de cor perto da borda retangular. Se a imagem ladrilhável Random fosse usada como origem, então as manchas de cor ignorariam completamente as bordas da imagem. Usando uma opção de virtual-pixel de fundo 'White' ou 'Black', as manchas de cor tendem a ficar centralizadas na própria imagem. O quão bem essa 'centralização' ocorre depende de quão diferente a imagem aleatória original era em relação à 'cor de fundo' usada. O tamanho do "[-blur](https://imagemagick.org/command-line-options/#blur)" basicamente afeta o tamanho e a suavidade das bolhas. Um desfoque pequeno produz muitas manchas pequenas; um desfoque grande, como o que usamos acima, produz uma única mancha de cor mais circular.
Você também pode produzir um conjunto completamente diferente de cores e interações usando um espaço de cor de quantização de cor diferente. Por exemplo, aqui repito o último exemplo (reduzindo a 5 cores) de cima, mas uso alguns espaços de cor "[-quantize](https://imagemagick.org/command-line-options/#quantize)" mais incomuns para a seleção de cor. (Veja Quantização de Cor e Espaço de Cor)

Color Space	Edge	Mirror	Tile	White	Black
RGB
YIQ
HSL
XYZ
OHTA

Lembre-se de que todas as imagens acima foram geradas a partir da mesma imagem de origem aleatorizada. Os diferentes efeitos que você vê são o resultado de diferentes formas de reduzir o número de cores na imagem. Você pode ver como a opção "[-virtual-pixel](https://imagemagick.org/command-line-options/#virtual-pixel)", que define quais cores de pixel o blur enxerga nas áreas além dos limites da imagem, tem forte influência sobre as formas das áreas de cor.

Uso dos Argumentos de Annotate

O IM Versão 6 forneceu uma nova opção de linha de comando para desenho de texto, "[-annotate](https://imagemagick.org/command-line-options/#annotate)", que contorna o método mais antigo "[-draw](https://imagemagick.org/command-line-options/#draw)" para usar a API Annotate() diretamente. Isso oferece alguns novos recursos aos usuários de linha de comando. Para este exemplo, escolho a fonte Arial Black, por seu traçado reto, de modo que a rotação fique bastante clara. |

    magick -font ArialB -pointsize 24 -gravity center \
            -size 55x55 xc:white -annotate 0x0+0+0 'Text' \
            annotate_source.jpg

O formato desta opção é...

**-annotate {_SlewX_}x{_SlewY_}+{_X_}+{_Y_} 'Text String' **

O deslocamento X e Y acima é a posição, afetada pela gravity, do texto anotado que será desenhado. No entanto, SlewX e SlewY representam uma forma de rotação. Se esses dois valores forem iguais, uma rotação normal é realizada. Mas, se forem diferentes, alguns efeitos muito interessantes podem resultar..

Como você pode ver, alguns dos argumentos resultaram em nenhum texto sendo desenhado, basicamente quando o texto teria sido desenhado todo em uma única linha. Isso é esperado. No entanto, você pode ver que podemos desenhar o texto invertido, espelhado, rotacionado, em itálico, de todas as maneiras possíveis. Um operador de imagem muito útil.

Splice: Criando um Novo Operador de Imagem

Logo após o primeiro lançamento da versão 6 do ImageMagick, desenvolveu-se uma discussão em resposta a uma pergunta. A pergunta envolvia adicionar espaço extra (linhas e colunas) no meio de uma imagem. O exemplo abaixo é o conjunto complexo de comandos que resultou dessa discussão, usando a magia poderosa do IM versão 6, e detalhava exatamente o que deveria ser feito. A partir deste exemplo, o operador "[-splice](https://imagemagick.org/command-line-options/#splice)" foi criado (para detalhes, veja os exemplos em Inserindo e Cortando Linhas e Colunas em Imagens). Assim, esta linha de comando são as operações que definem este novo comando, e ambos devem funcionar exatamente da mesma forma. |

  magick rose: -size 20x10 xc:blue   -background blue \
          \( -clone 0  -crop 40x0 +repage +clone -insert 1 +append \) \
          -swap 0,-1 +delete +repage \
          \( -clone 0  -crop 0x30 +repage +clone -insert 1 -append \) \
          -delete 0 -delete 0 +repage  splice_rose_seq.gif

No exemplo acima, dividimos a rose em muitas fatias verticais, depois inserimos uma imagem de espaçamento nessa sequência, antes de concatená-las todas novamente. Basicamente, adicionamos uma coluna vertical de pixels à imagem rose. Em seguida, substituindo a imagem original pela modificada, repetimos as mesmas operações, mas horizontalmente. Uma pequena limpeza das imagens de trabalho e pronto. Este exemplo também destacou à lista de discussão a utilidade do novo tratamento ordenado de linha de comando e das operações de sequência de imagens da versão 6 do ImageMagick. Em versões mais antigas do IM, isso teria exigido um grande número de comandos separados e imagens temporárias para alcançar o mesmo resultado.

Border, Frame e o uso de BorderColor

Há um debate de que "[-bordercolor](https://imagemagick.org/command-line-options/#bordercolor)" só deveria ser usado para adicionar uma borda às imagens com "[-border](https://imagemagick.org/command-line-options/#border)" ou "[-frame](https://imagemagick.org/command-line-options/#splice)". Ou seja, muitos usuários acham que ele não deveria ser usado para definir o fundo atrás de imagens com transparência. Por exemplo, no IM isso define as áreas transparentes da imagem star como "[-bordercolor](https://imagemagick.org/command-line-options/#bordercolor)" e ignora completamente a opção de cor "[-background](https://imagemagick.org/command-line-options/#background)". |

  magick star.gif -bordercolor LimeGreen   -background Gold \
                   -border 10       star_border.gif

A principal razão pela qual "[-bordercolor](https://imagemagick.org/command-line-options/#bordercolor)" é usado para definir o fundo de imagens transparentes é que isso faz o "magick montage" sair de forma agradável quando lhe é dado um conjunto aleatório de imagens que podem conter transparências, com configurações mínimas por parte do usuário. |

    magick montage star.gif  -frame 6  -geometry '64x64+5+5>' star_montage.gif

Se a transparência fosse preservada, os resultados do "magick montage" acima não ficariam nem de longe tão bons. Isso não significa que você não possa preservar a transparência das imagens ao usar os operadores "[-border](https://imagemagick.org/command-line-options/#border)" ou "[-frame](https://imagemagick.org/command-line-options/#splice)". Significa apenas que você precisa fornecer uma opção "[-compose](https://imagemagick.org/command-line-options/#compose)" adicional para dizer ao IM que preserve a transparência. |

  magick star.gif  -bordercolor LimeGreen \
          -compose Copy  -border 10   star_border_copy.gif
  magick montage star.gif  -bordercolor LimeGreen \
          -compose Copy -background None    -frame 6 \
          -geometry '64x64+0+0>'   star_montage_copy.gif

Para mais informações sobre como preservar o fundo transparente de uma imagem ao adicionar um "[-border](https://imagemagick.org/command-line-options/#border)" ou "[-frame](https://imagemagick.org/command-line-options/#splice)", veja adicionando bordas. E, para o "magick montage", veja exemplos de tratamento de fundo e transparência do montage. Uma alternativa que foi sugerida era definir o fundo da área da imagem nesses operadores como a cor "[-background](https://imagemagick.org/command-line-options/#background)", mas isso interfere no seu uso no "magick montage". Você pode, é claro, sempre Remover a Transparência da imagem por conta própria, antes de qualquer moldura ou borda extra ser adicionada. Nesse caso, o uso de "-compose Copy" torna-se irrelevante. |

  magick montage star.gif -background Gold -alpha remove \
          -frame 6  -geometry '64x64+5+5>' -size 16x16 \
          -bordercolor LimeGreen  -background SeaGreen \
          star_montage_texture.gif

É simplesmente muito mais fácil usar uma opção "[-compose](https://imagemagick.org/command-line-options/#compose)" para preservar a transparência, em vez de fazer com que a borda a preserve e cause outros problemas. Isso pode não ser óbvio para usuários novos, mas é justamente esse o propósito destas páginas de exemplos.

Teste dos Operadores de Lista

Todos os comandos a seguir devem produzir exatamente a mesma imagem, mas todas as imagens são produzidas de maneiras ligeiramente diferentes, demonstrando os novos Operadores de Lista de Imagens da versão 6 do IM. |

  magick eye.gif news.gif  storm.gif  +append  list_test_01.gif

|

  magick \( \) eye.gif news.gif  storm.gif  +append  list_test_02.gif

|

  magick eye.gif news.gif  storm.gif \( \) +append  list_test_03.gif

|

  magick \( eye.gif news.gif  storm.gif \) +append  list_test_04.gif

|

  magick \( eye.gif news.gif  storm.gif  +append \) list_test_05.gif

|

  magick eye.gif \( news.gif storm.gif +append \) +append list_test_06.gif

|

  magick \( eye.gif news.gif +append \) storm.gif +append  list_test_07.gif

|

  magick \( storm.gif -flop \) \( news.gif -flop \) \( eye.gif -flop \) \
          +append -flop  list_test_08.gif

|

  magick \( eye.gif -rotate 90 \) \( news.gif  -rotate 90 \) \
          \( storm.gif -rotate 90 \) -append  -rotate -90   list_test_09.gif

|

  magick eye.gif tree.gif news.gif storm.gif   -delete 1 \
          +append list_test_10.gif

|

  magick eye.gif tree.gif news.gif storm.gif  -delete -3 \
          +append list_test_11.gif

|

  magick eye.gif news.gif storm.gif tree.gif   +delete \
          +append list_test_12.gif

|

  magick news.gif storm.gif eye.gif  +insert  +append list_test_13.gif

|

  magick eye.gif storm.gif news.gif  -insert 1  +append list_test_14.gif

|

  magick news.gif eye.gif storm.gif   -swap 0,1  +append list_test_15.gif

|

  magick storm.gif news.gif eye.gif   -swap 0  +append list_test_16.gif

|

  magick eye.gif storm.gif news.gif   +swap  +append list_test_17.gif

|

  magick eye.gif storm.gif news.gif   \( -clone 1 \) \
          -delete 1   +append list_test_18.gif

|

  magick eye.gif -negate \( +clone -negate \) news.gif  storm.gif \
          -delete 0   +append list_test_19.gif

|

  magick storm.gif news.gif eye.gif \( -clone 2,1,0 \) \
          -delete 2,1,0   +append  list_test_20.gif

|

  magick storm.gif news.gif eye.gif \( -clone 2-0 \) \
          -delete 0-2   +append  list_test_21.gif

|

  magick {balloon,medical,present,shading}.gif  -delete 0--1 \
          {eye,news,storm}.gif   +append  list_test_22.gif

|

  magick balloon.gif -delete 0,0,0,0,0,0,0,0,0 \
          eye.gif news.gif  storm.gif  +append  list_test_23.gif

|

  magick eye.gif balloon.gif news.gif storm.gif \
          -delete 1,1,1,1,1   +append  list_test_24.gif

|

  magick {balloon,medical,present,shading}.gif {eye,news,storm}.gif \
          -delete 0--4   +append   list_test_25.gif

|

  magick eye.gif news.gif storm.gif \
          -delete 0--4   +append   list_test_26.gif

|

  magick storm.gif news.gif eye.gif -reverse +append  list_test_27.gif