Exemplos de ImageMagick -- Quantização de Cor e Pontilhamento

Prefácio e Índice dos Exemplos de ImageMagick

Introdução à Redução de Cores (o que está envolvido)

As Cores em uma Imagem (quais cores são usadas por uma imagem)

• Extraindo as Cores da Imagem

• Comparando Duas Cores

  Quantização de Cores (reduzindo o número de cores em uma imagem)

• O Operador de Quantização de Cores

• Quantização de Cores e Espaço de Cor
• A Quantização não Preserva as Cores

• Quantização de Cores e Transparência

  Pontilhamento por Correção de Erro (ou Pontilhamento Pseudoaleatório)

• Métodos de E-Dither

• Como Funciona um E-Dither
• E-Dither é Sensível a Mudanças
• Salpicos de Pixel do E-Dither
• Imagens Bitmap Monocromáticas Pontilhadas
• Quantização em Duas Cores
• Pontilhamento com Mapas de Cores Predefinidos
• Mapa de Cores Comum ou 'Melhor'
• Usando Cores Web-Safe
• Mapas de Cores Uniformes
• Mapa de Cores Uniforme 332
• Mapa de Cores TrueColor de 16 bits ou 556
• Mapas de Cores Uniformes com Correção de Gama

• Posterizar, Recolorir Usando um Mapa de Cores Uniforme

  Métodos de Pontilhamento por Limiar

• Imagens por Limiar

• Pontilhamento Aleatório com Limiar

  Pontilhamentos de Padrão Ordenado (Usando um mapa de limiar em mosaico)

• Pontilhamento por Difusão de Pixels

• Pontilhamentos por Meio-Tom Digital
• Pontilhamento por Deslocamento de Meio-Tom
• Mapas de Limiar XML
• Pontilhamento Ordenado com Níveis de Cor Uniformes

• Melhores Resultados de Pontilhamento Ordenado

  Faça Você Mesmo: Padrões de Pontilhamento e Mapas de Limiar (pontilhe imagens à sua maneira)

• Padrões de Pontilhamento Bitmap com Múltiplas Imagens

• Mapas de Limiar para Pontilhamento Ordenado DIY
• Pontilhamento DIY com Linhas Horizontais
• Pontilhamento com Padrões de Símbolos

Reduzir o número de cores ou substituir cores específicas é uma etapa muito complexa e difícil no Processamento de Imagens, e é esse o tema tratado nestas páginas de exemplo. Isso inclui determinar quais cores usar (quantização de cores) e como dispor essas cores na imagem (pontilhamento e padronização). Inclui também a geração de imagens bitmap ou de duas cores e até o tratamento de transparência booleana (ligado/desligado). Isso é tão importante que a redução ou quantização de cores muitas vezes acontece automaticamente e nos bastidores, apenas para que o ImageMagick possa realizar sua tarefa primária original de converter imagens de um formato de arquivo para outro, com menos cores, como os formatos GIF, XPixmap e XBitmap. Saber como isso funciona pode dar a você maior controle do processo, de forma a melhorar a imagem resultante armazenada em um formato de arquivo específico.

Introdução à Redução de Cores

A redução de cores é um aspecto muito importante do ImageMagick. Por exemplo, para converter com magick uma imagem JPEG ou PNG contendo milhões de cores em uma imagem GIF contendo no máximo 256 cores, você realmente precisa ser capaz de reduzir as cores de forma eficiente e eficaz. Muitas vezes, durante uma conversão de formato de imagem, isso acontece automaticamente nos bastidores, mas há outros momentos em que você quer fazê-lo manualmente. Reduzir o número de cores em uma imagem é tipicamente um processo de três etapas,

1. Primeiro, normalmente você precisa examinar as cores que uma imagem usa. Não só para ver quantas cores são realmente usadas, mas com que frequência determinada cor é usada. Não adianta preservar uma cor específica se apenas um único pixel estiver usando essa cor, embora às vezes você ainda precise fazer isso.
2. Em seguida, você precisa de alguma forma decidir o conjunto final de cores ao qual deseja limitar sua imagem. Você pode querer que o IM tente determinar o 'melhor' conjunto de cores para uma imagem específica. Outras vezes você pode querer algo mais geral e global que possa ser usado em qualquer imagem. Você pode até querer adicionar ou remover especificamente uma cor do conjunto de cores que será usado.
3. E, por fim, você precisa modificar a imagem para usar apenas as cores que selecionou. De preferência, você quer que o resultado fique bom, ou talvez queira que ele comprima, compare ou otimize bem.

Para complicar ainda mais, essas etapas costumam estar interligadas, pois um método de substituição de cores muitas vezes só pode ser aplicado usando conjuntos específicos de cores. E se você estiver usando um conjunto específico de cores, algum tipo de exame de cores não é necessário, ou talvez você precise abrir exceções para cores específicas. Basicamente, embora a redução de cores seja muitas vezes tratada automaticamente nos bastidores, é bom pelo menos estar ciente do que está acontecendo e de quais serão seus efeitos.

Exame de Cores

Esta é provavelmente a menos importante e, embora o IM ofereça métodos para realizar um exame, ela raramente é feita pelos usuários com o objetivo de redução de cores. Deixarei a discussão mais aprofundada para a seção relevante, Extraindo as Cores da Imagem.

Seleção de Cores (Quantização)

Para uma boa visão geral inicial, veja Wikipedia, Color Quantization. Existem quatro métodos básicos para a seleção de cores. Esses quatro métodos de controle de cor: Quantização, Mapa de Cores Predefinido, Cores Uniformes e Limiar; todos têm suas limitações, como você verá. Aqui está um exemplo de cada um desses quatro métodos...

  magick colorwheel.png +dither    -colors 32          color_quantize.gif
  magick colorwheel.png +dither -remap colortable.gif  color_predefined.gif
  magick colorwheel.png +dither   -posterize 3         color_uniform.gif
  magick colorwheel.png \
                  -separate -threshold 50% -combine     color_threshold.gif

O número de cores em cada uma das imagens finais é apenas um conjunto representativo, mas aproximadamente 32 cores em cada caso (exceto o limiar, que tem apenas 8). A partir disso, você pode ter uma ideia do que esperar de cada um deles. Todos os outros métodos têm um conjunto fixo de cores (de acordo com o argumento do operador), independentemente da imagem que está sendo reduzida. Apenas o primeiro método ("[-colors](https://imagemagick.org/command-line-options/#colors)") vai de fato escolher cores com base no conteúdo atual da imagem. Como a imagem de teste é predominantemente branca, muitas cores mais claras são selecionadas. Ele examina as cores em uma imagem usando uma técnica conhecida como "Subdivisão Espacial Adaptativa" utilizando oct-trees. Depois tenta escolher um conjunto específico de cores que melhor corresponda a uma imagem específica, dentro dos limites dados. Veja o Operador de Quantização de Cores abaixo. O "[-remap](https://imagemagick.org/command-line-options/#remap)" permite que você forneça ao IM seu próprio conjunto de cores predefinidas (Veja Mapas de Cores Definidos pelo Usuário). O mapa de cores "[colortable.gif](../static/img/images/colortable.gif)" usado acima é um conjunto de 32 cores especificamente escolhidas para uso em uma antiga X Window Icon Library e foi projetado tendo em mente ícones no estilo de desenho animado. (Veja AIcon Library, X Icon Color Selection para detalhes). Usar "[-posterize](https://imagemagick.org/command-line-options/#posterize)" também pode dividir matematicamente cada canal de cor em um conjunto de níveis ou intensidades de cor, produzindo um 'mapa de cores uniforme'. Ou seja, um mapa de cores com cada canal definido para um conjunto constante de valores ou intensidades. E, por fim, é possível aplicar "[-threshold](https://imagemagick.org/command-line-options/#threshold)" a todos ou a canais de cor específicos da imagem, tornando essencialmente cada canal de cor puramente booleano ou ligado/desligado. Ou seja, cada canal de cor pode receber um valor de zero ou MaxRGB (dependendo do nível 'Q' do IM). Isso, porém, produz apenas um conjunto mínimo de cerca de 8 cores. Um conjunto de cores muito limitado. O limiar também é equivalente a um "[-posterize](https://imagemagick.org/command-line-options/#posterize)" de nível '1', que escolhe 2 cores.

Aplicando um Conjunto de Cores

Uma vez que você tem um conjunto de cores, o próximo problema é aplicar a cor a uma imagem de forma que as cores existentes sejam substituídas pelo conjunto de cores selecionado. Isso é conhecido como 'Pontilhamento' (Dithering), e recebe esse nome por causa de sua natureza de "devo escolher isto ou devo escolher aquilo?", uma questão de um ou outro. Basicamente, a ideia do pontilhamento é colocar pixels de cores diferentes próximos uns dos outros de tal forma a enganar o olho, fazendo-o ver mais cores na imagem do que as que são realmente usadas. Ou seja, a cor naquela área da imagem corresponde mais de perto à cor original da imagem, por causa da forma como o olho humano 'funde' cores vizinhas. Uma das melhores introduções ao Pontilhamento está na Wikipedia, embora você precise pular a seção 'Audio Dithering' no início. Ela apresenta um excelente conjunto de exemplos dos benefícios de usar um padrão pontilhado de pixels quando você tem um conjunto limitado de cores. Os estilos básicos de substituição de cores incluem...

• Mapeamento Direto de Cores (limiar e posterização)
• Pontilhamento Aleatório (colocação puramente aleatória de pixels)
• Pontilhamentos por Correção de Erro (padrões pseudoaleatórios de pixels)
• Pontilhamento Ordenado por Difusão de Pixels (padrões regulares de pixels)
• Meio-Tom Digital (pontos de tamanhos diferentes)

O Mapeamento direto para a cor mais próxima de um dado conjunto é o que foi mostrado acima. Basicamente, você obtém áreas distintas de cores sólidas e imutáveis. Quando isso é aplicado a uma imagem com cor que varia lentamente, como uma foto real do céu, você obtém faixas de cores ao longo da imagem, especialmente no que de outra forma seria um gradiente suave de cores, como em áreas de céu. O resultado é tipicamente considerado como não sendo muito bom. A única ocasião em que o mapeamento direto de cores costuma ser considerado aceitável é para logotipos, símbolos, ícones e imagens no estilo de desenho animado. Na verdade, raramente é uma opção. É por isso que geralmente você precisa desativar o método normal de pontilhamento, se não quiser mapear diretamente as cores em suas imagens. O pontilhamento, porém, tem seu próprio problema. Uma vez que uma imagem é pontilhada, um padrão de cores passa a fazer parte da imagem. Uma vez presente, esse padrão é extremamente difícil de remover. Além disso, geralmente é uma má ideia reaplicar o pontilhamento a uma imagem várias vezes, pois isso apenas degrada a imagem. Por causa disso, a maioria dos exemplos de quantização abaixo geralmente mostrará como criar versões sem pontilhamento para cada técnica. É feito dessa forma para que você possa ver quais seleções de cor estão sendo feitas antes que o pontilhamento oculte essa informação. O Pontilhamento aleatório é o método de pontilhamento mais simples já criado. Também é considerado o pior método de pontilhamento possível. No entanto, tem alguns usos especiais. Dentro do IM, ele funciona apenas com duas cores, então geralmente fica restrito a casos especiais de pontilhamento de bitmap. Para mais, veja Pontilhamento Aleatório com Limiar abaixo. O Pontilhamento por Correção de Erro é geralmente considerado o melhor método geral de pontilhamento de cores em imagens, pois produz a aproximação mais próxima da cor original das áreas da imagem. É também atualmente o único método que consegue pontilhar qualquer conjunto de cores e, como tal, pode ser usado para todas as quatro técnicas de redução de cores. Veja Como funcionam os E-Dithers abaixo para mais detalhes. No entanto, o Pontilhamento por Correção de Erro tem alguns problemas sérios, especialmente no que diz respeito a animações de imagens. As duas últimas técnicas de pontilhamento, Difusão Ordenada de Pixels e Meio-Tom Digital, também são consideradas um bom método, e que funciona bem para animações, mas atualmente não podem usar qualquer conjunto de cores, apenas um conjunto fixo de cores uniformes. Elas fornecem um meio de colorir uma imagem usando padrões, permitindo produzir efeitos interessantes que de outra forma não seriam fáceis de produzir.
Todos esses aspectos da redução de cores são técnicas importantes e, com entendimento, você pode melhorar os resultados de suas operações de imagem, além dos padrões generalizados que o IM oferece. Vale bem a pena estudá-los.

As Cores em uma Imagem

Informações sobre imagens, como o número de cores usadas e a distribuição geral, podem ser muito importantes para programas e scripts que tentam tomar decisões sobre as melhores técnicas a usar. Aqui, examino alguns dos métodos que você pode usar para determinar esse tipo de informação, e não apenas para redução de cores.

Extraindo as Cores da Imagem

Extraindo a tabela de cores

Você extrai uma paleta de cores de uma imagem usando um "[identify](basics.html#identify)" detalhado, usando qualquer um destes métodos, que basicamente fazem exatamente a mesma coisa.

  magick identify -verbose  image.png
  magick image.png miff:- | identify -verbose -
  magick image.png  -verbose -identify null:
  magick image.png  -verbose info:

| A saída de qualquer uma das identificações detalhadas acima não retornará as tabelas de cor ou o histograma se houver mais de 1024 cores! Assim, para imagens grandes e coloridas, isso é uma questão de sorte, e não é recomendado, embora ainda possa ser útil.
---|---
A melhor maneira, porém, é gerar um "[histogram:](files.html#histogram)" da imagem e extrair o comentário incluído no resultado. | |

  magick tree.gif  -format %c  -depth 8  histogram:info:-

|

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

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

O problema com esses métodos é que você recebe uma saída em texto puro das cores, que você precisará analisar de acordo com suas próprias necessidades. No entanto, a partir do IM v6.2.8-8, o operador "[-unique-colors](https://imagemagick.org/command-line-options/#unique-colors)" converte com magick uma imagem em uma menor, contendo apenas um pixel por cor única encontrada na imagem original, todos em uma única linha. Isso significa que você pode converter com magick uma imagem em uma imagem de tabela de cores mais simples, listando cada cor presente. A largura da imagem retorna o número de cores e, se você precisar realmente listar as cores, pode enviá-la para um formato de imagem "[txt:](files.html#txt)". Por exemplo, aqui está a tabela de cores da imagem tree. |

  magick tree.gif -unique-colors -scale 1000%  tree_colors.gif
  magick tree.gif -unique-colors -depth 16  txt:-

Essa tabela de cores reduzida também é muito importante como forma de armazenar um mapa de cores geradas em um arquivo muito pequeno. Esses mapas são particularmente importantes para o operador de redução de cores "[-remap](https://imagemagick.org/command-line-options/#remap)". (Veja Mapas de Cores Predefinidos abaixo) Se você quiser obter uma imagem contendo não apenas as cores de uma imagem, mas as contagens de cores, aqui está uma solução de histograma de cores que foi desenvolvida a partir de uma Discussão no Fórum do IM.

  magick rose: -colors 256 -format %c histogram:info:- |
    sed 's/:.*#/ #/' |
      while read count color colorname; do
        magick -size 1x$count xc:$color miff:-
      done |
        magick - -alpha set -gravity south -background none +append \
                unique_color_histogram.png

Extraindo a Cor Média

A cor média de uma imagem pode ser encontrada muito rapidamente usando "[-scale](https://imagemagick.org/command-line-options/#scale)" para reduzir uma imagem a um único pixel. Aqui, por exemplo, está a cor média da imagem interna "rose:". Eu envio a cor usando o Formato de Escape FX, que retorna uma string de cor que pode ser usada diretamente no IM sem alteração.

  magick rose: -scale 1x1\! -format '%[pixel:s]' info:-

O problema de usar o Escape FX "%[pixel:...]" é que ele pode retornar um nome de cor como 'white' ou 'silver' em vez de um valor RGB. No entanto, você pode simular isso usando três Escapes FX para retornar os valores RGB reais na profundidade de bits desejada. Por exemplo...

  magick rose: -scale 1x1\! \
     -format '%[fx:int(255*r+.5)],%[fx:int(255*g+.5)],%[fx:int(255*b+.5)]' info:-

A partir do IM v6.3.9, há uma série de novos escapes de "[-format](https://imagemagick.org/command-line-options/#format)" que podem ser úteis para extrair informações mais específicas sobre imagens sem precisar analisar uma saída detalhada de "[identify](basics.html#identify)" ou "[info:](files.html#info)". Por exemplo, você pode obter a cor média do canal vermelho obtendo o valor de tons de cinza '%[mean]' da imagem do canal vermelho.

  magick rose: -channel R -separate -format '%[mean]' info:

Extraindo uma Cor Específica

Na linha de comando, há duas formas básicas de extrair a cor de um pixel específico de uma imagem. Use um Escape FX como "%[pixel:...]" ou "%[fx:...]" (veja acima) em uma localização de pixel específica...

  magick rose: -format '%[pixel:p{40,30}]' info:-

Como alternativa, você pode simplificar a imagem usando "[-crop](https://imagemagick.org/command-line-options/#crop)" para recortar um único pixel de seu interesse e usar qualquer um dos métodos anteriores. Por exemplo...

  magick rose: -crop 1x1+40+30 -depth 8 txt:-

Contagem de uma Cor Específica (ou Próxima)

Isso pode ser usado para obter a contagem de pixels ou a porcentagem de uma cor específica. O que você faz é tornar preto tudo o que não é aquela cor e, então, tornar branca aquela cor. Por exemplo, vamos obter o número de cores no sol "yellow" na imagem 'tree'.

  magick tree.gif -fill black +opaque yellow \
                   -fill white -opaque yellow \
                   -print "yellow sun pixels = %[fx:w*h*mean]\n"   null:

Há uma ressalva: não funcionará se a cor sob teste for ela mesma preta. Para lidar com o preto (ou cores muito escuras), troque os preenchimentos para mapear as cores não pretas para branco e depois use Negate nos resultados para gerar a máscara branca de todos os pixels pretos. Lembre-se de que a opção "[-print](https://imagemagick.org/command-line-options/#print)" é equivalente a usar "-format ... -write info:" e pode ser usada em qualquer ponto do seu processamento de imagem. Depois, descartei a imagem indesejada usando o formato de arquivo especial "[null:](files.html#null)". Você também pode salvar a imagem para usá-la como máscara em trabalhos posteriores. Observe que, embora isso funcione bem para imagens pequenas, com imagens muito maiores (como fotos digitais de alta resolução) a 'mean' não será precisa o suficiente para obter uma contagem exata de pixels! Basicamente, o uso da 'mean' acima é adequado para gerar uma proporção, mas não para contagens exatas de pixels. Para obter uma contagem exata de pixels, é melhor usar uma saída de 'comentário' de histograma que tenha contagens exatas de pixels (veja acima). O procedimento acima também pode usar a opção de Fator de Fuzz "[-fuzz](https://imagemagick.org/command-line-options/#fuzz)" antes do operador "[-opaque](https://imagemagick.org/command-line-options/#opaque)" para especificar também cores 'próximas'.

Comparando Duas Cores

Então você tem duas cores específicas e quer compará-las. Você pode usar "magick compare " para obter o RMSE (erro padrão)...

  magick compare -metric RMSE xc:Navy xc:blue null:

Isso é bom, pois lhe dará a distância entre as duas cores, tanto em termos de valores quanto como uma porcentagem normalizada da distância do preto ao branco. No entanto, esse método não trata a transparência corretamente. Por exemplo, comparando 'preto totalmente transparente' vs 'branco totalmente transparente'.

  magick compare -metric RMSE xc:'#0000' xc:'#FFF0' null:

Cores transparentes deveriam, na verdade, ter distância zero, pois totalmente transparente é o mesmo independentemente da cor subjacente. Em vez disso, obtivemos uma distância de hipercubo 4-d). Assim, o método acima de distância de cor só é adequado para comparar cores totalmente opacas.
Em vez de obter uma distância real, você também pode usar um Fator de Fuzz para verificar se duas cores estão próximas.

  magick compare -fuzz 20% -metric AE xc:Navy xc:Blue null:
  magick compare -fuzz 30% -metric AE xc:Navy xc:Blue null:

Lembre-se, porém, de que o resultado será '1' se os pixels não corresponderem (número de pixels com erro). Para obter a distância real do fator de 'fuzz' que separa os valores, você pode usar a métrica 'FUZZ'.

  magick compare -metric FUZZ xc:Navy xc:Blue null:

O valor 'normalizado' mostra que a distância real é de 28,7%. Usar o Fator de Fuzz é diferente de calcular o RMSE quando há transparência envolvida. Isso porque o fator de fuzz é projetado de forma que quaisquer duas cores totalmente transparentes sejam tratadas como iguais. Assim, 'preto totalmente transparente' e 'branco totalmente transparente' são exatamente equivalentes (produzindo um valor de 0 ou nenhum pixel com erro)...

  magick compare -metric FUZZ xc:'#0000' xc:'#FFF0' null:

Outro método de comparação de cores é tentar Substituir Cores com uma porcentagem apropriada de Fator de Fuzz. Por exemplo...

  magick xc:Navy  -fuzz 20% -fill Blue -opaque Blue txt:

Como 'Navy' não mudou para 'Blue', ele é mais de 20% diferente de 'Blue'. Ao passo que

  magick xc:Navy  -fuzz 30% -fill Blue -opaque Blue txt:

Isto mudou a cor para 'Blue', então agora sabemos que 'Navy' está a algo entre 20% e 30% de distância um do outro. Para fazer isso em um script, use algo como...

  fuzz=%1
  color1="red"
  color2="#e00"

  color2=`magick xc:"$color2" -format '%[pixel:s]' info:`
  result=`magick xc:"$color1" -alpha set -channel RGBA -fuzz $fuzz \
            -fill $color2 -opaque $color2 -format '%[pixel:s]' info:`
  if [ "$result" = "$color2" ]; then
    echo "Colors match according to Fuzz Factor"
  else
    echo "Colors DO NOT match"
  fi

As opções especiais "-alpha set -channel RGBA" são importantes para permitir a correspondência aproximada de cores transparentes e quase transparentes.

Quantização de Cores

Operador de Quantização de Cores

O principal instrumento da quantização de cores, e o que é usado internamente para toda redução automática de cores, é o operador "[-colors](https://imagemagick.org/command-line-options/#colors)". Ele implementa um algoritmo de redução de cores por "Subdivisão Espacial Adaptativa" e é um algoritmo de redução de cores extremamente bom. Aqui está um exemplo típico: tenho uma imagem de 'roda de cores' contendo muitas cores, e pedimos ao IM para reduzir o número de cores para apenas 64 cores, usando vários métodos de pontilhamento.

  magick colorwheel.png  -dither None       -colors 64  colors_64_no.gif
  magick colorwheel.png  -dither Riemersma  -colors 64  colors_64_rm.gif
  magick colorwheel.png  -dither FloydSteinberg \
                                             -colors 64  colors_64_fs.gif

Por padrão, o IM usa um 'pontilhamento' para sombrear as cores ao longo da imagem. Isso evita as mudanças bruscas de cor em gradientes que variam suavemente. Se você desativar o pontilhamento (usando 'None' ou a configuração "[+dither](https://imagemagick.org/command-line-options/#dither)") você pode ver claramente quais cores foram mescladas para gerar o que o IM considerou o melhor conjunto de cores para esta imagem específica. Você também pode ver as mudanças bruscas de cor que os gradientes de cor produzirão se o pontilhamento não for feito. É claro que esta imagem usa muito mais cores do que a maioria das imagens usa. Assim, embora um limite de 64 cores seja frequentemente aceitável para muitas imagens, é completamente inaceitável para esta imagem. Em outras palavras, a quantização de cores tenta encontrar o melhor conjunto de cores para uma imagem específica. Aqui estão exemplos de quantização de cores para parte do logo do IM, usando um número extremamente pequeno de cores.

  magick logo: -resize 40% -crop 100x100+105+50\! -normalize  logo.png
  magick logo.png  +dither             -colors 8  colors_8_no.gif
  magick logo.png  -dither Riemersma   -colors 8  colors_8_rm.gif
  magick logo.png  -dither FloydSteinberg \
                                        -colors 8  colors_8_fs.gif

Compare isso com alguns resultados para a imagem de foto embutida "rose:".

  magick rose: +dither             -colors 16 colors_16_no.gif
  magick rose: -dither Riemersma   -colors 16 colors_16_rm.gif
  magick rose: -dither FloydSteinberg \
                                     -colors 16 colors_16_fs.gif

Como você pode ver, imagens do tipo desenho animado exigem muito menos cores do que uma fotografia real para produzir um resultado razoável. | _Apenas um algoritmo de Quantização de Cores, "Subdivisão Espacial Adaptativa", está atualmente implementado no IM, e como funciona muito bem, houve pouca necessidade de adicionar outros. No entanto, com feedback este algoritmo está sendo constantemente aprimorado.

À PARTE: Como referência, o programa "[Gifsicle](http://www.lcdf.org/gifsicle/)" lista vários outros métodos de quantização de cores (usando sua opção "--color-method"). Não faço ideia de quão bem esses métodos de quantização de cores se comparam ao IM. Se você encontrar uma boa referência sobre diferentes métodos de quantização de cores, por favor me envie um e-mail._
---|---

Detalhes Internos da Quantização de Cores

O processo de selecionar o número limitado de cores a usar em uma imagem é chamado de Quantização de Cores, e é um processo muito complexo envolvendo vários fatores. Uma descrição técnica completa dele é dada no site do ImageMagick Algoritmo de Redução de Cores. No entanto, tentarei exemplificar alguns dos aspectos mais importantes disso aqui. Provavelmente o maior fator são as cores reais usadas em uma imagem. Não adianta escolher uma cor específica para uma imagem se há muito poucos pixels 'próximos' dessa cor. Assim, a escolha da cor depende não apenas das cores usadas em uma imagem, mas do número de pixels 'próximos' da cor. Posso demonstrar isso facilmente tentando reduzir duas imagens diferentes de duas cores a uma única cor comum.

  magick -size 4x1 xc:blue -draw 'fill red   point 0,0' \
                                                -scale 20 colors_rb.gif
  magick -size 4x1 xc:red   -draw 'fill blue point 3,0' \
                                                -scale 20 colors_br.gif
  magick colors_rb.gif  -colors 1  colors_rb2.gif
  magick colors_br.gif  -colors 1  colors_br2.gif

Como você pode ver, a única cor final depende não apenas das cores presentes, mas da quantidade de cada cor na imagem.

  magick -size 20x640  gradient: -rotate 90  gradient.png
  magick gradient.png   +dither  -colors 5   colors_gradient.gif

Observe que a quantização de cores é uniforme, dentro do espaço de cor atual.

FUTURE: Just what are the effects of the "[-treedepth](https://imagemagick.org/command-line-options/#treedepth)"  setting?
Mail me if you know

Quantização de Cores e Espaço de Cor

A outra grande influência sobre quais cores são selecionadas é definir exatamente o que queremos dizer com cores que estão 'próximas' ou 'vizinhas'. Isso é definido pelo espaço de cor usado para a quantização (seleção de cores) e é (a partir do IM v6.2.8-6) controlado pela configuração de espaço de cor "[-quantize](https://imagemagick.org/command-line-options/#quantize)". A configuração "[-quantize](https://imagemagick.org/command-line-options/#quantize)" torna-se particularmente importante quando um número muito pequeno de cores é escolhido. Para demonstrar, vamos reduzir uma imagem padrão de 'roda de cores' usando vários espaços de cor diferentes e definindo diferentes 'distâncias de cor'.

  for S in    RGB CMY sRGB GRAY \
              XYZ LAB LUV  \
              HSL HSB HWB  \
              YIQ YUV OHTA ; do \
     magick colorwheel.png   -quantize $S   +dither -colors 16 \
             -fill black -gravity SouthWest -annotate +2+2 $S \
             colors_space_$S.gif; \
  done

Como você pode ver, as cores escolhidas dependem fortemente de como o espaço de cor está organizado. O cubo de cores sRGB (Vermelho, Verde, Azul) geralmente resultará na escolha de pelo menos as cores próximas da cor primária. O espaço de cor sRGB é particularmente bom em escolher cores para imagens do tipo desenho animado e ícones, mas na verdade é um espaço de cor ruim para fotos gerais do tipo imagem. O espaço de cor CMY é exatamente o mesmo que o espaço de cor sRGB, pois os canais de cor são simplesmente negados para converter entre os espaços de cor sRGB e CMY. Assim, as cores da quantização acabam com aproximadamente a mesma solução. | _O espaço de cor CMYK (não mostrado) também produz o mesmo, mas por razões diferentes. Como internamente o canal 'K' e o 'mapa de cores' de uma imagem usam o mesmo ponteiro de dados (VejaCanal de Paleta), o IM o converte de volta para CMY antes da quantização.

---|---
O espaço de cor sRGB, como esperado, produz um resultado similar ao RGB, mas é distorcido para remover a quantidade de cores quase pretas no espaço de cor. Assim, há menos cores para o centro da roda de cores escolher, produzindo uma mancha 'não tão preta' maior. O espaço de cor XYZ também é muito, muito similar ao espaço de cor RGB linear. A grande diferença aqui é que o eixo de cor foi deslocado de modo a conter melhor TODAS as cores possíveis que podemos (e até cores que normalmente não podemos) ver, portanto os dados de cor na roda de cores são comprimidos um pouco mais e, como resultado, as quantizações parecem ficar mais espalhadas. Os espaços de cor LAB e LUV são baseados em eixos de cor diferentes entre si, mas similares. Isso resulta em um arranjo diferente das quantizações de cores. Os espaços de cor especiais envolvendo um canal de 'Matiz', como HSL (Matiz, Saturação, Luminosidade), HSL (Matiz, Saturação, Brilho) e HWB (Matiz, Branco, Preto), todos têm uma representação cíclica de roda de cores da cor como parte de seu espaço de cor. Na verdade, foi usando um espaço de cor HSL que se gerou esta roda de cores. Veja Gerando uma Roda de Cores. | _No momento em que isto foi escrito, o algoritmo de distância de cor que o IM usa não leva em conta a natureza cíclica do 'Matiz' do espaço de cor. O algoritmo para isso é muito diferente. Por causa disso, ocorre uma forte descontinuidade ao longo do caminho 'vermelho', onde o 'Matiz' dá a volta, e resulta em muito poucas cores vermelhas sendo selecionadas no processo de quantização de cores.
---|---
YIQ e YUV são projetados para produzir tons de cores 'pastéis' e de 'meio-tom' mais naturais, muito mais adequados para fotografias e imagens do mundo real envolvendo tons sutis de cores, e especialmente tons de pele. Helmut Dersch observa em seu site que você deve considerar usar um espaço de cor LAB para distorções. | _Em versões mais antigas do IM (especificamente o IM versão 5) o espaço de cor usado para quantização era definido com a opção "[-colorspace](https://imagemagick.org/command-line-options/#colorspace)". No entanto, no IM versão 6 este operador é usado para modificar como as imagens são armazenadas na memória, e como tal não é uma configuração para quantização de cores.

Assim, no IM v6.2.8-6, a configuração "[-quantize](https://imagemagick.org/command-line-options/#quantize)" foi fornecida para fazer esse trabalho. No entanto, é apenas uma configuração para o processo de Quantização de Cores do "[-colors](https://imagemagick.org/command-line-options/#colors)". Ela não fará nada para a substituição e o pontilhamento de cores usando operadores como "[-remap](https://imagemagick.org/command-line-options/#remap)" e "[-posterize](https://imagemagick.org/command-line-options/#posterize)", ou as várias técnicas de pontilhamento._
---|---
Para uma lista completa dos espaços de cor disponíveis, veja o operador "[-colorspace](https://imagemagick.org/command-line-options/#colorspace)". Você pode ver mais efeitos do espaço de cor na seleção de cores observando os exemplos em Pontos Aleatórios de Cor Sólida. Ali a quantização de cores é usada para reduzir o número de cores em uma imagem aleatorizada usando vários espaços de cor. A Quantização NÃO Preserva CoresObserve que em todas as imagens acima uma cor preto-puro nunca é de fato escolhida pela Quantização de Cores. Repare que há apenas um pixel preto puro, e não muitas cores quase pretas na imagem de qualquer forma. Como resultado, o único preto que aparece na imagem final foi adicionado depois como parte da rotulagem da imagem. Até mesmo a imagem do espaço de cor 'GRAY' não produziu uma cor preto-puro. Na verdade, nenhuma das imagens contém qualquer uma das cores primárias ou secundárias, como: vermelho, azul, verde, ciano, magenta! A única exceção a isso é o branco, pois as imagens continham uma boa quantidade de cor branco-puro, tornando-a uma 'cor preferida' (veja abaixo). Esta situação, no entanto, não é um bug! Primeiro, uma cor 'black' geralmente não foi selecionada nos exemplos acima, normalmente porque há muito pouco preto na imagem original, então a Quantização de Cores geralmente não se preocupou muito com cores escuras. Na verdade, ela gerou mais das cores mais claras, pois estas são mais comuns na imagem. Veja a seção anterior para um exemplo específico. Segundo, como a quantização tenta escolher cores que estão próximas do número máximo de pixels de cor existentes em uma imagem, isso é melhor alcançado NÃO correspondendo a uma cor primária ou secundária 'pura', pois estas estão sempre nos extremos do espaço de cor sendo usado. Uma 'cor imperfeita' tenderá a corresponder a mais cores do que uma cor 'primária', então estas são selecionadas com mais frequência. Então deixe-me ser claro... A Quantização de Cores (" -colors") geralmente evitará escolher cores primárias!

A partir do IM versão 6.3, a função de Quantização de Cores foi modificada para tentar incluir cores que são muito comuns na imagem original. Assim, se uma imagem contém uma área de uma única cor (como 'white' no exemplo acima), essa cor geralmente será incluída no mapa de cores final. Isso melhora um pouco a situação, especialmente para imagens do tipo 'desenho animado' ou imagens sobre um fundo de cor sólida. A cor 'sólida' geralmente será escolhida para ajudar a evitar as Manchas de Pontilhamento que veremos abaixo. Soluções para Cor Específica no Mapa de Cores No momento há apenas algumas maneiras de garantir que uma 'cor específica' seja incluída nas cores selecionadas para pontilhamento posterior. Uma maneira é quantizar a imagem normalmente, mas depois gerar o mapa de cores criado (usando "[-unique-colors](https://imagemagick.org/command-line-options/#unique-colors)"). Agora você pode ajustar esse mapa de cores para que sua cor específica seja realmente aquela cor. Por fim, você pode usar o operador Remapear Cores para pontilhar a imagem usando o mapa de cores fornecido. O mapa de cores pode não ser mais as MELHORES cores para a imagem, e provavelmente algumas outras cores também deveriam ser ajustadas, mas será próximo do mapa de cores que você queria. Alternativamente, anexe (ampliando a imagem) grandes áreas das cores específicas que se deseja preservar na imagem, antes de usar "[-colors](https://imagemagick.org/command-line-options/#colors)". A adição da grande 'amostra' de uma cor específica tornará essa cor mais provável de ser escolhida no mapa de cores final. Além disso, todas as outras cores serão então automaticamente ajustadas para se adequarem melhor a esse mapa de cores). Se isso funcionar, as amostras de cores que você adicionou devem permanecer inalteradas (não pontilhadas). Depois você pode então Recortar a imagem para remover as amostras adicionadas. Se não funcionar, então o IM deve ter pelo menos adicionado uma cor próxima da 'cor específica' desejada, de modo que apenas um pequeno ajuste do mapa de cores gerado seja necessário antes de usar Remapear Cores na imagem original. Se você tentar isso, independentemente de sucesso ou fracasso, por favor me diga como foi para você. Idealmente, o que eu gostaria de ver é uma maneira de especificar um pequeno número de cores específicas, que devem fazer parte do mapa de cores final, e então de alguma forma pedir ao IM para escolher as melhores cores para o restante das cores no mapa de cores, para uma imagem específica.

Quantização de Cores e Transparência

Por padrão, o ImageMagick não apenas gera cores totalmente opacas, mas também tenta gerar cores semitransparentes. Dessa forma, imagens contendo sombras transparentes ou outros efeitos de sobreposição não perderão esses efeitos. No entanto, a partir do IM v6.2.6, a quantização de cores que envolve transparência foi modificada para tratar todas as cores totalmente transparentes como sendo a mesma cor. Esta é uma modificação linear, então cores que são apenas meio transparentes também são consideradas mais próximas entre si do que se fossem totalmente opacas. Por causa dessa modificação, a Quantização de Cores do IM ainda gerará cores semitransparentes, mas se concentrará mais nas cores opacas e menos nas cores totalmente transparentes da imagem. Por exemplo, aqui gero um Gradiente Arco-Íris de cores, com a imagem totalmente opaca no topo e totalmente transparente no topo. Exibi as imagens sobre um padrão de fundo para que você possa ver o quão transparente a imagem é.

  magick xc:red xc:yellow xc:green1 xc:cyan xc:blue \
          +append -filter Cubic -resize 100x100\!  -size 100x100 \
          gradient: -alpha off -compose CopyOpacity -composite alpha_gradient.png
  magick alpha_gradient.png  +dither  -colors 256  alpha_colors_256.png
  magick alpha_gradient.png  +dither  -colors 64   alpha_colors_64.png
  magick alpha_gradient.png  +dither  -colors 15   alpha_colors_15.png

Como você pode ver, quando pedimos ao IM para reduzir o número de cores necessárias para esta imagem, ele criou muito mais cores opacas e usou menos cores altamente transparentes para as partes mais translúcidas. O resultado é uma distribuição muito boa das cores selecionadas, especialmente quando o número de cores é muito pequeno. No entanto, assim como apontei acima, não só as cores primárias não são escolhidas, mas a cor totalmente transparente também não será escolhida exatamente pelos mesmos motivos. Na verdade, mesmo cores totalmente opacas não serão escolhidas! Em outras palavras, cada cor nas imagens quantizadas do exemplo anterior é semitransparente. Deixe-me apenas deixar isso claro.

Quando há transparência envolvida, a Quantização de Cores do IM
pode não selecionar nenhuma cor totalmente opaca ou mesmo uma cor totalmente transparente!

É claro que, a partir do IM v6.3 e da correção do bug da 'cor comum' (veja A Quantização NÃO Preserva Cores acima), isso é menos provável de acontecer se a imagem contiver muitas cores opacas e totalmente transparentes, o que é comumente o caso. Como algumas imagens podem conter muitas cores semitransparentes, como imagens envolvendo efeitos de fumaça ou sombras, talvez você queira fazer uma execução de teste, para garantir que uma cor totalmente transparente seja selecionada para inclusão na imagem resultante. Você pode então mapear a cor mais transparente para totalmente transparente e fazer o Remapear Cores você mesmo. Se você realmente quer ter certeza de obter tanto cores totalmente opacas quanto totalmente transparentes na imagem resultante, você pode Normalizar OU Esticar o Contraste do canal alfa. Por exemplo, aqui garanto que as principais seleções de cores sejam feitas opacas usando "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)". Embora isso seja provavelmente um pouco exagerado para uma situação mais normal.

  magick alpha_gradient.png  +dither  -colors 15 \
          -channel A -contrast-stretch 10%  alpha_colors_15n.png

Isso NÃO é um problema para imagens GIF, que não permitem cores semitransparentes, nem para JPG, que não permite transparência, ou mesmo para PNG, que não precisa de quantização para salvar corretamente. Só se torna um problema em casos especiais onde você pode forçar uma redução de cores em uma imagem quando muitas cores semitransparentes estão envolvidas. Lembre-se de que, para o formato GIF, salvar cores semitransparentes é um esforço inútil. Assim, se você planeja fazer a quantização de cores você mesmo para tal formato de imagem, precisa dizer ao IM para ignorar a transparência da imagem ao gerar seu conjunto reduzido de cores. Você pode fazer isso usando a configuração especial de espaço de cor 'transparent' do "[-quantize](https://imagemagick.org/command-line-options/#quantize)".

  magick alpha_gradient.png -quantize transparent \
                            +dither  -colors 15   alpha_colors_15qt.png

Observe como a quantização de cores ignorou completamente a transparência das cores e não tocou de forma alguma no canal alfa das imagens. Isso significa que você pode processar o canal alfa de uma maneira mais apropriada para sua imagem, completamente separada das outras cores. Na verdade, você pode fazê-lo antes ou depois de usar "[-colors](https://imagemagick.org/command-line-options/#colors)" sem problemas. Não fará diferença no resultado. Este espaço de cor de quantização é, portanto, recomendado ao reduzir o número de cores para uma imagem que você planeja salvar em um formato com transparência booleana ou sem transparência, como os formatos de imagem GIF ou XPM. Se você contar o número de cores geradas, também verá que ele gerou exatamente o número de cores solicitado. Assim, se você também precisar de uma cor totalmente transparente (provável), então precisa reduzir o argumento de "[-colors](https://imagemagick.org/command-line-options/#colors)" em pelo menos um, para deixar espaço para ela na tabela de cores final das imagens. Portanto, para lidar com o limite de tabela de cores de 256 cores do formato de arquivo GIF, você precisará reduzir as cores para 255, e não 256, deixando o espaço extra para o índice de cor totalmente transparente, conforme definido pela configuração "[-transparent-color](https://imagemagick.org/command-line-options/#tranparent-color)". Ajuste isso para tamanhos de tabela de cores menores. Este comportamento de quantização é automático quando o IM salva no formato de arquivo GIF, mas é importante quando você precisa fazer a quantização por conta própria ao gerar tabelas de cores globais ou compartilhadas. É claro que você ainda precisa lidar com os pixels semitransparentes, para que estejam corretos conforme o que você deseja que sua imagem pareça.

FUTURE: This last part will probably move to a new section on 'Dithering
Alpha Channel' to be created in the near future. And a reference to this
section added here.

Aqui estão alguns exemplos de pontilhar apenas o canal alfa para apenas uma configuração booleana ou de liga/desliga, sem afetar o restante dos canais de cor da imagem.

  magick alpha_gradient.png \
          -channel A   -threshold 50%       alpha_dither_threshold.gif
  magick alpha_gradient.png \
          -channel A -ordered-dither checks alpha_dither_checks.gif
  magick alpha_gradient.png \
          -channel A -ordered-dither o8x8   alpha_dither_ordered.gif
  magick alpha_gradient.png \
          -channel A -ordered-dither h8x8a  alpha_dither_halftone.gif

  magick alpha_gradient.png -channel RGBA -separate \
          \( +clone -monochrome \) \
          +swap +delete -combine alpha_dither_monochrome.gif
  magick alpha_gradient.png -channel RGBA -separate \
          \( +clone -dither FloydSteinberg -monochrome \) \
          +swap +delete -combine alpha_dither_monochrome_fs.gif
  magick alpha_gradient.png -channel RGBA -separate \
          \( +clone -remap pattern:gray50 \) \
          +swap +delete -combine  alpha_dither_map.gif
  magick alpha_gradient.png -channel RGBA -separate \
          \( +clone -dither FloydSteinberg -remap pattern:gray50 \) \
          +swap +delete -combine  alpha_dither_map_fs.gif

| _Ao pontilhar uma cópia do Canal Alfa, para que você possa pontilhá-lo usando "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)" ou "[-remap](https://imagemagick.org/command-line-options/#remap)", certifique-se de que a imagem seja uma imagem em tons de cinza pura, e não uma máscara de forma contendo transparência. Se não fizer isso, provavelmente acabará com efeitos não lineares do canal alfa ainda presentes.

Há várias maneiras de extrair e restaurar o canal alfa de uma imagem, como uma máscara em tons de cinza, para que você possa pontilhá-lo. O exemplo acima usa a Separação de Canais e a Combinação para fazer isso. Outros métodos usam a Extração de Alfa com a Composição CopyOpacity._
---|---

Pontilhamento por Correção de Erro

Como discutido na introdução, um pontilhamento por correção de erro é geralmente considerado a melhor escolha para produzir a representação mais fiel da imagem original com um conjunto reduzido de cores. Ele também se limita a qualquer paleta de cores predefinida, seja fornecida pelo usuário ou determinada pelas rotinas de quantização de cores do IM. Por causa disso, é a escolha padrão lógica para redução geral de cores fornecida pelos operadores do IM, "[-colors](https://imagemagick.org/command-line-options/#colors)", "[-remap](https://imagemagick.org/command-line-options/#remap)", "[-posterize](https://imagemagick.org/command-line-options/#posterize)" e "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)".

Métodos de E-Dither

A partir da versão 6.4.2-9, o IM agora fornece mais de um tipo de estilo ou método de pontilhamento, que pode ser selecionado usando a configuração "[-dither](https://imagemagick.org/command-line-options/#dither)". Antes disso, o IM estava limitado a uma variação do Pontilhamento de Riemersma, ou Pontilhamento por Curva de Hilbert. que você pode definir usando "-dither Riemersma". Agora você também pode selecionar um Pontilhamento Floyd-Steinberg usando "-dither FloydSteinberg". Você pode ver quais tipos de métodos de pontilhamento foram implementados na sua versão do IM usando...

  magick -list dither

Por exemplo, aqui está a roda de cores pontilhada usando diferentes métodos de pontilhamento.

  magick colorwheel.png -dither Riemersma      -colors 16 dither_riemersma.gif
  magick colorwheel.png -dither FloydSteinberg -colors 16 dither_floyd.gif

Como você pode ver, o pontilhamento Floyd-Steinberg produz um padrão de pontilhamento muito mais uniforme do que o pontilhamento Riemersma padrão. A maior diferença entre eles é como cada um distribui o 'erro de cor' entre pixels vizinhos. Então vamos dar uma olhada em exatamente como um E-Dither funciona.

Como Funciona um E-Dither

Reescrita em Andamento

O método específico usado pelo IM para pontilhamento geral é uma variação do "Pontilhamento por Correção de Erro por Curva de Hilbert". Esta é na verdade uma técnica de pontilhamento muito boa, muito bem definida e razoavelmente rápida. Para uma descrição completa (e uma variação muito similar) veja... Pontilhamento de Riemersma. Basicamente, cada pixel da imagem é examinado em um caminho muito complexo conhecido como 'Curva de Hilbert'. O pixel recebe a cor mais próxima do valor daquele pixel, e qualquer diferença entre a cor original do pixel e a cor selecionada é salva e adicionada aos valores de cor do próximo pixel (que é sempre um pixel vizinho) antes que uma nova cor seja novamente selecionada. Dessa forma, quaisquer variações de cor entre as cores selecionadas e a cor original das imagens são distribuídas para os outros pixels na mesma área. O resultado é que, embora apenas cores específicas sejam atribuídas à imagem final, a mesma cor geral básica para aquela área corresponderá de perto à imagem original. Por exemplo, aqui está uma pequena imagem cinza que pedi ao IM para pontilhar usando um conjunto de cores que não inclui a cor original. A imagem resultante está ampliada para que você possa ver o pixel colorido individual atribuído.

  magick -size 10x10 xc:'#999999' -scale 80x80  dither_not.gif
  magick -size 10x10 xc:'#999999' \
          -remap colortable.gif   -scale 80x80  dither.gif

Como você pode ver, como a cor das imagens originais não estava no mapa de cores especificado, a cor original é aproximada usando um padrão das três cores mais próximas que estavam na tabela de cores fornecida. Se calculássemos a média da cor gerada pelo padrão de pontilhamento acima, obteríamos a cor , que é muito próxima da cor média original das imagens de e esse é todo o propósito do padrão de pontilhamento que foi produzido. No entanto, como o 'caminho' usado para atribuir cores é complexo (embora geralmente permaneça na área local), as atribuições de cor produzem um padrão essencialmente aleatório. Tecnicamente não é aleatório, no entanto, pois a mesma imagem produzirá o mesmo padrão, mas os resultados poderiam muito bem ser aleatórios, ou pelo menos pseudoaleatórios. O pontilhamento "F-S" é na verdade apenas um (o primeiro) de vários 'E-Dithers Rasterizados' que foram desenvolvidos desde seu surgimento no início da década de 1970. É também provavelmente o mais amplamente implementado, embora não seja considerado o melhor. Veja o artigo, Algoritmos de Pontilhamento, para um resumo mais completo de tais algoritmos. A partir do IM v6.4.3 ele também está diretamente disponível no IM, e é implementado de modo a seguir um caminho 'serpentino' linha por linha do topo da imagem até a base.

  magick -size 10x10 xc:'#999999'  -dither FloydSteinberg \
          -remap colortable.gif   -scale 80x80  dither_fs.gif

O "Pontilhamento Floyd-Steinberg", em particular, acho que produz um padrão de pixels mais 'entrecruzado' do que o "Pontilhamento por Curva de Hilbert", e foi de fato projetado para isso. Tal padrão regular pode tornar uma limpeza manual de baixo nível de pequenas imagens de ícones coloridos muito mais fácil. Isso é algo que fiz bastante no meu passado para a Biblioteca de Ícones do Anthony, mas esse tipo de coisa não é mais frequentemente necessário, exceto possivelmente para pequenas imagens monocromáticas.

Problema do E-Dither - Sensível a Mudanças

Um dos maiores problemas que você enfrenta ao usar um pontilhamento por correção de erro é que você obtém um padrão essencialmente aleatório de pixels, que também é altamente sensível a mudanças. Aqui, por exemplo, tome a imagem cinza original e substitua um pixel por uma cor diferente antes de pontilhá-la novamente. O resultado é uma mudança completa do padrão de pontilhamento em cada pixel que está mais adiante no caminho seguido pelo Pontilhamento por Curva de Hilbert.

  magick -size 10x10 xc:'#999999' -draw 'fill #C28 point 2,2' \
          -remap colortable.gif   -scale 80x80   dither_modified.gif
  magick compare dither.gif dither_modified.gif dither_difference.gif

pontilhamento original |
uma mudança de pixel |
|
comparação das mudanças
---|---|---|---

Como você pode ver, apenas adicionar um único pixel à imagem resultou em uma mudança dramática do padrão de pontilhamento! Basta a mudança de um único bit para que a imagem resultante fique diferente, mesmo que a aparência geral de uma imagem (quando não ampliada) permaneça basicamente a mesma (o que é o propósito de um bom algoritmo de pontilhamento, afinal). A imagem do "magick compare" também mostra a extensão da mudança no padrão de pontilhamento. Neste caso, aproximadamente 80% dos pixels receberam uma cor completamente diferente. Em um Pontilhamento por Curva de Hilbert, a mudança de um único pixel na verdade resultará em cada pixel que vem depois sendo possivelmente diferente, o que significa que de 0 a 100 por cento do padrão de pontilhamento poderia ser diferente. Depende apenas de onde na complexa curva de Hilbert a mudança ocorreu. O pontilhamento Floyd-Steinberg, no entanto, só progride pela imagem em uma direção, e assim a mudança de um único pixel modificará o padrão apenas para um lado da mudança.

  magick -size 10x10 xc:'#999999' -draw 'fill #C28 point 2,2' \
          -dither FloydSteinberg -remap colortable.gif \
          -scale 80x80   dither_fs_modified.gif
  magick compare dither_fs.gif dither_fs_modified.gif dither_fs_difference.gif

Pontilhamento FS |
uma mudança de pixel |
|
comparação das mudanças
---|---|---|---

Como você pode ver, ele tem exatamente o mesmo problema. A mudança de um único pixel causando uma mudança quase completa no padrão de pontilhamento para as áreas da imagem processadas após aquele pixel. Ou seja, daquela linha para baixo. Para uma única imagem, o padrão resultante das cores pontilhadas é irrelevante. A cor média do padrão deve dar à imagem a cor apropriada para aquela área da imagem. Mas quando você tem uma animação na qual uma imagem é seguida por outras imagens muito similares, com grandes áreas de cor constante, o padrão de pontilhamento em mudança torna-se muito perceptível e irritante como um 'ruído' de fundo de baixo nível. Por exemplo, aqui gero uma animação de 3 imagens da mesma cor pontilhada, mas com a mudança de um único pixel em cada quadro. Também amplio uma região central para que você possa ver esse padrão em mudança mais claramente.

  magick -size 80x80 xc:'#999999' \
          \( +clone -draw 'fill #C28 point 2,2' \) \
          \( +clone -draw 'fill #28C point 2,2' \) \
          -remap colortable.gif  -set delay 50 -loop 0   dither_anim.gif
  magick dither_anim.gif -crop 10x10+40+40 +repage \
                              -scale 80x80     dither_anim_magnify.gif

Manchas de Pixel do E-Dither

Outro problema com os E-Dithers é que eles podem produzir pixels ocasionais de cor estranha em áreas que de outra forma seriam bastante uniformes em cor. Por exemplo, o pixel verde ocasional em uma imagem em tons de cinza. Ou, como nos exemplos abaixo, um pixel branco em áreas de cor azul lisa e plana. Este é especialmente o caso em imagens grandes que contêm objetos com grande número de cores, e outras áreas de cores sólidas lisas e imutáveis. Isso é especialmente típico de objetos coloridos sobrepostos a fundos de cor plana, como você costuma obter em diagramas e desenhos. Você pode ver um desses pixels de cor estranha na ampliação dos exemplos de teste acima, onde um pixel roxo claro extra foi adicionado a uma boa distância da pequena mudança de um único pixel. Os pixels de cor estranha adicionados ao exemplo acima não são, no entanto, prontamente visíveis e o mapa de cores cobre a imagem muito bem, então os pixels estranhos estão razoavelmente próximos das três cores normais usadas para pontilhar a imagem. Para um exemplo mais extremo, aqui tenho um fundo de gradiente desfocado, que reduzi fortemente as cores para 64 cores para realmente estressar o pontilhamento por correção de erro. |

  magick -size 100x60 xc:SkyBlue \
          -fill DodgerBlue -draw 'circle 50,70 15,35' \
          -fill RoyalBlue  -draw 'circle 50,70 30,45' \
          -blur 0x5  -colors 64     speckle_gradient.gif

Como você pode ver com este mapa de cores altamente reduzido, o pontilhamento por correção de erro fez um trabalho razoavelmente bom em representar o gradiente original. Mas se adicionarmos uma área de branco puro ao exemplo acima... |

  magick -size 100x60 xc:SkyBlue \
          -fill DodgerBlue -draw 'circle 50,70 15,35' \
          -fill RoyalBlue  -draw 'circle 50,70 30,45' -blur 0x5 \
          -fill white -draw 'rectangle 40,40 60,55' \
          -colors 64   speckle_problem.gif

Você pode ver que o E-dither de repente começou a produzir uma dispersão de pixels brancos na área superior da imagem, onde não tínhamos nenhum antes. Aqui está uma ampliação de uma pequena seção para que você possa ver esses pixels mais claramente... |

  magick speckle_problem.gif -crop 15x15+75+0 +repage \
          -scale 90x90    speckle_prob_mag.gif

O pixel de cor estranha é causado por dois fatores. Primeiro, a Quantização de Cores foi forçada a incluir uma única cor branca pura (mas nenhuma outra cor de suavização branco-azul) no mapa de cores final da imagem, permitindo assim que o processo de pontilhamento use essa cor extra. Mas como os E-Dithers acumulam erros lentamente, especialmente em áreas de cores extremas, como na seção superior da imagem acima. Eventualmente os erros se somam a um valor grande o suficiente para tornar a cor adicional a correspondência mais próxima. Assim, de tempos em tempos um pixel branco de alto contraste é gerado para 'corrigir o erro', em uma localização pseudoaleatória. O resultado é um leve salpicado de pixels brancos. Quanto mais lenta a acumulação de erro, mais espalhados ficam esses pixels brancos e mais deslocados eles parecem. A melhor solução é mudar para algum outro formato de imagem que não tenha uma tabela de cores limitada. Por exemplo, converta sua imagem em formato GIF para PNG. Isso evitará a necessidade de quantização de cores (redução) e, portanto, a necessidade de pontilhar as cores reduzidas. A próxima solução é substituir o uso do E-dither por algum outro método de pontilhamento, que 'localize' quaisquer erros, como o Pontilhamento Ordenado. No entanto, isso atualmente não é fácil de aplicar no IM neste momento. Veja Melhores Resultados do Pontilhamento Ordenado, para um desses métodos, até que um mais geral seja encontrado. Se mudar para outro formato de imagem, ou usar um método de pontilhamento diferente, não for prático (e muitas vezes não é), então resta a você tentar corrigir a situação para aquela imagem específica. A melhor correção, para isso é de alguma forma garantir que você tenha outras cores logo fora do grande grupo de cores que está causando a acumulação de erro do E-Dither. No entanto, a Quantização de Cores normal não faz isso. Ela tende a escolher um conjunto de cores médias representando grupos de cores. O que se precisa são cores extras que 'cerquem' as bordas de um grande grupo de cores, em vez de uma simples cor média. Aqui, por exemplo, usei um círculo em vez de um quadrado, para que não apenas uma cor branca pura seja adicionada, mas também várias cores branco-azul. Estas foram adicionadas automaticamente devido à suavização das bordas do círculo, para suavizar sua aparência. |

  magick -size 100x60 xc:SkyBlue \
          -fill DodgerBlue -draw 'circle 50,70 15,35' \
          -fill RoyalBlue  -draw 'circle 50,70 30,45' -blur 0x5 \
          -fill white -draw 'circle 50,45 40,40' \
          -colors 64  speckle_fixed.gif

E uma ampliação da mesma área de antes. |

  magick speckle_fixed.gif -crop 15x15+85+0 +repage \
          -scale 90x90    speckle_fix_mag.gif

Como você pode ver, as cores adicionais fornecem as cores extras, logo fora do gradiente azul-ciano. Agora, embora essas cores extras signifiquem que há menos cores disponíveis para o gradiente propriamente dito, elas fornecem outras cores azul-branco que permitirão ao E-dither corrigir-se mais cedo e com mais frequência, antes que o erro acumulado possa crescer demais. Ou seja, não é que tenhamos impedido o salpicado do E-dither, apenas fornecemos cores melhores para o algoritmo de pontilhamento trabalhar. Se você estudar a parte ampliada da imagem, ainda verá um padrão de salpicos, mas as cores estão mais próximas da cor de fundo, e há muito mais deles produzindo uma distribuição mais uniforme de salpicos. Outra maneira é gerar nossa própria tabela de cores, talvez baseada na que o IM gerou, e adicionar as cores apropriadas para impedir a acumulação de erro. Isso, porém, não é fácil de fazer, especialmente com um espaço de cor tridimensional. Para este exemplo de imagem específico, uma maneira de impedir o 'salpicado' é gerar e pontilhar o fundo separadamente, com um pouco menos de cores do que o necessário, e então sobrepor a caixa branca e sua cor adicional. |

  magick -size 100x60 xc:SkyBlue \
          -fill DodgerBlue -draw 'circle 50,70 15,35' \
          -fill RoyalBlue  -draw 'circle 50,70 30,45' -blur 0x5 \
          -colors 63 \
          -fill white -draw 'rectangle 40,40 60,55'  speckle_perfect.gif

Isso adicionará uma cor 'branca' à imagem, mas o fundo não terá nenhum efeito de salpicado, pois o branco não estava disponível quando o pontilhamento de correção de erro foi usado. O resultado é uma imagem com exatamente 64 cores, e nenhum salpicado. No entanto, isso depende muito da imagem e do que você está tentando alcançar, portanto não é uma solução geral para o problema do salpicado.
Uma alternativa mais geral a adicionar cores extras é tentar remover os salpicos da imagem pontilhada final. Ou seja, limpar a imagem de alguma forma. No entanto, isso é em si um problema complicado, pois você não quer remover pixels que fazem parte do padrão de pontilhamento normal. O que precisamos é encontrar pixels de cor que sejam de alguma forma muito diferentes de todas as cores ao seu redor, mas que também estejam bem isolados de todas as outras cores semelhantes, por alguma distância. Você tem uma solução de filtro de imagem melhor? Resumo Para mim, o salpicado é um problema muito irritante, especialmente para imagens de ícones de desktop que usam uma tabela de cores muito limitada. Eu mesmo frequentemente edito imagens menores de 'ícones' para remover salpicos ou corrigir alguns dos outros efeitos de pontilhamento, como o faixamento vertical. Se você conhece outra solução melhor, por favor me avise.

Imagens de Bitmap Pontilhadas Monocromáticas

O operador "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)" é uma forma especializada tanto do operador "[-colors](https://imagemagick.org/command-line-options/#colors)" para gerar uma imagem de bitmap. É, portanto, um operador ideal para demonstrar não apenas o 'Pontilhamento por Curva de Hilbert', mas também para dar uma olhada mais atenta na seleção de cores. Aqui está um exemplo típico. |

  magick logo.png  -monochrome     monochrome.gif

O operador pontilhou a imagem baseando-se apenas em sua 'intensidade' ou 'nível' de brilho em escala de cinza, porém não pontilha toda a faixa de escala de cinza diretamente, mas aplica limiar aos valores mais extremos até seus valores máximos. Podemos ver isso pedindo ao IM para pontilhar uma imagem de gradiente.

  magick -size 15x640 gradient: -rotate 90 \
                   -monochrome     monochrome_gradient.gif

Como você pode ver, o gradiente tem apenas cerca dos 50% centrais de suas cores pontilhadas pelo operador "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)". Um agradecimento especial vai para Ivanova flamingivanova@punkass.com por apontar esse fato interessante sobre o modo como o IM funciona. Se você quiser pontilhar usando toda a faixa de escala de cinza, pode usar o operador "[-remap](https://imagemagick.org/command-line-options/#remap)" usando um mapa de cores puro preto e branco (fornecido por uma imagem de padrão embutida). |

  magick logo.png  -remap pattern:gray50  mono_remap.gif
  magick -size 15x640 gradient: -rotate 90 \
                   -remap pattern:gray50     mono_remap_gradient.gif

Com uma seleção mais cuidadosa de cores usando "[-remap](https://imagemagick.org/command-line-options/#remap)", você pode efetivamente produzir a mesma faixa de 'limiar' usada pelo operador "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)", ou qualquer outra faixa de limiar que você desejar. |

  magick xc:gray20  xc:white  +append   ctrl_colors.gif
  magick logo.png -colorspace Gray \
          -remap ctrl_colors.gif  -normalize  mono_remap_ctrl.gif
  magick -size 15x640 gradient: -rotate 90 \
          -remap ctrl_colors.gif  -normalize  mono_remap_grad_ctrl.gif

Quantização de Duas Cores

Em vez de escolher você mesmo as duas cores de controle, você pode usar a quantização de cores para escolher as duas melhores cores da imagem usando o operador "[-colors](https://imagemagick.org/command-line-options/#colors)". |

  magick logo.png   -colors 2 -colorspace gray  -normalize \
                                                 colors_monochrome.gif

No entanto, o resultado não será o mesmo que usar "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)", pois não convertemos a imagem para escala de cinza primeiro. Em vez disso, a imagem foi pontilhada diretamente entre os dois valores de cor não cinza escolhidos. Ou seja, as duas melhores cores são selecionadas para pontilhar a imagem, em vez de dois níveis de brilho em escala de cinza. Consequentemente, produzirá um resultado melhor para, digamos, uma imagem que usa apenas cores de aproximadamente o mesmo 'nível' de escala de cinza. Aqui, por exemplo, usamos "[-colors](https://imagemagick.org/command-line-options/#colors)", bem como um operador de pontilhamento de bitmap "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)", em um gradiente vermelho-azul. Como você pode ver, os resultados não são os mesmos.

  magick -size 20x640 gradient:red-blue -rotate 90    gradient_rb.png
  magick gradient_rb.png   -colors 2 -colorspace gray \
                                -normalize        colors_threshold.gif
  magick gradient_rb.png       -monochrome       mono_threshold.gif

O operador "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)" no exemplo acima falhou em encontrar quaisquer diferenças para pontilhar em bitmap, pois tanto o azul quanto o vermelho têm intensidade quase igual. Usar um método de quantização "[-colors](https://imagemagick.org/command-line-options/#colors)", porém, não teve problema em encontrar cores aceitáveis entre as quais pontilhar. Você também pode ver que apenas a parte central das cores foi pontilhada. Isso se deve à quantização de cores escolher cores no meio de dois 'agrupamentos' de cor que ela selecionou. Cores 'fora' das cores selecionadas são, portanto, efetivamente limiarizadas diretamente para aquela cor sem pontilhamento. Isso demonstra que cores fora do espaço de cor da quantização não são pontilhadas, embora esse fato seja difícil de aproveitar de forma prática. Ao definir o "[-colorspace](https://imagemagick.org/command-line-options/#colorspace)" para escala de cinza antes da quantização, você reproduzirá a operação interna do operador "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)". |

  magick logo.png -colorspace gray   -colors 2  -normalize \
                                                 monochrome_equivelent.gif

E, finalmente, ao desligar o pontilhamento, você pode produzir uma separação mais automática das cores da imagem do que a produzida usando uma configuração "[-threshold](https://imagemagick.org/command-line-options/#threshold)" fixa. |

  magick logo.png  -colorspace gray  +dither  -colors 2  -normalize \
           threshold_two_grays.gif

| Lembre-se de que "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)" atualmente ignora a configuração "[+dither](https://imagemagick.org/command-line-options/#dither)", então você não pode simplesmente usar esse operador para fazer um 'limiar inteligente'.
---|---
Se você remover o "[-colorspace](https://imagemagick.org/command-line-options/#colorspace)" para a etapa de quantização de cores do processamento da imagem, você pode aplicar limiar a uma imagem com base na melhor separação de cores (em vez de separação de cores em escala de cinza) possível para aquela imagem. |

  magick logo.png  +dither  -colors 2  -colorspace gray -normalize \
           threshold_two_color.gif

Pontilhar usando Mapas de Cores Predefinidos

Como mostrado acima, "[-colors](https://imagemagick.org/command-line-options/#colors)" tenta escolher um conjunto limitado e ótimo de cores com o qual representar uma imagem. Com "[-remap](https://imagemagick.org/command-line-options/#remap)", você fornece ao IM o conjunto final de cores que deseja usar para a imagem, quer você planeje pontilhar essas cores, ou apenas substituir as existentes por suas vizinhas mais próximas. O argumento é dado como uma imagem contendo todas as cores que você gostaria de usar. Se você quiser reduzir uma grande imagem de cores a apenas sua lista de cores, pode usar "[-unique-colors](https://imagemagick.org/command-line-options/#unique-colors)", antes de salvar, para uso posterior por "[-remap](https://imagemagick.org/command-line-options/#remap)". | _Observe que, embora o operador "[-remap](https://imagemagick.org/command-line-options/#remap)" aceite qualquer imagem para uso, não use uma imagem JPEG para esta imagem ou você obterá muitas cores extras devido à sua 'compressão com perdas' gerar cores extras.

Por outro lado, usar JPEG para gerar cores extras pode ajudar a resolver o problema do 'salpicado' visto anteriormente!_
---|---
Por exemplo, aqui limito as cores usadas no logo do IM a um mapa predefinido de cores nomeadas do X window. O padrão é o pontilhamento 'Riemersma', mas a partir do IM v6.4.4 o "[-dither](https://imagemagick.org/command-line-options/#dither)" foi expandido para permitir a seleção de outros métodos de pontilhamento, como 'FloydSteinberg'. Você pode, é claro, ainda desligar o pontilhamento usando a opção "[+dither](https://imagemagick.org/command-line-options/#dither)".

  magick logo.png  -dither None       -remap colortable.gif  remap_logo_no.gif
  magick logo.png  -dither Riemersma  -remap colortable.gif  remap_logo_rm.gif
  magick logo.png  -dither FloydSteinberg \
                                       -remap colortable.gif  remap_logo_fs.gif

Como você pode ver, o IM tentou fazer um trabalho razoável de representar a imagem usando apenas as cores fornecidas, embora os resultados estejam longe de ser tão bons quanto a imagem que você obtém se permitir que o IM selecione o conjunto de cores a usar. Vale notar que esta imagem "[colortable.gif](../static/img/images/colortable.gif)" nunca foi projetada para pontilhar imagens, mas como um conjunto de cores para projetar ícones coloridos estilo cartoon para monitores coloridos X window mais antigos e primitivos (Veja Anthony's X Window Icon Library e AIcons Color Selection para detalhes). Observe também que a imagem final não usou todas as 32 cores fornecidas por este mapa, embora mais das cores do mapa sejam usadas quando alguma forma de pontilhamento é habilitada ( e respectivamente), do que quando ele estava desligado (). Este último exemplo mostra o quão importante é selecionar um bom mapa de cores. Por causa disso, recomendo que você deixe o IM otimizar a seleção de cores usada em uma imagem usando o operador "[-colors](https://imagemagick.org/command-line-options/#colors)", e modifique isso para atender às suas necessidades, a menos que você tenha razões mais urgentes para não o fazer. Um último ponto: embora você possa especificar um espaço de cor no qual "[-colors](https://imagemagick.org/command-line-options/#colors)" encontrará o melhor conjunto de cores, você atualmente NÃO pode definir um espaço de cor para a fase de mapeamento de cores ou pontilhamento. Todos os meus experimentos parecem mostrar que o conjunto de cores é aplicado (tanto o pontilhamento de correção de erro quanto a substituição pela cor mais próxima) com base no espaço RGB. A configuração de espaço de cor "[-quantize](https://imagemagick.org/command-line-options/#quantize)" é usada apenas para a seleção de cores, não para seu mapeamento. Então, se usar um mapa de cores é uma ideia tão ruim, por que você iria querer usá-lo? Há várias razões comuns, geralmente porque você precisa de mais controle sobre a paleta específica de cores usada em uma imagem. Outro usuário também separou o mapa de cores para poder usá-lo em uma Risograph (Um sistema de impressão digital). Se você conhece outra razão para usar o operador "[-remap](https://imagemagick.org/command-line-options/#remap)" que eu não tenha apresentado abaixo - Me escreva.

Mapa de Cores Comum ou 'Melhor'

A outra técnica, ao lidar com múltiplas imagens, é gerar uma tabela de cores comum para todas as imagens envolvidas. Basicamente você junta todas as imagens em uma grande imagem, então usa o operador "[-colors](https://imagemagick.org/command-line-options/#colors)" para descobrir um bom mapa de cores a usar que seja comum a todas as imagens. Uma vez que você tenha essa imagem de mapa de cores, você pode usá-la para recolorir cada uma das imagens originais usando este Mapa de Cores Predefinido recém-gerado. Alternativamente, você pode usar o operador especial "[+remap](https://imagemagick.org/command-line-options/#remap)", que faz a mesma coisa para um mapa de cores de 255 cores. Ele conta as cores, realiza a quantização de cores para formar um bom mapa de cores comum, então pontilha as imagens para usar esse mapa, se necessário. Ambas as formas "[-remap](https://imagemagick.org/command-line-options/#remap)" e "[+remap](https://imagemagick.org/command-line-options/#remap)", no entanto, têm uma característica muito importante para animações GIF. Elas convertem todas as imagens para um "[-type](https://imagemagick.org/command-line-options/#type)" de imagem de 'Palette' com todas as imagens usando a mesma paleta de cores. A razão é que, ao gravar uma imagem GIF, a paleta de cores da primeira imagem será usada para o 'mapa de cores global' do formato de arquivo. Então, à medida que cada imagem é gravada, ele nota que essas imagens usam o mesmo conjunto de cores, então NÃO cria um 'mapa de cores local'. Isso pode economizar até 256 × 3, ou 768 bytes de espaço de mapa de cores para cada uma das imagens do arquivo GIF final. Somente os operadores "[-remap](https://imagemagick.org/command-line-options/#remap)" podem fazer isso. Portanto, ao lidar com GIFs e, em particular, animações GIF, pode ser um ponto importante a lembrar. Para mais detalhes, e um exemplo, veja Gif Animations, Global Color Table.

Coloração Segura para Web

Quando a WWW foi criada, os monitores de computador tinham uma faixa limitada de cores disponíveis, e os navegadores web geralmente usavam um conjunto de cores mais simples para as imagens. Assim, era comum recolorir imagens para esse conjunto de cores, para torná-las tanto menores quanto para garantir que ficariam bem nos navegadores dos usuários. Para mais detalhes, veja Web Style Guide, Dithering. Para ajudar com isso, o IM forneceu uma imagem de mapa de cores embutida desta tabela especial de 216 cores, chamada "netscape:". Então vamos ver como nossa imagem de teste ficaria em um monitor de navegador web antigo usando essas cores.

  magick logo.png         -remap netscape:  remap_netscape.gif
  magick logo.png +dither -remap netscape:  remap_netscape_nd.gif

Este conjunto de cores era uma paleta determinada matematicamente, projetada por engenheiros de monitores e computadores, não por artistas gráficos, e embora seja geral o suficiente para funcionar razoavelmente bem para imagens reais, como fotos, é muito ruim para imagens contendo grandes áreas planas de cor, como logos, fundos, imagens geradas por computador como gráficos, e imagens estilo cartoon. Basicamente, isso funciona em áreas de cores altamente variáveis, mas para as áreas planas maiores de cores constantes um pontilhamento de três cores (em geral) é aplicado, como a camisa azul-desbotada do logo de teste do IM (acima). Em outras palavras, se você estivesse projetando uma imagem ou logo para uso na web, geralmente tentaria usar as cores desta paleta para as grandes áreas planas, e ter apenas cores pontilhadas em áreas onde você tem tonalidades variáveis de cor. Os comandos acima permitem testar suas imagens para ver como ficariam em monitores de computador mais primitivos, e editar a imagem para usar essas cores, para que funcionem bem. Isso é particularmente importante para símbolos e imagens de navegação. É claro que hoje, graças às demandas de usuários de jogos e da web, você pode estar bastante seguro de que a maioria dos usuários tem um monitor de computador moderno que não tem aquelas antigas limitações de cor, no entanto o uso desta "paleta segura para web" ainda existe, pois tem outros benefícios, como a compressão de imagem. Para uma discussão sobre o uso de cores seguras para web no mundo moderno, veja Death of the Web-safe Color Palette?, e provavelmente uma visão mais importante de uma designer gráfica que primeiro identificou este mapa de cores, Lynda Weinman.

Gerando Mapas de Cores

Determinar um bom mapa de cores para qualquer imagem, ou um conjunto específico de imagens, pode ser muito importante. Isso se torna especialmente importante quando você está lidando com uma sequência de imagens que serão usadas para uma animação GIF. Basicamente você quer fazer com que elas precisem apenas de uma tabela de cores, a ser usada para todos os quadros da animação, em vez de uma tabela de cores separada para cada quadro. Em outras palavras, você quer um único mapa de cores para todas as imagens. Você tem realmente apenas duas escolhas nesse caso. Você pode tentar criar um mapa de cores que funcione bem para qualquer imagem, ou pode tentar otimizar um mapa de cores para o conjunto específico de imagens ao qual está aplicando.

Mapa de Cores Seguro para Web

O primeiro método é tipicamente um mapa de cores gerado matematicamente, como o mapa de cores "netscape:" embutido no IM. Isso fornece um conjunto de 216 cores, que se encaixará bem no limite de 256 cores do formato GIF, e ainda terá espaço para lidar com a transparência da imagem, ou até mesmo adicionar algumas cores extras para propósitos especiais, como sombras, ou sobreposições de texto. Este mapa de cores foi gerado criando 6 níveis de cores para cada um dos três canais de cor, produzindo 6×6×6 cores ou 216 cores. O número da besta. Como apenas 219 cores são usadas, ainda há espaço (para imagens GIF) para adicionar mais cores ao mapa de cores para propósitos específicos. Por exemplo, uma cor transparente, bem como mais tonalidades de escala de cinza. Uma antiga versão Macintosh do mapa seguro para web de fato fazia exatamente isso para tentar melhorar seu resultado geral, mas era usada apenas em clientes web Macintosh. Este é provavelmente o mapa de cores 'uniforme' (ou derivado matematicamente) mais comum em uso geral, graças à sua simplicidade, e ao seu uso geral na World Wide Web.

Mapa de Cores Uniforme 332

Outro mapeamento de cores uniforme comumente usado é o "mapa de cores RGB 332". Os números se referem ao número de bits usados para representar cada cor dentro de um índice de cor de 8 bits. Ou seja, 3 bits (ou 8 níveis) de vermelho, 3 para verde, e 2 bits (ou 4 níveis de cor) para azul, visto que nossos olhos não respondem bem ao azul. Isso dá 3+3+2 bits ou um índice de cor de 8 bits, ou 256 cores. Perfeito para a tabela de cores limitada do GIF. No entanto, não deixará nenhum espaço para uma cor de transparência GIF, ou outras cores de uso especial. Aqui está uma maneira de fazer o IM gerar este mapa de cores... |

  magick -size 16x16 xc: -channel R -fx '(i%8)/7' \
                          -channel G -fx '(j%8)/7' \
                          -channel B -fx '((i>>3&1)|(j>>2&2))/3' \
          -scale 600% colormap_332.png

| Os operadores de deslocamento de bits '>>' e '<<' estavam ausentes do operador "[-fx](https://imagemagick.org/command-line-options/#fx)" até a versão 6.2.9-2 do IM.
---|---
Uma maneira mais simples de fazer a mesma coisa é usar Pontilhamento Ordenado usando Níveis de Cor Uniformes usando a operação, "-ordered-dither threshold,8,8,4" (veja aquela área de exemplos). Uma técnica muito mais fácil e rápida do que o método FX faça-você-mesmo acima, e que ainda permite usar outros mapas de pontilhamento embutidos para um melhor tratamento de gradientes. A única desvantagem deste mapa é que ele na verdade não fornece nenhuma cor 'cinza'. No entanto, essa desvantagem pode ser uma vantagem quando o pontilhamento é usado, pois as pequenas diferenças de cor reduzem o efeito das mudanças de limite de cor em um gradiente em escala de cinza, tornando-o só um pouquinho mais suave.

Mapa de Cores TrueColor de 16 bits

Um mapa de cores uniforme semelhante ao 'mapa de cores 332' acima é usado pelo X windows em uma classe visual de 16 bits raramente usada. Nesse caso, 16 bits são usados para o índice de cor que é dividido em 5 bits para vermelho, 5 para verde, e 6 para azul. Em outras palavras, este mapa de cores é mais como um "mapa de cores 556", e é melhor obtido usando um Pontilhamento Ordenado usando Níveis de Cor Uniformes usando um mapa de pontilhamento de 'limiar'. Especificamente a operação "-ordered-dither threshold,32,32,64". Mapas de cores de 16 bits, porém, raramente são vistos, pois imagens que usam mapas de cores tipicamente precisam de uma tabela de cores de 8 bits. Assim, não o mencionarei mais adiante.

Mapas de Cores Uniformes Corrigidos por Gama

No momento, o IM não faz mapas de cores corrigidos por gama diretamente. Em vez disso, o que você deve fazer é converter sua imagem (assumindo que você tenha uma versão do IM compilada com qualidade Q16 ou melhor), do sRGB ou de qualquer nível de gama que a imagem tenha para um modelo RGB linear, antes de fazer seu pontilhamento. Isso também vale para muitas outras operações de processamento de imagem, como redimensionar, desfocar, etc. Veja Resizing with Gamma Correction para um exemplo.

Posterizar, Recolorir usando um Mapa de Cores Uniforme

O propósito original do operador (usando um argumento de '2') é recolorir imagens usando apenas 8 cores básicas, como se a imagem tivesse sido gerada usando um método de impressão de pôster simples e barato usando apenas as cores básicas. Assim o operador recebe seu nome. O operador "[-posterize](https://imagemagick.org/command-line-options/#posterize)" é, na verdade, um operador especial de redução de cores que gera um mapa de cores baseado no número de 'níveis' de cor dados, para cada canal de cor da imagem, pontilhando a imagem usando um pontilhamento de correção de erro.

  magick netscape: -scale 50%  +dither  -posterize 2   posterize_2_ns.gif
  magick netscape: -scale 50%  +dither  -posterize 3   posterize_3_ns.gif
  magick netscape: -scale 50%  +dither  -posterize 6   posterize_6_ns.gif

Como você pode ver, um argumento "[-posterize](https://imagemagick.org/command-line-options/#posterize)" de '2' significa fornecer apenas 2 cores por canal de cor, produzindo um mapa de apenas 8 cores para uma imagem RGB de 3 canais, como a acima. Basicamente ele recolorirá imagens usando o conjunto de limiar de 8 cores. Um argumento de '3' mapeará as cores da imagem com base em um mapa de cores de 27 cores, incluindo cores de tom médio. Já um argumento de '4' gerará uma tabela de cores de 64 cores, e '5' gera um mapa de cores de 125 cores. É claro que, como mencionado acima, um argumento de '6' reproduzirá o mesmo conjunto de 216 cores, como o fornecido pela imagem "netscape:" embutida. Observe que um argumento "[-posterize](https://imagemagick.org/command-line-options/#posterize)" de '0' ou '1' não faz sentido, e com as últimas versões do IM apenas converte as imagens para preto puro (o que, embora lógico, é bastante inútil). O resultado é que a imagem foi recolorida usando um mapa de cores derivado matematicamente ou 'uniforme'. Você pode ver isso mais claramente em uma imagem de gradiente, produzindo uma distribuição uniforme de níveis de cinza posterizados.

  #magick -size 20x640  gradient: -rotate 90  gradient.png
  magick gradient.png  +dither  -posterize 5   posterize_gradient.gif

Por exemplo, vamos posterizar a imagem do logo do IM em vários níveis...

  magick logo.png  +dither -posterize 2  posterize_logo.gif
  magick logo.png          -posterize 2  posterize_logo_dither.gif
  magick logo.png          -posterize 6  posterize_6_logo.gif

Como um teste melhor, vamos posterizar a imagem sombreada "colorwheel".

  magick colorwheel.png  +dither  -posterize 2   posterize_2_cw.gif
  magick colorwheel.png  +dither  -posterize 3   posterize_3_cw.gif
  magick colorwheel.png  +dither  -posterize 6   posterize_6_cw.gif

E aqui está a mesma coisa com o pontilhamento habilitado...

É claro que muitos dos pontilhamentos de bitmap que veremos na próxima seção também podem gerar pontilhamentos ordenados de nível 2, usando vários tipos de estilos de pontilhamento. No entanto, poucos podem usar um número maior de níveis de cinza. O Pontilhamento Ordenado, a partir do IM v6.2.9, também é um método de posterização, devido à sua limitação atual em pontilhar usando mapas de cores uniformes. No entanto, o padrão de pontilhamento é mais uniforme, com uma seleção maior de estilos, do que o pontilhamento pseudoaleatório produzido por "[-posterize](https://imagemagick.org/command-line-options/#posterize)". Compare estes com as versões pontilhadas de "[-posterize](https://imagemagick.org/command-line-options/#posterize)" acima.

  magick colorwheel.png  -ordered-dither o8x8,2   posterize_2_od.gif
  magick colorwheel.png  -ordered-dither o8x8,3   posterize_3_od.gif
  magick colorwheel.png  -ordered-dither o8x8,6   posterize_6_od.gif

O mapa de pontilhamento 'threshold' (em vez de 'o8x8' usado acima) efetivamente converte "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" em um método de posterização sem pontilhamento. Finalmente, o Pontilhamento Ordenado permite que você especifique um número diferente de níveis de cor, para cada canal de cor individual. Algo que o operador "[-posterize](https://imagemagick.org/command-line-options/#posterize)" atualmente não permite.

Métodos de Pontilhamento por Limiar

Imagens por Limiar

O método mais simples de converter uma imagem em uma imagem de bitmap preto e branco (para cores) é usar "[-threshold](https://imagemagick.org/command-line-options/#threshold)". Este é, na verdade, um operador matemático simples que apenas fornece um valor de corte. Qualquer coisa igual ou abaixo desse valor torna-se preta, enquanto qualquer coisa maior torna-se branca.

  magick logo.png     -threshold   -1   threshold_0.gif
  magick logo.png     -threshold  25%   threshold_25.gif
  magick logo.png     -threshold  50%   threshold_50.gif
  magick logo.png     -threshold  75%   threshold_75.gif
  magick logo.png     -threshold 100%   threshold_100.gif

Como você pode ver, um valor de '-1' tornará todas as cores brancas, enquanto '100%' converte todas as cores para preto. Um '50%' é, obviamente, o valor mais comum utilizado. Um valor de '0' é um caso especial que torna brancas todas as cores que não sejam preto puro. Claro que, se a imagem não tiver cores de preto puro, você obterá apenas uma imagem branca sólida! |

  magick logo.png  -threshold   0    threshold_black.gif

Se você realmente quiser tornar pretas todas as cores que não sejam branco puro, recomendo que você aplique o limiar sobre a imagem negada, em vez de tentar calcular o valor de limiar correto a usar (um a menos que o 'MaxRGB' atual do IM), um valor que depende da configuração específica de Qualidade, ou 'Q' usada na compilação do seu IM. |

  magick logo.png  -negate -threshold 0 -negate threshold_white.gif

O operador "[-threshold](https://imagemagick.org/command-line-options/#threshold)" pode ser classificado como um operador de 'contraste' definitivo, maximizando as diferenças nas cores conforme o nível de limiar. É, no entanto, um operador em tons de cinza, o que significa que a configuração "[-channel](https://imagemagick.org/command-line-options/#channel)" pode ser usada para ajustar a qual canal de cor o operador será aplicado. Por exemplo, você pode aplicar o limiar a cada um dos canais individuais da imagem para produzir o mesmo efeito de uma operação "[-posterize](https://imagemagick.org/command-line-options/#posterize)" de nível 2 sem pontilhamento. |

  magick logo.png  -channel R -threshold 50% \
                     -channel G -threshold 50% \
                     -channel B -threshold 50%   threshold_posterize.gif

| Note que "[-threshold](https://imagemagick.org/command-line-options/#threshold)" trata qualquer transparência em uma imagem como um canal matte, não como um canal alfa (exatamente como é armazenado internamente no IM). Assim, é preciso cautela se você pretende aplicar este operador ao canal alfa. Veja Canal Matte para mais detalhes.
---|---
Para uma técnica de limiar mais automática, você pode usar a técnica de Quantização de Duas Cores que mostramos anteriormente. Por exemplo, isto aplicará o limiar à imagem com base nas duas melhores cores encontradas na imagem. Essas cores não são necessariamente em tons de cinza ou mesmo opostas, apenas as duas cores que melhor representam a imagem inteira. As duas cores são então mapeadas (usando "[-normalize](https://imagemagick.org/command-line-options/#normalize)") para preto e branco puros. |

  magick logo.png  +dither  -colors 2  -colorspace gray -normalize \
             threshold_two_color.gif

Pontilhamento e Limiar Aleatórios

O operador "[-random-threshold](https://imagemagick.org/command-line-options/#random-threshold)" é uma forma especial de conversor de imagem bitmap. Neste caso ele usa um "pontilhamento aleatório" muito simples para determinar se um pixel específico deve tornar-se um pixel branco ou um pixel preto. Diferentemente dos operadores "[-threshold](https://imagemagick.org/command-line-options/#threshold)" ou "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)", ou mesmo das variações da seção anterior, os canais selecionados (definidos com "[-channels](https://imagemagick.org/command-line-options/#channels)") não são combinados em um único canal em tons de cinza e pontilhados como uma unidade única. Em vez disso, "[-random-threshold](https://imagemagick.org/command-line-options/#random-threshold)" trabalha em cada canal selecionado de forma completamente independente dos demais. Naturalmente, usar o operador diretamente resultará em uma posterização de 2 níveis da imagem usando um pontilhamento aleatório. |

  magick logo.png  -random-threshold  0x100%  random_posterize.gif

Converter para tons de cinza equalizará todos os canais da imagem antes que sejam pontilhados. Mas, como cada canal é pontilhado independentemente dos outros e de forma aleatória, o resultado não é uma imagem bitmap como você esperaria. Em vez disso, você obterá um respingo de pixels coloridos, especialmente para cores de meio-tom. |

  magick logo.png  -colorspace Gray -random-threshold  0x100% \
                                                   random_greyscale.gif

Aqui está a maneira correta de gerar uma imagem bitmap devidamente pontilhada de forma aleatória. |

  magick logo.png  -colorspace Gray -channel B \
          -random-threshold 0x100%    -separate   random_monochome.gif

Basicamente, o que ele fez foi pontilhar apenas um canal da imagem em tons de cinza e, em seguida, usar o operador de canal "[-separate](https://imagemagick.org/command-line-options/#separate)" para extrair esse canal como a imagem bitmap final. Engenhoso, mas eficaz. Como recurso especial deste operador, o IM garantirá que uma imagem bitmap seja gerada quando a opção especial "[-channels](https://imagemagick.org/command-line-options/#channels)" de 'All' é usada. |

  magick logo.png  -channel All -random-threshold 0x100% random_all.gif

Entretanto, observe que qualquer canal alfa será ignorado e perdido usando este método, de modo que ele normalmente não é recomendado. Eu mesmo só descobri este antigo recurso por acaso, a partir do código-fonte. Agora que você sabe como usar o operador para gerar bitmaps corretamente a partir de uma imagem colorida, vamos ver como o argumento afeta a faixa do pontilhamento. Isto também mostra claramente o 'agrupamento' de pixels que este pontilhamento produz.

  #magick -size 20x640  gradient: -rotate 90  gradient.png
  magick gradient.png  -channel All \
                        -random-threshold 0x100%  random_grad_0x100.gif
  magick gradient.png  -channel All \
                        -random-threshold 10x90%  random_grad_10x90.gif
  magick gradient.png  -channel All \
                        -random-threshold 25x75%  random_grad_25x75.gif
  magick gradient.png  -channel All \
                        -random-threshold 50x50%  random_grad_50x50.gif

Uma configuração de "[-random-threshold](https://imagemagick.org/command-line-options/#random-threshold)" de '0x100%' produzirá um 'Pontilhamento Aleatório' puro da imagem. Se os dois limites forem definidos com o mesmo valor (ou até mesmo ultrapassarem um ao outro), ela produzirá apenas uma imagem de "[-threshold](https://imagemagick.org/command-line-options/#threshold)" pura. Usar qualquer outro conjunto de limites (geralmente especificado usando uma porcentagem) aplicará o limiar ao bitmap fora da faixa dada, ao mesmo tempo em que produz um padrão de pontilhamento aleatório para os valores dentro da faixa dada. Os melhores resultados podem ser obtidos usando uma faixa ligeiramente menor, exatamente como você obtém usando o operador "[-monochrome](https://imagemagick.org/command-line-options/#monochrome)". Um valor de cerca de '30x80%' é provavelmente o melhor resultado para a maioria dos casos. |

  magick logo.png  -channel All -random-threshold 30x80%  random_30x80.gif

Naturalmente, o resultado ainda não é muito bom. Mas, afinal, esta é a forma mais simples e pior de pontilhamento que você pode obter. O que de fato acontece é que o padrão de pontilhamento aleatório tende a produzir 'aglomerados' de pixels, em vez de um padrão de pontilhamento suave. Isso se deve ao 'ruído' de alta frequência no gerador de números aleatórios. No entanto, em resoluções muito altas, um pontilhamento aleatório demonstrou produzir um resultado extremamente bom, se for aleatório o suficiente. O IM usa um nível criptográfico de aleatoriedade, então provavelmente será muito aleatório, embora as imagens raramente sejam usadas em uma resolução suficientemente alta para torná-lo útil dessa forma. Uma 'correção' para este pontilhamento, que foi sugerida, é usar um gerador de 'ruído azul' aleatório (um filtro de alta frequência, em oposição ao filtro de 'ruído rosa' de baixa frequência usado na produção de som). Isso deveria remover o agrupamento dos pixels, mas é muito difícil de implementar digitalmente. Nenhuma implementação conhecida de 'pontilhamento aleatório com ruído azul' foi encontrada, e é improvável que venha a ser criada.

Pontilhamento Ordenado

Enquanto um pontilhamento aleatório produz aglomerados aleatórios de pixels, e os vários pontilhamentos com correção de erro produzem um padrão essencialmente aleatório de pontos, o pontilhamento ordenado é basicamente o oposto. Ele é projetado para ser o mais matematicamente determinístico possível. Tão determinístico que você realmente precisa especificar o padrão que ele deve usar para pontilhar a imagem. O operador "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" pontilhará cada um dos "[-channels](https://imagemagick.org/command-line-options/#channels)" selecionados na imagem com um padrão predefinido dado. O argumento define o padrão (conhecido como mapa de limiar) a usar. Esses mapas de limiar se enquadram em três estilos básicos. Pontilhamentos por Pixels Difundidos, em que os pixels são posicionados o mais longe possível uns dos outros, de modo a evitar 'agrupamentos' e artefatos de ladrilhamento. Ou para agrupá-los em pontos compactos que os tornam mais fáceis de imprimir mecanicamente, em uma técnica conhecida como Meio-tom Digital. Há também alguns mapas de limiar artísticos especializados que também examinaremos, e até mesmo o projeto de nosso próprio padrão de pontilhamento ou mapa de limiar. Em cada caso, o número de pixels que estão ligados ou desligados no mapa de limiar depende da intensidade do nível de cinza da imagem (ou do canal de cor individual) que está sendo pontilhado em um bitmap. O mapa adiciona níveis de limiar de pixels de maneira consistente, de modo que, uma vez que um pixel se acende em um 'limiar' específico, ele permanece aceso para qualquer cor de cinza mais clara. Essa consistência é muito importante; caso contrário, artefatos são produzidos ao longo das fronteiras das mudanças no padrão de pontilhamento. O ponto importante disto é que o resultado para cada pixel de uma imagem é determinado puramente de forma matemática, independentemente de qualquer outro pixel da imagem. Assim, qualquer pequena mudança na imagem original não terá absolutamente nenhum efeito na imagem em qualquer outra área, um problema que os Pontilhamentos com Correção de Erro têm, como vimos acima. Este ponto é vital para o pontilhamento consistente de imagens de vídeo e animações otimizadas.

Pontilhamento por Pixels Difundidos

O propósito original do pontilhamento ordenado, e o que a maioria dos programadores gráficos espera obter quando usa um pontilhamento ordenado, é algo mais corretamente chamado de "Pontilhamento Ordenado por Pixels Difundidos". O que isso significa é que os pixels são adicionados ao mapa ladrilhado conforme a intensidade do limiar aumenta, de modo que fiquem o mais afastados possível uns dos outros e distribuídos de forma tão uniforme quanto possível. Isso produz um padrão altamente consistente que parece bastante suave e quase invisível na maioria dos monitores modernos. Tais padrões foram elaborados para tamanhos de ladrilho que são potência de 2, a saber, tamanhos de ladrilho de 2, 4 e 8. Embora o IM também forneça um padrão de limiar razoável para um ladrilho de mapa de limiar de 3 por 3. Aqui está o conjunto atual de pontilhamentos ordenados embutidos que o IM fornece atualmente. Lembre-se de que o argumento reflete o tamanho do ladrilho do pontilhamento ordenado.

  magick logo.png    -ordered-dither o2x2    logo_o2x2.gif
  magick logo.png    -ordered-dither o3x3    logo_o3x3.gif
  magick logo.png    -ordered-dither o4x4    logo_o4x4.gif
  magick logo.png    -ordered-dither o8x8    logo_o8x8.gif

Observe como um tamanho de ladrilho maior permite simular mais 'níveis de cor', mas também gera defeitos mais perceptíveis ou arranjos retangulares de pixels em certos níveis. | _O pontilhamento ordenado 'o8x8' fez parte do código central do IM por muito tempo, mas não era usado. Ele só foi adicionado como opção ao operador "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" no IM v6.2.9, quando o IM Examples passou a detalhar o uso deste operador.

Nessa época, os mapas receberam nomes mais definitivos para permitir uma expansão futura do operador "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)", embora os antigos nomes de 'tamanho de ladrilho', compatíveis com versões anteriores, tenham sido mantidos como apelidos para os novos nomes.

Além disso, os 'mapas' que produziam o 'o3x3' e o 'o4x4' foram completamente revisados para produzir um melhor padrão de pontilhamento por 'pixels difundidos'. Antes disso, os mapas produziam 'aglomerados' distintos de pixels.

Veja a página de notas Atualização do Pontilhamento Ordenado para exemplos dos padrões antigos antes de serem corrigidos, bem como outras mudanças feitas durante o desenvolvimento para o lançamento oficial das atualizações no IM v6.3.0._
---|---
Naturalmente, você precisa converter a imagem para tons de cinza primeiro para produzir um bitmap adequado de todos os canais da imagem; porém, como o processo não é aleatório, você não precisa pós-processar a imagem como precisa fazer com o operador "-random-threshold", o que simplifica enormemente as coisas.

  magick logo.png -colorspace Gray  -ordered-dither o2x2  logo_bw_o2x2.gif
  magick logo.png -colorspace Gray  -ordered-dither o3x3  logo_bw_o3x3.gif
  magick logo.png -colorspace Gray  -ordered-dither o4x4  logo_bw_o4x4.gif
  magick logo.png -colorspace Gray  -ordered-dither o8x8  logo_bw_o8x8.gif

Como referência, aqui estão cada um dos padrões de 'pixels difundidos' de "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" aplicados a um gradiente em tons de cinza, para que você possa ver claramente como eles se parecem.

  # Limiar Sem Pontilhamento / Pontilhamento Xadrez Mínimo
  magick gradient.png   -ordered-dither threshold  od_threshold.gif
  magick gradient.png   -ordered-dither checks     od_checks.gif
  # Pontilhamento por Pixels Difundidos
  magick gradient.png   -ordered-dither o2x2       od_o2x2.gif
  magick gradient.png   -ordered-dither o3x3       od_o3x3.gif
  magick gradient.png   -ordered-dither o4x4       od_o4x4.gif
  magick gradient.png   -ordered-dither o8x8       od_o8x8.gif

O número de padrões de níveis efetivos ou pseudo-níveis produzidos por um pontilhamento ordenado específico é tipicamente (mas nem sempre) igual ao número de pixels no padrão mais um. Assim, um pontilhamento ordenado 'o3x3' produzirá 3×3+1, ou 10 níveis de cinza efetivos por canal (preto, branco e 8 padrões de cinza artificiais) na imagem resultante. Também são mostrados acima dois mapas de limiar de pontilhamento mínimo especiais:

1. um 'limiar de 50%' direto sem pontilhamento, que não produz níveis de cinza extras e
2. um padrão de pontilhamento 'checks' ou xadrez, que insere apenas um único padrão para adicionar um 'pseudo-nível' extra ao gradiente resultante.

Pontilhamentos de Meio-tom Digital

  # Tela de Meio-tom (ângulo de 45 graus)
  magick logo.png   -ordered-dither h4x4a    logo_h4x4a.gif
  magick logo.png   -ordered-dither h6x6a    logo_h6x6a.gif
  magick logo.png   -ordered-dither h8x8a    logo_h8x8a.gif
  # Tela de Meio-tom (ortogonal)
  magick logo.png   -ordered-dither h4x4o    logo_h4x4o.gif
  magick logo.png   -ordered-dither h6x6o    logo_h6x6o.gif
  magick logo.png   -ordered-dither h8x8o    logo_h8x8o.gif

Novamente, use o operador "[-colorspace](https://imagemagick.org/command-line-options/#colorspace)" para gerar um pontilhamento bitmap verdadeiro de uma imagem.

  # Tela de Meio-tom (ângulo de 45 graus)
  magick logo.png -colorspace Gray  -ordered-dither h4x4a logo_bw_h4x4a.gif
  magick logo.png -colorspace Gray  -ordered-dither h6x6a logo_bw_h6x6a.gif
  magick logo.png -colorspace Gray  -ordered-dither h8x8a logo_bw_h8x8a.gif
  # Tela de Meio-tom (ortogonal)
  magick logo.png -colorspace Gray  -ordered-dither h4x4o logo_bw_h4x4o.gif
  magick logo.png -colorspace Gray  -ordered-dither h6x6o logo_bw_h6x6o.gif
  magick logo.png -colorspace Gray  -ordered-dither h8x8o logo_bw_h8x8o.gif

E, finalmente, outra imagem de gradiente de referência para mostrar claramente o padrão de pontilhamento de meio-tom, e como os aglomerados de pixels dentro do padrão de pontilhamento crescem uns em direção aos outros conforme o nível de cinza muda.

  # Tela de Meio-tom (ângulo de 45 graus)
  magick gradient.png   -ordered-dither h4x4a      od_h4x4a.gif
  magick gradient.png   -ordered-dither h6x6a      od_h6x6a.gif
  magick gradient.png   -ordered-dither h8x8a      od_h8x8a.gif
  # Tela de Meio-tom (ortogonal)
  magick gradient.png   -ordered-dither h4x4o      od_h4x4o.gif
  magick gradient.png   -ordered-dither h6x6o      od_h6x6o.gif
  magick gradient.png   -ordered-dither h8x8o      od_h8x8o.gif
  magick gradient.png   -ordered-dither h16x16o    od_h16x16o.gif
  # Meios-tons Circulares (preto e branco)
  magick gradient.png   -ordered-dither c7x7b      od_c7x7b.gif
  magick gradient.png   -ordered-dither c7x7w      od_c7x7w.gif

Até a versão 6.2.9 do ImageMagick, todos os mapas de pontilhamento ordenado por limiar acima eram tudo o que era possível com o IM. Isso agora mudou, permitindo que os usuários adicionem seus próprios padrões e até mesmo os contribuam para a comunidade do IM. Os limiares de meio-tom 'Circular' foram adicionados por Glenn Randers-Pehrson, IM v6.6.5-6.

Pontilhamento de Meio-tom com Deslocamento

O único problema com o pontilhamento de meio-tom acima é que exatamente o mesmo mapa de limiar (ladrilho) é aplicado a todos os canais de cor da mesma maneira. Isso significa que o mesmo conjunto de cor primária é organizado em pontos com o mesmo 'centro'. Para obter o que é conhecido como 'Impressão Offset', o padrão de limiar é rotacionado de uma forma específica, de modo que as cores formem 'padrões de roseta' em pequena escala que destroem os padrões de interferência (moiré) muito mais horríveis que você poderia, de outra forma, desenvolver. Este diagrama basicamente explica o processo, e é explicado em grande detalhe na página da Wikipédia, Meio-tom.

Note, entretanto, que as telas rotacionadas não se ladrilham muito bem, de modo que a melhor ideia é, na verdade, gerar o padrão rotacionado diretamente, em vez de usar um padrão de limiar ladrilhado. Aqui está uma maneira de dar a uma imagem uma aparência de impressão de meio-tom com deslocamento, usando um pequeno padrão xadrez rotacionado de 2x2 pixels, que é cerca da menor 'tela' que pode ser usada. |

  magick colorwheel.png  -set option:distort:viewport '%wx%h+0+0' \
          -colorspace CMYK -separate null: \
          \( -size 2x2 xc: \( +clone -negate \) \
                +append \( +clone -negate \) -append \) \
          -virtual-pixel tile -filter gaussian \
          \( +clone -distort SRT 60 \) +swap \
          \( +clone -distort SRT 30 \) +swap \
          \( +clone -distort SRT 45 \) +swap \
          \( +clone -distort SRT 0 \)  +swap +delete \
          -compose Overlay -layers composite \
          -set colorspace CMYK -combine -colorspace RGB \
          offset_colorwheel.png

Note que as quatro 'telas' rotacionadas são aplicadas à imagem como um todo; é apenas a etapa "-combine" no espaço de cor CMYK que efetivamente extrai os 4 diferentes canais de cor das imagens com telas aplicadas. Além disso, o distort 'no-op' para o último canal 'preto' é importante, pois ele borrará o padrão xadrez de entrada de acordo com o filtro gaussiano que foi usado nos outros canais durante suas rotações, mesmo que essa tela em si não esteja sendo rotacionada. E aqui eu uso a função de escala do SRT Distort usada para gerar os ladrilhos rotacionados para criar um 'padrão de tela' ligeiramente maior e mais borrado.

  magick parrots_med.png  -set option:distort:viewport '%wx%h+0+0' \
          -colorspace CMYK -separate null: \
          \( -size 2x2 xc: \( +clone -negate \) \
                +append \( +clone -negate \) -append \) \
          -virtual-pixel tile -filter gaussian \
          \( +clone -distort SRT 2,60 \) +swap \
          \( +clone -distort SRT 2,30 \) +swap \
          \( +clone -distort SRT 2,45 \) +swap \
          \( +clone -distort SRT 2,0  -blur 0x0.7 \) +swap +delete \
          -compose Overlay -layers composite \
          -set colorspace CMYK -combine -colorspace RGB \
          offset_parrots.png

Note que o padrão permanece muito 'quadrado', especialmente a tela preta da qual todas as outras são derivadas. POSSIBILIDADE FUTURA: Substituir o xadrez de 2 pixels acima por um padrão xadrez em nível de pixel "pattern:gray50". As opções do filtro gaussiano podem ser usadas para ajustar o desfoque do padrão escalado. Alternativamente, você pode escalar o padrão de forma borrada e aplicar-lhe o limiar para obter pontos mais redondos. Isso pode então ser rotacionado como anteriormente para criar as 4 telas de cor. Também seria melhor se uma tela maior usando um padrão de pontos hexagonais pudesse ser usada, em vez do padrão xadrez que usei acima.
É importante notar que isto não está realmente gerando pontos de cor como na verdadeira impressão offset, mas fingindo isso ao simplesmente multiplicar as telas de cor contra a imagem original. Você pode ver que é este o caso devido à mudança brusca de cor ao longo das bordas do papagaio vermelho contra o fundo verde. A verdadeira impressão offset, usando apenas pontos de cor pura, não terá nenhuma mudança de cor no meio do ponto. É o tamanho do ponto de cor pura que deve mudar, dependendo da média das cores naquela área representada pelo ponto na imagem de origem. Para de fato gerar uma imagem de impressão offset verdadeira contendo apenas pontos redondos em cada canal de cor de tamanho apropriado, seria necessário muito mais trabalho. A cor média em cada ponto em cada canal de cor precisaria ser determinada e, a partir disso, o tamanho apropriado do ponto colorido (círculo com anti-aliasing) gerado. Alguém gostaria de tentar? O acima veio de uma discussão no fórum do IM Efeito de Meio-tom CMYK, que examina como o photoshop 'finge isso' e como o ImageMagick poderia alcançar o mesmo efeito. Essa discussão também está relacionada a Pontilhamento de Meio-tom P/B, que examina mais de perto a geração de telas de meio-tom verdadeiras usando pontos reais de tamanho apropriado. Aquela discussão, entretanto, não chegou ao próximo passo de usar telas com deslocamento (rotacionadas). Tais telas provavelmente exigiriam rotacionar a imagem para gerar os pontos e, depois, rotacionar o padrão de pontos de volta novamente para aquele canal de cor específico.

Mapas de Limiar em XML

A partir da versão 6.3.0 do IM, em vez de usar um conjunto fixo de mapas embutidos no código-fonte do IM (mostrados anteriormente), os mapas agora são lidos de um conjunto de arquivos de dados XML externos ao próprio programa. Como parte dessa mudança, você agora pode listar os 'mapas de limiar' disponíveis que o operador "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" pode usar.

  magick identify -list threshold

A lista acima mostra não apenas os mapas de limiar disponíveis, mas também os apelidos fornecidos para compatibilidade retroativa ou nomenclatura alternativa, e aqueles definidos em meu próprio arquivo de dados XML pessoal "thresholds.xml" (salvo no subdiretório ".magick" do meu diretório pessoal). Quando "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" está procurando um mapa, o primeiro mapa que ele encontra na lista acima será usado. Dessa forma, você não pode sobrescrever um padrão de limiar definido pelo sistema. O arquivo de sistema "thresholds.xml" (cujo caminho é dado pela opção "[-list](https://imagemagick.org/command-line-options/#list)" acima) contém um resumo completo do formato do arquivo XML. Um formato simples o suficiente (com verificações de erro pelo IM) para permitir que os usuários definam e criem seus próprios mapas de limiar para pontilhamento ordenado. Por exemplo, aqui está uma cópia do mapa de limiar 'diag5x5' que defini em meu arquivo pessoal "threshold.xml".

Se você observar, ele cria um mapa simples 5x5 de uma única linha diagonal que se torna mais grossa conforme o nível de limiar aumenta. Os números de nível no mapa vão de 0 a 5, um a menos que o divisor, que declara em quantos 'cinzas' ele precisa dividir o gradiente de cor. Aqui está um gradiente pontilhado usando esse mapa de limiar pessoal.

  magick gradient.png   -ordered-dither diag      od_diag.gif

E aqui está um exemplo de uso desse limiar para pontilhar o canal alfa de uma simples imagem sombreada, propósito para o qual eu o projetei.

  magick -size 70x60 xc:none -font Candice -pointsize 50 \
          -fill black -annotate +10+45 'A' -channel RGBA  -blur 0x5 \
          -fill white -stroke black -draw "text 5,40 'A'"   shadow.png

  magick shadow.png  -channel A  -ordered-dither diag   shadow_diag.gif

Muito legal, não? Mais sobre pontilhamento de canais alfa depois. Primeiro, preciso mostrar também como usar os recursos de coloração do operador "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" expandido.

Pontilhamento Ordenado usando Níveis de Cor Uniformes

Com o lançamento do IM v6.3.0, não apenas os mapas de limiar usados por "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" foram alterados de modo a serem lidos de arquivos externos, mas as operações internas foram aprimoradas para permitir o uso de mapas de cores 'posterizados' definidos matematicamente. Isso significa que você pode gerar um pontilhamento mais determinístico das imagens do que consegue obter com 'pontilhamento por correção de erros'. Isso é especialmente importante para reduções de cores envolvendo animações, pois você não terá problemas com diferenças de cores entre os quadros. Os níveis de posterização são passados ao argumento de "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" usando uma lista extra de números separados por vírgula, anexada ao nome do mapa de limiar a ser usado. Se nenhum número for fornecido, o operador recorre ao mapa de cores normal de 2 cores (ou nível de posterização 1). Por exemplo, um argumento de 'checks,6' usará um clássico Mapa de Cores Seguras para a Web (posterizado no nível 6) (também definido pela imagem de mapa de cores embutida "netscape:"). No entanto, como o mapa de pontilhamento mínimo 'checks' é usado, um único nível extra de pontilhamento é adicionado entre cada um dos 6 níveis de cor, criando 11 pseudo-níveis de cores em cada canal da imagem. Em outras palavras, mesmo que apenas 6 níveis de cor por canal estejam sendo usados (produzindo 6^3 ou 216 cores), o único padrão de pontilhamento entre os níveis aumenta o pontilhamento para 11 níveis efetivos (produzindo 11^3 ou 1331 cores efetivas). Por exemplo, aqui está um gradiente em escala de cinza pontilhado usando 6 níveis de cinza e diversos mapas de limiar. O primeiro mapa 'threshold' é um mapa de limiar especial de pontilhamento ordenado sem pontilhamento, mostrando apenas as cores usadas.

  magick gradient.png   -ordered-dither threshold,6  od_threshold_6.gif
  magick gradient.png   -ordered-dither checks,6     od_checks_6.gif
  magick gradient.png   -ordered-dither o2x2,6       od_o2x2_6.gif
  magick gradient.png   -ordered-dither o4x4,6       od_o4x4_6.gif
  magick gradient.png   -ordered-dither o8x8,6       od_o8x8_6.gif

Como você pode ver, mesmo que apenas 6 cores sejam usadas, com o pontilhamento ordenado você aumenta o número efetivo de cores usadas para definir o gradiente, a ponto de ser difícil perceber quão poucas cores foram realmente usadas! Você não apenas pode definir o número de níveis de posterização para todos os canais, mas, diferente da opção de pontilhamento por correção de erros "[-posterize](https://imagemagick.org/command-line-options/#posterize)", você pode especificar os níveis para cada canal. Os números são atribuídos aos canais conforme a configuração "[-channels](https://imagemagick.org/command-line-options/#channels)". Por exemplo, aqui pontilhamos o gradiente usando um mapa de cores 332 especial (8 níveis de vermelho e verde, 4 de azul) que define um total de 256 cores.

  magick gradient.png   -ordered-dither o8x8,8,8,4   od_o8x8_884.gif

Por causa do número diferente de níveis de cor por canal, a imagem acima não contém apenas cores cinza puras, mas inclui alguns pixels azulados e amarelados que se cancelam mutuamente para produzir níveis extras de cinza. Agora compare a versão pontilhada por ordem com a versão pontilhada por correção de erros usando níveis de posterização de 2 e 6, e um "mapa de cores 332" (8 níveis de vermelho e verde, 4 de azul).

  magick logo.png  -ordered-dither o8x8        logo_o8x8_2.gif
  magick logo.png  -posterize 2                logo_posterize_2.gif
  magick logo.png  -ordered-dither o8x8,6      logo_o8x8_6.gif
  magick logo.png  -posterize 6                logo_posterize_6.gif
  magick logo.png  -ordered-dither o8x8,8,8,4  logo_o8x8_332.gif
  magick logo.png  -remap colormap_332.png     logo_remap_332.gif

A primeira imagem de cada par acima é pontilhada matematicamente por ordem, enquanto a segunda é pontilhada pseudoaleatoriamente por 'correção de erros'. O último par usa o especial 'mapa de cores 332' (veja Gerando Mapas de Cores), que é considerado provavelmente o melhor mapa de cores de posterização para imagens gerais com um limite de 256 cores. A diferença ímpar nos níveis de canal produz um sombreamento de cores ligeiramente melhor para essa imagem em estilo de desenho animado. Foi para permitir a produção do 'mapa de cores 332' que o operador "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" incluiu a capacidade de especificar níveis separados para cada canal de cor.

Melhores Resultados de Pontilhamento Ordenado

Vamos dar uma olhada mais de perto no pontilhamento ordenado de nível 6 que acabamos de gerar.

  magick logo.png -ordered-dither o8x8,6 -format %k info:

Como você pode ver, para essa imagem nem chegamos perto de preencher a tabela de cores do GIF (limite de 256). Basicamente, como a imagem geralmente consiste em sua maioria de cores azuis, pouquíssimos tons de vermelho ou mesmo de verde de um mapa de cores uniforme de nível 6 chegaram a ser usados. No entanto, aumentando o número de níveis de posterização, podemos preencher melhor a tabela de cores do GIF, de modo a produzir uma imagem pontilhada por ordem melhor.

  magick logo.png -ordered-dither o8x8,13 -format %k info:

Isso produz cores suficientes para ficar apenas ligeiramente menor que os limites da tabela de cores do GIF. Com o aumento no número de cores, o resultado fica muito melhor do que os resultados de um simples mapa de cores uniforme padrão. |

  magick logo.png -ordered-dither o8x8,13    logo_o8x8_13.gif

Como você pode ver, com um valor alto de 'níveis', "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" pode produzir imagens comparáveis à quantização de cores, à escolha específica de cores gerada pela quantização de cores e um pontilhamento por correção de erros. O ponto principal sobre essas imagens não é que sejam de alta qualidade. Afinal, uma Quantização de Cores completa pode produzir mais facilmente um mapa de cores melhor para a imagem. Mas sim que o padrão de pontilhamento de baixo nível dentro da imagem é fixo, independentemente de quaisquer pequenas mudanças que possam ocorrer. Apenas as mudanças de área serão alteradas na Imagem Pontilhada por Ordem. Ou seja, elas não têm a Sensibilidade do Pontilhamento por Erros a mudanças que causa problemas para a Otimização de Quadros em animações GIF. (veja Problema de Otimização) É claro que, para uma animação, você precisará usar "[-append](https://imagemagick.org/command-line-options/#append)" em todas as imagens juntas antes de verificar quantas cores são realmente usadas. E você precisará usar a opção especial "[+remap](https://imagemagick.org/command-line-options/#remap)" depois de usar "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" para forçar o IM a gerar um 'mapa de cores global comum' para TODAS as imagens, mesmo que você já tenha realizado a redução de cores e o pontilhamento. Esse método de determinar o número de níveis de cor não é simples de determinar, mas funciona. Espero encontrar uma maneira de o IM determinar o melhor nível automaticamente, especialmente para animações GIF.

Padrões de Pontilhamento e Mapas de Limiar Faça-Você-Mesmo

Anteriormente, mostrei a você que o novo operador "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" pode aceitar um padrão de pontilhamento definido pelo usuário. Aqui vou mostrar como você pode criar seu próprio padrão de pontilhamento. Especificamente, um padrão especial que achei útil para gerar sombras compostas por linhas horizontais.

Padrões de Pontilhamento com Múltiplas Imagens

A primeira coisa que você precisa fazer é criar um conjunto de imagens definindo o padrão que deseja criar. O padrão deve começar com uma imagem preta sólida do tamanho certo como a primeira imagem (todos os pixels desligados) e uma imagem branca sólida na outra extremidade (todos os pixels ligados). A imagem seguinte deve ser o padrão de cinza intermediário de 50%, definindo o estilo básico do pontilhamento que você está tentando alcançar. Por exemplo, aqui está meu padrão de pontilhamento faça-você-mesmo inicial. Que eu salvo em um arquivo GIF de múltiplas imagens (não uma animação GIF)...

  magick -size 2x2 xc:black \
          \( +clone -draw 'fill white line 0,0 1,0' \) \
          xc:white     dpat_hlines2x2.gif
  montage dpat_hlines2x2.gif    -tile x1 -background none -frame 2 \
          -filter box  -geometry 32x32+5+0    dpat_hlines2x2_imgs.gif

Este é praticamente o conjunto mais simples de imagens de padrão de pontilhamento que você pode obter, e é muito semelhante ao 'checks' ou 'Pontilhamento em Tabuleiro de Xadrez', mas com linhas horizontais, em vez de um padrão de xadrez. Então, para que você possa ver como esse padrão de pontilhamento ficaria, aqui está um pontilhamento ordenado faça-você-mesmo bastante simples, que faz uso direto do conjunto de imagens de pontilhamento por limiar.

  magick gradient.png   dpat_hlines2x2.gif \
          -virtual-pixel tile  -fx 'u[(floor((n-1)*u)+1) % n]' dgrad_hlines2x2.gif

  magick shadow.png dpat_hlines2x2.gif  -channel A \
          -virtual-pixel tile  -fx 'u[floor((n-1)*u)+1].g' \
          shadow_dpat_hlines2x2.gif

Mapas de Limiar de Pontilhamento Ordenado Faça-Você-Mesmo

O padrão de pontilhamento faça-você-mesmo acima é o padrão de pontilhamento mais simples que se pode obter e, como tal, podemos convertê-lo diretamente em um mapa de limiar XML, para que o rápido operador embutido "[-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither)" possa fazer uso dele. Aqui está a definição XML final, que salvei em meu próprio arquivo pessoal de mapa de limiar "~/.magick/thresholds.xml" do meu diretório "$HOME".

O formato XML é muito simples e define um mapa de pixels 2x2. A primeira imagem preta recebe um valor de zero e não tem pixels, então nenhum valor zero está presente. Os pixels ligados (tornados brancos) na imagem intermediária são definidos como '1' e os pixels restantes ou da segunda imagem recebem um valor de '2'. O 'divisor=' define o número de imagens, ou pseudo-níveis de cor (níveis de cor falsos) que esse padrão de pontilhamento representa, então ele tem um valor de '3'. Ele divide os valores dos pixels para definir o nível de cor no qual aquele pixel deve ser ligado. Dessa forma, os dois pixels superiores são ligados para cores maiores que 1/3, enquanto os dois inferiores são ligados para valores de cor maiores que 2/3. Ou seja, cada valor de pixel representa um nível de 'limiar', e é por isso que os padrões de pontilhamento também são chamados de mapas de limiar. O resto da definição define os nomes (e apelido opcional) pelos quais você pode se referir ao mapa de limiar para o operador de pontilhamento ordenado. Então, vamos testá-lo...

  magick gradient.png  -ordered-dither hlines2x2  od_hlines2x2.gif
  magick shadow.png  -channel A \
          -ordered-dither hlines2x2   shadow_hlines2x2.gif

Como você pode ver, o resultado é razoavelmente bom, mas podemos fazer outras coisas para melhorá-lo. Ajustando os valores de limiar no mapa, podemos mudar as fronteiras, de modo que ele não divida o espaço de cor em 3 áreas iguais...

Note como aumentei o divisor para '10', de modo a dividir os níveis de cor em dez seções iguais. Em seguida, alterei as configurações de limiar para que o padrão comece em um limiar de 30% na extremidade transparente (preto) e vá até 90% para totalmente opaco (branco). E aqui estão os resultados de alterar o mapa de limiar.

  magick gradient.png  -ordered-dither hlines2x2a  od_hlines2x2a.gif
  magick shadow.png -channel A \
          -ordered-dither hlines2x2a  shadow_hlines2x2a.gif

Como você pode ver, isso ampliou a faixa de pixels semitransparentes que usam linhas horizontais puras como padrão de pontilhamento. Isso proporciona um efeito de sombra melhor, embora provavelmente só deva ser usado com uma sombra menos difusa do que o exemplo usado aqui. Note, porém, que esse tipo de mudança em um limiar é muito incomum. Embora justificado para o uso pretendido neste caso. Basicamente, ele não define adequadamente um gradiente nem permite tons mais claros e mais escuros de padrões. Para isso, precisamos criar um mapa de limiar muito mais complexo, com mais pixels e mais padrões.

Pontilhamento de Linhas Horizontais Faça-Você-Mesmo

Aqui expandi o simples padrão de pontilhamento de linhas horizontais que criei acima em um conjunto de padrões, para produzir um gradiente mais suave de 'desligado' a 'ligado'. Este foi o resultado.

  montage dpat_hlines.gif   -filter box   -geometry 60x20+2+0 \
          -tile x1 -background none  -frame 2   dpat_hlines_images.gif
  magick gradient.png  dpat_hlines.gif  \
          -virtual-pixel tile  -fx 'u[(floor((n-1)*u)+1) % n]' \
          dgrad_dpat_hlines.gif
  magick shadow.png dpat_hlines.gif  -channel A \
          -virtual-pixel tile  -fx 'u[floor((n-1)*u)+1].g' \
          shadow_dpat_hlines.gif

Como você pode ver, ele agora consiste em 9 imagens de 12x4 pixels. Ele não representa todos os padrões de pixels que você poderia ter, mas isso realça o efeito das linhas. Também dobrei sua altura de modo a deslocar as lacunas nas linhas apropriadamente. Aqui está outro exemplo de uso desse padrão de pontilhamento...

  magick -size 120x55 xc:white  -draw 'fill #777 ellipse 50,43 30,5 0,360' \
          -motion-blur 0x15+180   -blur 0x2      sphere_shadow.png
  magick sphere_shadow.png dpat_hlines.gif \
          -virtual-pixel tile  -fx 'u[(floor((n-1)*u)+1) % n]' \
          sphere_shadow_dither.gif
  magick sphere_shadow_dither.gif   -fill red  -stroke firebrick \
          -draw 'circle 35,25 35,5'     sphere_shadow_hlines.gif

O próximo passo é converter esse conjunto de padrões de pontilhamento em uma única imagem de mapa de limiar, em vez de um conjunto de múltiplas imagens. Isso é obtido usando algumas manipulações de imagem sofisticadas para mesclar todas as imagens juntas.

|

  magick -size 1x10 gradient: -flip -crop 1x1 +repage -delete 0,-1 \
          -scale 12x4\! null: \( dpat_hlines.gif -delete 0 \) \
          -alpha off -compose CopyOpacity -layers Composite \
          -reverse -compose Over -flatten -alpha off dmap_hlines.png

O valor '10' é um a mais que o número de imagens no padrão de pontilhamento, enquanto "-scale 12x4\!" é o tamanho dos padrões de pontilhamento sendo convertidos em um mapa de limiar. O resultado é um mapa em escala de cinza, sem cores preto ou branco puras. O nível de cinza usado para um pixel significa que, se o nível de cor for aquele valor de cinza ou maior, então aquele pixel deve ser ligado. Ou seja, cada nível de cinza é o nível de 'limiar' no qual o valor de cor passa de preto para branco. Se você quiser olhar a imagem de outra forma, pixels escuros geralmente resultam em que esses pixels sejam ligados para mais níveis de cor. Enquanto pixels claros só são ligados quando a cor da imagem se torna muito brilhante. Isso é quase uma negação da aparência real da imagem, mas, se você pensar bem, faz sentido. Também usei uma imagem PNG em vez de uma imagem GIF para o mapa, pois apenas uma imagem precisa ser salva e, mais importante, para tentar preservar níveis de qualidade de 16 bits para os valores de limiar. O GIF só consegue lidar com níveis de cor de 8 bits. Agora podemos pontilhar nossas imagens usando apenas uma única imagem, e uma comparação de limiar muito mais simples de cada pixel diretamente contra a imagem (ou mapa) de limiar de pontilhamento.

  magick gradient.png dmap_hlines.png \
          -virtual-pixel tile  -fx 'u>=v'   dgrad_dmap_hlines.gif

  magick dmap_hlines.png pgm:- | pnmdepth 9 | pnmnoraw > dmap_hlines.pgm

Todos os números (exceto o identificador mágico de imagem 'P2') no exemplo acima são os números necessários para gerar o 'mapa de limiar' apropriado, que você pode adicionar ao seu arquivo pessoal "thresholds.xml". Por exemplo, aqui está a entrada de mapa de limiar resultante criada a partir do acima.

E aqui está um exemplo de uso desse mapa de limiar.

  magick shadow.png  -channel A  -ordered-dither hlines   shadow_hlines.gif

E é assim que você pode gerar um mapa de limiar complexo a partir de uma progressão de imagens.

Pontilhamento com Padrões de Símbolos

Agora, embora você possa usar um único mapa de limiar ou imagem de limiar, em vez de um conjunto de padrões de múltiplas imagens para a maioria das operações de pontilhamento, isso não significa que os mapas de múltiplas imagens não tenham seus próprios usos. Você pode usar um conjunto de imagens de consulta para ladrilhar várias áreas de uma só vez, em vez de uma de cada vez. Por exemplo, escalando uma imagem simples e depois substituindo cada pixel de uma imagem por um símbolo específico. Por exemplo, aqui pego a pequena imagem de 'olhos' e substituo os pixels individuais por vários símbolos, para produzir tal padrão para cada pixel na imagem original.

  montage dpat_symbols.gif   -geometry +5+0 \
          -tile x1 -background none -mattecolor blue  -frame 3 \
          dpat_syms_images.gif
  magick eyes.gif -alpha off -colorspace sRGB -grayscale Average \
          -alpha off -scale 1600% -negate  \
          dpat_symbols.gif -virtual-pixel tile -fx 'u[floor(15.9999*u)+1]' \
          eyes_syms.gif

O montage é usado para expandir a imagem GIF de múltiplas imagens para que você possa ver seu conteúdo, sem que ela seja 'animada'. Você pode ajustar qual método de intensidade "[-grayscale](https://imagemagick.org/command-line-options/#grayscale)" deseja usar, do normal 'Rec709Luminance' a um mais escuro 'Rec709Luma', ou usar uma 'média' de um espaço de cor não linear 'sRGB' ou de um espaço de cor linear 'RGB'. Você pode até ajustar o escalonamento "[-gamma](https://imagemagick.org/command-line-options/#gamma)" dos valores para obter a melhor distribuição de cores. Há muitas possibilidades, e o que é bom depende mais do arranjo dos seus símbolos do que do método realmente escolhido. A chave no exemplo acima é garantir de alguma forma que cada cor na imagem de entrada produza um símbolo único, e isso pode ser muito difícil de conseguir. Este exemplo pode ser usado para criar guias de ponto cruz ou tricô que amadores possam seguir, gerando obras de arte em maior escala a partir de imagens de computador menores. Você pode usar essa técnica para ladrilhar imagens em escala de cinza com um conjunto de imagens coloridas de ladrilho. O resultado é um pouco como os mapas de paisagem vistos em muitos jogos de guerra de computador antigos.

  montage dpat_map.gif   -geometry +5+0 -tile x1  -background none  \
          dpat_map_images.gif
  magick -seed 100 \
          -size 200x200 plasma:'gray(50%)-gray(50%)' -blur 0x15 \
          -channel G -auto-level +channel -set colorspace sRGB \
          dpat_map.gif -virtual-pixel tile  -fx 'u[floor(5.999*u.g)+1]' \
          map.gif

Note que eu precisei garantir que o IM considerasse a imagem em escala de cinza como já estando no espaço de cor sRGB final (assim como as imagens de ladrilho estão), embora sejam na verdade dados RGB lineares que estão sendo usados para consultas de índice FX. Sem isso, o 'mapa' resultante fica enviesado em direção a paisagens arborizadas, com pouca chance de áreas de água. Como você pode ver, qualquer conjunto de imagens pode ser usado para os ladrilhos, as imagens nem precisam se alinhar entre si, ou mesmo ser ladrilhos do mesmo tamanho. É claro que, se os ladrilhos forem do mesmo tamanho e estiverem intimamente relacionados entre si, como no caso dos 3 ladrilhos azuis de 'mar', o padrão ladrilhado pode 'fluir' de uma área ladrilhada para outra. Substituindo o ladrilho por imagens de números, você também pode gerar uma espécie de guia de pintar por números. No entanto, algum processamento extra pode ser necessário para delimitar as diferentes áreas. Isso fica como um exercício; envie-me suas soluções por e-mail, e você poderá ter seu nome nos exemplos do IM como autor dessa técnica.

Notas Aleatórias e Possibilidades Futuras do Pontilhamento Ordenado

Em Construção

Pontilhamento ordenado com pequenos números de cores.

Ao usar um pequeno número de cores para uma imagem pequena, um pontilhamento pseudoaleatório como o pontilhamento por correção de erros de curva de hilbert do IM, ou mesmo um pontilhamento por correção de erros Floyd-Steinberg mais simples (veja Pontilhamento por Correção de Erros acima), produz um resultado de aparência horrível. Idealmente, um Pontilhamento Ordenado deveria ser usado com imagens de poucas cores e do tipo ícone pequeno para produzir um resultado de aparência muito melhor. No entanto, no momento, o pontilhamento ordenado no IM só pode usar tabelas de cores 'fixas' geradas matematicamente, e não apenas uma coleção das 'melhores' cores.

Pontilhamento ordenado com um mapa de cores quaisquer

Existe algum algoritmo que permitirá usar um conjunto de cores específicas para o pontilhamento ordenado. Basicamente, adicionando as 'pseudo-cores' que um algoritmo de pontilhamento ordenado pode gerar (o que poderia envolver pontilhamento de três cores) ao mapa de cores dado, para 'preenchê-lo'. Você pode então 'mapear' os pixels individuais de uma imagem para esse 'mapa de cores expandido'. A partir desse mapeamento inicial para uma pseudo-cor específica, a cor real pode ser escolhida do mapa de limiar que gera aquela pseudo-cor, e assim pontilhar por ordem as áreas dessa cor, e assim a imagem inteira para um dado conjunto de cores. Por causa da minha experiência com ícones, e agora com animações GIF, eu definitivamente gostaria de ver um pontilhamento ordenado de qualquer cor implementado, mas ainda não encontrei uma referência prática de como fazer pontilhamentos ordenados com um conjunto fixo de cores.