Exemplos do ImageMagick -- Modificações de Cor

Prefácio e Índice dos Exemplos do ImageMagick

Convertendo Cor para Escala de Cinza

Ajustes de Nível da Imagem

• Invertendo Imagens (trocando preto e branco)
• Operador de Ajuste de Nível (ajuste de contraste e de preto/branco)
• Ajustes de Nível Invertidos (redução de contraste)
• Ajuste de Nível por Gama (ajustes de meios-tons)
• Ajuste pelo Operador de Gama (gama sem ajustes de nível)
• Ajustes de Nível por Cor (ajustar níveis da imagem usando cores)
• Contraste por Não-linearidade Sigmoidal (ajuste de contraste não linear)

• Ajustes Diversos de Contraste

  Ajustes Usando Modificação do Histograma (alterando o histograma de uma imagem)

• Alongamento Linear do Histograma

• Normalize (alongamento automático de níveis)
• Alongamento de Contraste (alongamento controlado)
• Alongamento Linear (alongamento alternativo)
• Redistribuição do Histograma
• Equalize (redistribuição uniforme do histograma)
• Redistribuição Gaussiana

• Metodologia da Redistribuição do Histograma

  Ajustes de Nível "Faça Você Mesmo" (operadores gerais de tingimento)

• Ajustes Lineares Matemáticos "Faça Você Mesmo"

• Ajustes Não Lineares Matemáticos

• Ajustes por 'Curvas'

  Tingimento dos Meios-tons das Imagens (operadores gerais de tingimento)

• Tingimento Uniforme de Cor

• Tingimento de Cor nos Meios-tons
• Coloração em Tom Sépia
• Efeito Duotone
• Tingimento de Cor, Faça Você Mesmo

• Sobreposição de Tingimento de Cor

  Modificadores Globais de Cor

• Modular Brilho, Saturação e Matiz

• Modular o Ciclo de Cores da Matiz
• Modulate "Faça Você Mesmo"
• Modular em Outros Espaços de Cor
• Modular em LCHuv e Outros Espaços de Cor
• Operador de Matriz de Cor

• Coloração por Solarização

  Recolorindo Imagens com Tabelas de Consulta

• Tabelas de Consulta de Cor

• Conversão de Função para LUT de Cor
• CLUT e Tratamento de Transparência
• Tabelas de Consulta de Cor 3D Hald
• Limitações do Hald CLUT
• Substituição de Cor usando Hald CLUT
• Substituição Completa do Mapa de Cores (sem solução, apenas ideias)

Aqui examinamos técnicas para modificar todas as cores de uma imagem como um todo. Seja para clarear ou escurecer a imagem, ou para modificações de cor mais drásticas. Para explorar essas técnicas, precisaremos de uma imagem de teste...
Não se preocupe em como eu realmente gerei essa imagem, isso não é importante para o exercício. Eu a projetei para conter uma variedade de cores, transparências e outras características, especificamente para exercitar bem o IM quando usado. |
---|---
Se você tiver real interesse nos comandos usados para gerar essa imagem, pode consultar o script especial, "[**generate_test**](../static/img/scripts/generate_test)", que uso para criá-la. | AVISO: Os processos de cor abaixo geralmente assumem que a imagem está usando um espaço de cor linear. A maioria das imagens, porém, é salva usando um espaço de cor sRGB ou corrigido por gama, de modo que, para acertar as coisas, a correção de espaço de cor também deve ser aplicada primeiro.
---|---

Convertendo Cor para Escala de Cinza

Imagens em escala de cinza podem ser muito úteis para diversos fins, como o processamento adicional da imagem original ou o uso em composições de fundo. O melhor método de converter uma imagem para escala de cinza é simplesmente pedir ao IM que transforme a imagem em uma representação em Espaço de Cor de escala de cinza.

  magick test.png  -colorspace Gray   gray_colorspace.png

Observe como o azul fica muito mais escuro que o vermelho, devido à ponderação que corresponde à intensidade como ela parece ser percebida pelo olho humano. Ou seja, 'red' é uma cor bastante brilhante em comparação com 'blue', que parece mais escura. Isso é equivalente ao uso da fórmula de conversão 'rec709luma' com o operador dedicado "[-grayscale](https://imagemagick.org/command-line-options/#grayscale)" (adicionado no IM v6.8.3-10). |

  magick test.png  -grayscale rec709luma  gray_grayscale.png

O valor 'rec709luma' é apenas uma das muitas fórmulas de escala de cinza definidas para uso pela configuração "[-intensity](https://imagemagick.org/command-line-options/#intensity)" (veja abaixo). Aqui, por exemplo, está a outra fórmula comum de escala de cinza, 'rec601luma' |

  magick test.png  -grayscale rec601luma  gray_grayscale_601.png

Como você pode ver, há uma leve diferença nos níveis de intensidade para os diferentes canais de cor vermelho, verde e azul.
No entanto, existem muitos outros métodos e significados para 'escala de cinza'... Por exemplo, você pode drenar toda a cor da imagem usando o Operador Modulate, definindo todos os níveis de saturação de cor como zero. |

  magick test.png  -modulate 100,0  gray_modulate.png

Isso essencialmente converte a imagem para o espaço de cor HSL e extrai o valor de escala de cinza 'Lightness' desse espaço de cor. Porém, usando um "-define modulate:colorspace", você pode especificar outros modelos de espaço de cor para usar. Veja Modular em Outros Espaços de Cor abaixo. Observe como a cor 'green' do IM que usei para o disco colorido central na minha imagem de teste não é, na verdade, um verde puro, como o usado no arco-íris colorido, mas o verde de meio brilho definido pelo novo padrão SVG -- Scalable Vector Graphics. Se você precisar de um verde RGB puro, pode usar a cor 'lime' em vez disso. Veja Conflitos de Nomes de Cores para mais detalhes. Outra maneira é usar o Operador FX "Faça Você Mesmo" para tirar a média dos três canais e obter um significado puramente matemático de escala de cinza. |

  magick test.png -fx '(r+g+b)/3' gray_fx_average.png

| A média dos valores dos canais sRGB também é equivalente ao canal de intensidade do espaço de cor 'OHTA' (canal vermelho). Ou o canal 'I' do espaço de cor HSI.
---|---
Outra técnica é simplesmente somar os três canais (uma medida de cor conhecida como distância de Manhattan) e, embora a imagem resultante não perca informação devido a efeitos de 'arredondamento quântico', você pode perder informação sobre as cores mais brilhantes. Infelizmente, você também perde o canal de transparência. |

  magick test.png -separate \
          -background black -compose plus -flatten   gray_added.png

Você pode usar a mesma técnica de soma de canais para controlar a ponderação dos canais de cor individuais. Por exemplo, esta é uma fórmula "faça você mesmo" que você pode usar... |

  magick test.png -fx '0.3*r+0.6*g+0.1*b' gray_diy.png

Você também pode usar 'intensity' se quiser o mesmo significado dentro do operador "[-fx](https://imagemagick.org/command-line-options/#fx)". |

  magick test.png  -fx intensity  gray_intensity.png

No entanto, como o Operador FX "Faça Você Mesmo" é interpretado, ele pode ser executado muito, muito lentamente. Para operações mais complexas, você pode usar o mais simples Operador Evaluate, "[-evaluate](https://imagemagick.org/command-line-options/#evaluate)". Por exemplo, aqui está uma imagem em escala de cinza com proporção 2/5/3, embora, novamente, eu não faça nenhuma tentativa de preservar o canal de transparência da imagem original. | |

  magick test.png -channel R -evaluate multiply .2 \
                   -channel G -evaluate multiply .5 \
                   -channel B -evaluate multiply .3 \
                   -channel RGB -separate -compose add -flatten gray_253.png

| _O procedimento acima sofreria com efeitos de 'quantização' em um ImageMagick compilado em um Nível de Qualidade 'Q8'. Isso porque os resultados do "[-evaluate](https://imagemagick.org/command-line-options/#evaluate)" serão salvos em um pequeno inteiro de 8 bits, usado para os valores da imagem. Só depois esses valores são somados, com a perda de precisão resultante.

Um ImageMagick compilado com 'Q16', ou melhor ainda com as opções de compilação de qualidade HDRI, produzirá um resultado muito mais exato. Outra nova alternativa é o Poly - Operador de Fusão Ponderada de Imagens, que fará a ponderação e a soma das imagens de canal separadas em uma única operação, evitando assim os efeitos de 'arredondamento quântico'.

_
---|---
Uma técnica semelhante pode ser usada para gerar uma escala de cinza puramente matemática, calculando diretamente a média igual dos três canais RGB. |

  magick test.png -separate -evaluate-sequence mean  gray_average.png

No entanto, como você pode ver, não tentei preservar o canal alfa da imagem resultante. Outra alternativa rápida é usar o operador de matriz de cor "[-recolor](https://imagemagick.org/command-line-options/#recolor)", que permite especificar a ponderação dos três canais de cor. |

  magick test.png -recolor '.2 .5 .3
                             .2 .5 .3
                             .2 .5 .3'   gray_recolor.png

Isso não afeta a transparência, mas torna-se uma maneira muito melhor de converter cores usando uma ponderação específica. Basicamente, a primeira linha de números é a ponderação de canal para o canal vermelho da imagem resultante, os três seguintes para o verde e os três números finais para o azul. Você também pode usar "[-type](https://imagemagick.org/command-line-options/#type)" para dizer ao IM que trate a imagem como escala de cinza, ao ler ou gravar a imagem. |

  magick test.png  -type GrayScaleAlpha  gray_type.png

| A configuração "[-type](https://imagemagick.org/command-line-options/#type)" geralmente só é usada como orientação quando uma imagem está sendo lida ou gravada em um arquivo. Como tal, sua ação é adiada até a gravação final da imagem. Seu efeito também depende fortemente das capacidades do formato de arquivo de imagem envolvido e serve para substituir a determinação normal do ImageMagick durante esse processo. Veja os exemplos de Type para mais informações.
---|---
| Antes do IM v6.3.5-9, o procedimento acima teria removido qualquer transparência na imagem gravada (equivalente a um "[-type](https://imagemagick.org/command-line-options/#type) Grayscale") devido a um bug. Isso foi corrigido assim que notei o problema e o reportei. (Há uma lição aqui :-)
---|---

Uma técnica muito mais interessante é extrair uma variedade de diferentes significados de brilho, extraindo o Canal de Cor apropriado de várias representações de Espaço de Cor da imagem. Para exemplos, veja Canais de Escala de Cinza a partir de Representações de Espaço de Cor.

Ajustes de Nível da Imagem

A forma mais básica de ajuste que você pode fazer em imagens é conhecida como ajuste de 'nível'. Isso basicamente significa pegar os valores de cor RGB individuais (ou até mesmo os valores do canal alfa) e ajustá-los de modo a alongar ou comprimir esses valores. Como apenas os valores de canal são ajustados, eles são mais bem demonstrados em uma imagem em escala de cinza do que em uma imagem colorida. Porém, se você ajustar todos os canais de cor de uma imagem na mesma proporção, poderá usá-los com imagens coloridas, com o propósito de realçar ou ajustar a imagem. Não confunda isso com a forma mais automática de ajuste de nível, que veremos na próxima seção principal de exemplos abaixo, Ajustes de Normalização. Esta função realiza exatamente a mesma operação, independentemente do conteúdo real da imagem. Não importa se a imagem é clara ou escura, ou se tem um tom azulado ou amarelado. As operações são cegas ao conteúdo real da imagem. Ao demonstrar essas operações, usarei um gráfico modificado do "[gnuplot](http://www.gnuplot.info/)", como o mostrado à direita, que gero usando um script especial "[im_graph](../static/img/scripts/im_graph)". O gráfico tem uma linha vermelha que mapeia o valor 'x' original fornecido (representando o valor de escala de cinza do gradiente superior) para o valor 'y' mostrado. O gradiente de cor resultante também é mostrado abaixo do gradiente linear de entrada. O gráfico mostrado à direita é do operador "[-noop](https://imagemagick.org/command-line-options/#noop)" do IM, que na verdade não faz nada com a imagem. Assim, cada um dos valores de cor da imagem é mapeado para exatamente o mesmo valor, sem alteração. Portanto, o gradiente inferior é igual ao gradiente superior.

Inversão da Imagem

O ajuste global de nível mais simples e básico que você pode fazer é inverter a imagem, usando o operador de imagem "[-negate](https://imagemagick.org/command-line-options/#negate)". Essencialmente, isso torna o branco em preto e o preto em branco, ajustando todas as cores para corresponder. Ou seja, ele tornará a cor vermelha em sua cor complementar, o ciano, e o azul em amarelo, etc. Você pode ver isso no gráfico de mapeamento mostrado abaixo, enquanto uso o operador "[-negate](https://imagemagick.org/command-line-options/#negate)" tanto na imagem 'test' quanto na imagem interna padrão 'rose' do IM. Observe como o gradiente inferior na imagem do gráfico de mapeamento agora está invertido, de modo que preto e branco são trocados, e a mesma inversão aparece na imagem 'test' invertida.

  magick test.png  -negate  test_negate.png
  magick rose:    -negate  rose_negate.gif

| |

---|---|---

Internamente, o negate é na verdade bastante simplório. Ele trata os três canais de cor de forma independente e, por padrão, ignora o canal alfa. Se não fosse assim, você obteria um resultado bem tolo como este...

  magick test.png -channel RGBA  -negate  negate_rgba.png

A imagem é invertida, como você pode ver pelo gradiente de cor semitransparente. Mas, como o canal de transparência também foi invertido, você perde todas as cores opacas da imagem. É por isso que a configuração padrão de "[-channel](https://imagemagick.org/command-line-options/#channel)" é 'RGB'. Veja Canais de Cor para mais informações. Você pode limitar a inversão a apenas um canal, digamos, o canal de cor verde. Isso pode não parecer muito útil, mas às vezes é de importância vital.

  magick test.png -channel green  -negate  negate_green.png

O operador "[-negate](https://imagemagick.org/command-line-options/#negate)" é, na verdade, seu próprio inverso. Fazer duas inversões com a mesma configuração de "[-channel](https://imagemagick.org/command-line-options/#channel)" cancela uma à outra.

  magick negate_green.png  -channel green  -negate  negate_restore.png

A inversão é extremamente comum no processamento de imagens, particularmente ao lidar com imagens em escala de cinza como uma etapa antes ou depois de outras opções de processamento. Por isso, recomendo que você brinque com ela e a mantenha em mente sempre que estiver fazendo qualquer coisa, pois trabalhar com imagens invertidas pode resolver alguns problemas que, de outra forma, seriam difíceis.

Ajustes Diretos de Nível

O operador "[-level](https://imagemagick.org/command-line-options/#level)" é o operador de ajuste de nível mais geral. Você basicamente fornece a ele dois valores, um 'black_point' e um 'white_point', além de um terceiro valor opcional (ajuste de gama), que examinarei mais adiante. O que ele faz é mapear quaisquer valores de cor na imagem que sejam iguais ou menores que o 'black_point' e torná-los pretos (ou um valor 0). Da mesma forma, quaisquer valores de cor que sejam iguais ou mais brilhantes que o 'white_point' serão tornados brancos (ou um valor máximo). As cores entre esses dois pontos são então 'alongadas' linearmente para preencher toda a faixa de valores. O efeito disso é melhorar o contraste, realçando as cores dentro de uma imagem. Por exemplo, aqui está um realce de contraste de 25% da nossa imagem de teste, usando os mesmos valores mostrados no gráfico. Como você comumente ajusta tanto o ponto preto quanto o branco na mesma proporção a partir de 0% e 100%, pode especificar apenas o 'black_point'. O ponto branco será ajustado na mesma proporção para dentro.

  magick test.png  -level 25%,75%  test_level.png
  magick rose:    -level 25%      rose_level.gif

| |

---|---|---

Observe que 25% é um enorme realce de contraste para qualquer imagem, mas mostra claramente o que ele faz. Você não precisa alterar ambos os pontos, 'preto' e 'branco'. Em vez disso, é perfeitamente aceitável ajustar apenas uma extremidade da faixa de cores. Por exemplo, podemos criar uma imagem rose muito clara ou muito escura.

  magick rose: -level 0,75%     rose_level_light.gif
  magick rose: -level 25%,100%  rose_level_dark.gif

No entanto, aviso novamente que as cores fora da faixa fornecida são 'cortadas' ou 'queimadas' e, como tal, não estarão mais disponíveis para processamento posterior da imagem. Este é o maior problema ao usar um operador "[-level](https://imagemagick.org/command-line-options/#level)". Usando um valor negativo, você pode fazer uma redução de contraste aproximada de uma imagem. O que isso significa é que, em vez de fornecer um valor de cor para os valores que serão mapeados para 'preto' e 'branco', alongando assim as cores intermediárias, você comprime os valores de cor de modo a mapear a cor negativa imaginária para preto ou branco. O resultado é um acinzentamento geral da imagem. |

  magick rose: -level -25%  rose_decontrast.gif

Este método de redução de contraste de uma imagem, porém, é muito impreciso e não é recomendado, a menos que você tenha um IM mais antigo que a versão 6.4.2, onde não há acesso ao novo Operador de Nível Invertido. Você pode usar o operador "[-level](https://imagemagick.org/command-line-options/#level)" para inverter uma imagem (como já mostrado acima), simplesmente trocando os valores dos pontos 'preto' e 'branco' fornecidos, usando "-level 100%,0". |

  magick rose: -level 100%,0  rose_level_neg.gif

Ou, definindo-os com o mesmo valor, você pode efetivamente fazer com que todos os valores de cor da imagem sejam limiarizados. Usar "[-level](https://imagemagick.org/command-line-options/#level)" para limiarizar uma imagem é exatamente o mesmo que usar um Operador de Limiar com esse valor. O gráfico de mapeamento mostrado à direita apresenta os resultados de uma operação "-level 50%,50%" e seu efeito em um gradiente de escala de cinza. |

  magick rose: -level 50%,50%  rose_level_thres.gif

Ajustes de Nível Invertidos -- Reduzindo o Contraste das Imagens

A partir da versão 6.4.2 do IM, o Operador de Nível foi expandido para fornecer uma forma 'invertida' "[+level](https://imagemagick.org/command-line-options/#level)" (note o 'mais'). Alternativamente, você pode usar a forma original "[-level](https://imagemagick.org/command-line-options/#level)" do operador, mas adicionar um '!' ao argumento de nível fornecido (para interfaces de API mais antigas). Os argumentos para esta variante são exatamente os mesmos, mas, em vez de alongar os valores de modo a mapear o 'black_point' e o 'white_point' para 'preto' e 'branco', ela mapeia 'preto' e 'branco' para os pontos fornecidos. Em outras palavras, "[+level](https://imagemagick.org/command-line-options/#level)" é exatamente o inverso de "[-level](https://imagemagick.org/command-line-options/#level)". Por exemplo, aqui mapeamos 'preto' para um cinza de 25% e branco para um cinza de 75%, reduzindo efetivamente o contraste da imagem de forma muito exata, usando os dois métodos de especificar a forma 'invertida'.

  magick test.png   +level 25%    test_level_plus.png
  magick rose:     -level 25%\!  rose_level_plus.gif

| |

---|---|---

Se você comparar a operação "+level 25%" acima com o uso de uma redução de contraste negativa, o operador "-level -25%" que mostramos anteriormente, verá que não são a mesma coisa. A versão 'mais' produz uma imagem com contraste muito mais fortemente reduzido (é mais acinzentada), mas o faz mapeando para os valores exatos que você fornece ao operador, e não para os valores 'imaginários' que a forma 'menos' usava. Esse uso de valor exato é importante e uma das razões pelas quais a forma 'mais' do operador foi adicionada. Claro que '25%' é novamente um valor muito grande, e não é recomendado para uso em trabalhos típicos com imagens. Observe que "[-level](https://imagemagick.org/command-line-options/#level)" e "[+level](https://imagemagick.org/command-line-options/#level)" são, de fato, exatamente inversos um do outro quando recebem o mesmo argumento. Ou seja, um mapeia valores para os extremos da faixa, enquanto o outro mapeia a partir dos extremos da faixa. Por exemplo, aqui comprimimos as cores da imagem de teste usando "[+level](https://imagemagick.org/command-line-options/#level)" e depois as descomprimimos novamente usando "[-level](https://imagemagick.org/command-line-options/#level)", de modo a restaurar a imagem para próximo de sua aparência original.

  magick test.png  +level 20%  -level 20%  test_level_undo.png

As duas imagens parecem muito, muito semelhantes e, como estou usando uma versão de alta qualidade 'Q16' do IM, você terá dificuldade em notar qualquer diferença. No entanto, os valores podem não ser exatamente iguais, pois você comprimiu efetivamente os valores de cor da imagem para uma faixa menor de inteiros e depois os restaurou novamente. Em casos extremos, isso pode resultar em Efeitos de Arredondamento Quântico. Fazer essas duas operações na ordem oposta (alongar e depois comprimir os valores de cor) produzirá Efeitos de Recorte Quântico. Outro aspecto útil do operador "[+level](https://imagemagick.org/command-line-options/#level)" é que você pode comprimir completamente todos os valores de cor de uma imagem para o mesmo nível de escala de cinza.

  magick test.png  +level 30%,30%  test_level_const.png

Ao especificar níveis de acordo com os valores de cores específicas para cada canal individual, você pode efetivamente transformar um gradiente de escala de cinza em um gradiente de cor específico. No entanto, isso é bastante difícil de calcular e executar. Por isso, também foi fornecido um operador "[-level-colors](https://imagemagick.org/command-line-options/#level-colors)" que permite especificar os pontos preto e branco em termos de cores específicas, em vez de valores de 'nível'. Veja Nível por Cor abaixo.

Ajustes de Nível por Gama

Ambas as variantes de "[-level](https://imagemagick.org/command-line-options/#level)" acima também permitem que você use uma terceira configuração. O valor de ajuste de 'gama'. Por padrão, ele é definido com o valor 1.0', que não faz nenhum tipo de ajuste de meio-tom na imagem resultante, produzindo um mapeamento puramente linear dos valores da imagem antiga para a nova imagem. No entanto, ao tornar esse valor maior, você curvará a linha resultante de modo a clarear a imagem, enquanto reduzir esse valor escurecerá a imagem. Por exemplo, aqui uso apenas a configuração de 'gama' para clarear e escurecer apenas os meios-tons da imagem.

  magick rose: -level 0%,100%,2.0   rose_level_gamma_light.gif
  magick rose: -level 0%,100%,0.5   rose_level_gamma_dark.gif

Os valores geralmente variam de 10 para uma imagem ofuscantemente brilhante a .2 para uma imagem muito escura. Como mencionado, um valor de 1.0 não fará nenhuma alteração de 'gama' na imagem. No entanto, o valor especial de '2.0' (veja acima) pode ser usado para obter a raiz quadrada da cor normalizada da imagem. Ambas as versões do operador "[-level](https://imagemagick.org/command-line-options/#level)" tratam a 'gama' da mesma maneira. Isso significa que você pode combinar o ajuste de nível das extremidades 'preta' e 'branca' com um ajuste não linear de 'gama'. Você também pode ajustar apenas um único canal de uma imagem. Por exemplo, aqui damos a uma imagem um leve tingimento na extremidade preta apenas do canal azul, enquanto usamos a gama para preservar os níveis de cor dos meios-tons da imagem.

  magick test.png  -channel B +level 25%,100%,.6 test_blue_tint.png

Este exemplo específico poderia ser usado para tingir uma foto de satélite meteorológico, onde apenas o mar é preto puro, enquanto a terra é mais acinzentada. Outras alternativas a esse ajuste do canal azul são apresentadas abaixo em Ajustes Não Lineares Matemáticos "Faça Você Mesmo".

Ajustes pela Operação de Gama

O operador "[-gamma](https://imagemagick.org/command-line-options/#gamma)" também é fornecido e tem exatamente o mesmo efeito que a configuração 'gama' no operador "[-level](https://imagemagick.org/command-line-options/#level)". No entanto, ele permite que você ajuste o nível de 'gama' para cada canal individual também. Seu uso real é no ajuste da função de 'gama' de uma imagem antes de realizar operações lineares sobre ela. Para mais detalhes, veja Percepção Humana de Cor e Correção de Gama. Também podemos usar essa função para clarear a imagem de forma diferente para cada canal RGB individual. |

  magick rose: -gamma 0.8,1.3,1.0  gamma_channel.gif

Como você pode ver, isso pode ser usado para fazer alguns tingimentos e ajustes de cor sutis em uma imagem, ou corrigir imagens que contêm cor demais de uma determinada cor. | _Para saber por que você deveria usar essa função, vejaCorreção de Gama.

_
---|---
Esta função é, na verdade, equivalente à Função POW do Evaluate, mas com o argumento invertido. Assim, um "-evaluate POW 2.2" fará, na verdade, uma operação "-gamma 0.45455" (0.45455 é igual a 1/2.2), que é o inverso de um "-gamma 2.2".
Um dos usos menos óbvios de "[-gamma](https://imagemagick.org/command-line-options/#gamma)" é zerar canais de imagem específicos (veja Zerando Canais de Cor). Ou colorir uma imagem completamente de 'preto', 'branco' ou alguma outra cor primária (veja Telas de Cor Primária).

Ajuste de Nível por Cor

O operador "[-level-colors](https://imagemagick.org/command-line-options/#level-colors)" foi adicionado ao IM v6.2.4-1. Essencialmente, é exatamente o mesmo que o Operador de Nível que discutimos acima, mas com o valor de cada canal especificado como um valor de cor. Ou seja, a opção "[-level-colors](https://imagemagick.org/command-line-options/#level-colors)" mapeará as cores fornecidas para 'preto' e 'branco', alongando linearmente todas as outras cores entre elas. Isso efetivamente remove da imagem a faixa de cores fornecida. E, embora funcione, não é particularmente útil, pois tende a falhar para cores que têm valores comuns em algum canal. Por exemplo, as cores 'DodgerBlue' e 'White' têm os mesmos valores de cor no canal azul. Assim, "-level-colors DodgerBlue,White" pode nem sempre transformar essas cores em preto e branco. A melhor técnica nesse caso é extrair uma imagem em escala de cinza do canal com as maiores diferenças (como o vermelho) e aplicar level ou normalize a esse canal. AVISO: cuidado com cores 'transparentes'.
A forma mais do operador "[+level-colors](https://imagemagick.org/command-line-options/#level-colors)", por outro lado, é extremamente útil, pois mapeia as cores 'preta' e 'branca' para os valores fornecidos, comprimindo linearmente todas as outras cores para caberem entre as duas cores que você fornece. Por exemplo, vamos mapear 'black' e 'white' para 'green' e 'gold'...

  magick test.png  +level-colors green,gold   levelc_grn-gold.png

Como você pode ver, o gradiente de escala de cinza é remapeado para um gradiente delimitado pelas cores fornecidas e, embora as cores fora de uma faixa de escala de cinza também sejam modificadas, elas também seguirão o estilo básico da faixa de cores especificada. Isso torna o operador "[+level-colors](https://imagemagick.org/command-line-options/#level-colors)" extremamente útil, especialmente ao mapear imagens em escala de cinza. Se você fornecer apenas um nome de cor, mas incluir uma vírgula, a cor ausente assumirá por padrão 'black' ou 'white', conforme apropriado.

  magick test.png  +level-colors ,DodgerBlue   levelc_dodger.png
  magick test.png  +level-colors ,Gold         levelc_gold.png
  magick test.png  +level-colors ,Lime         levelc_lime.png
  magick test.png  +level-colors ,Red          levelc_red.png

  magick test.png  +level-colors Navy,         levelc_navy.png
  magick test.png  +level-colors DarkGreen,    levelc_darkgreen.png
  magick test.png  +level-colors Firebrick,    levelc_firebrick.png

Isso facilita transformar imagens em escala de cinza em um gradiente para qualquer cor que você quiser. Por exemplo, aqui remapeio um gradiente preto e branco para um gradiente vermelho e branco (note a ',' no argumento)...

  magick cow.gif   +level-colors red,   cow_red.gif

Isso não apenas substituiu 'preto' por 'vermelho', mas também remapeou todas as cores cinzas com suavização de bordas para uma mistura apropriada de 'vermelho' e 'branco', produzindo um resultado bem suave. Se eu tivesse apenas realizado uma simples Substituição Direta de Cor convertendo cores pretas puras em vermelho, eu acabaria com a imagem horrível (mostrada à direita). Veja Fator de Fuzz para o exemplo usado na geração dessa imagem. Claro que, se você quiser que uma das cores seja tornada transparente, é melhor usar o operador -alpha Shape, pois isso exige que você transfira o gradiente para o canal alfa.
Se você especificar apenas uma única cor, sem qualquer separador de 'vírgula', essa cor será usada tanto para o ponto preto quanto para o branco. Isso significa que todas as cores da imagem serão redefinidas para essa única cor. (de acordo com as limitações da configuração atual de "[-channel](https://imagemagick.org/command-line-options/#channel)"). |

  magick test.png  +level-colors dodgerblue  levelc_blue.png

Este é um resultado idêntico ao uso de "-fill DodgerBlue -colorize 100%" para Colorir Imagens (veja abaixo). Se você quiser definir também a transparência da imagem, precisará configurar "[-channel](https://imagemagick.org/command-line-options/#channel)" para incluir o canal de transparência, OU definir o Canal Alfa como totalmente opaco, usando "-alpha opaque" ou "-alpha off". |

  magick test.png -channel ALL +level-colors dodgerblue levelc_blue2.png

Veja também Apagando Imagens Existentes. Aqui estão mais alguns exemplos de uso disso para ajustar ou 'tingir' uma imagem colorida, em vez de uma imagem em escala de cinza.

  magick rose: +level-colors             navy,lemonchiffon  levelc_faded.gif
  magick rose: +level-colors        firebrick,yellow        levelc_fire.gif
  magick rose: +level-colors 'rgb(102,75,25)',lemonchiffon  levelc_tan.gif

Em resumo, o "[+level-colors](https://imagemagick.org/command-line-options/#level-colors)" é uma substituição de cor em gradiente, um operador de tingimento linear, e também pode redefinir cores completamente.

Contraste por Não-linearidade Sigmoidal

A partir de um artigo em PDF sobre 'Fundamentals of Image Processing ' (página 44), apresenta-se uma alternativa ao uso de um controle de contraste linear (level), com um que usa correção de gama conhecido como 'controle de contraste por não-linearidade sigmoidal '. O resultado é uma mudança de contraste não linear e suave (uma 'Função Sigmoidal' em termos matemáticos) sobre toda a faixa de cores, preservando as cores branca e preta, muito melhor para ajustes de cor em fotos. A fórmula exata do artigo é muito complexa e até tem um erro, mas essencialmente requer dois valores de ajuste. Um nível de limiar sobre o qual a função de contraste será centrada (tipicamente centrada em '50%') e um fator de contraste ('10' sendo muito alto e '0.5' muito baixo). | Para os interessados, a fórmula corrigida do 'controle de contraste por não-linearidade sigmoidal' é... ( 1/(1+exp(**β** *(**α** -u))) - 1/(1+exp(**β** *(**α**)) ) / ( 1/(1+exp(**β** *(**α** -1))) - 1/(1+exp(**β** * **α**)) ) _Ondeα é o nível de limiar e β o fator de contraste a ser aplicado.

Aqui está uma versão alternativa da fórmula usando variáveis intermediárias. x = exp(**β** * (**α** - u)) y = exp(**β** + 1 result (x / y + 1) * (1 / (x + 1) - 1 / y) _A fórmula é, na verdade, uma curva exponencial muito simples, sendo que o grosso da fórmula acima foi projetado para garantir que 0 permaneça zero e 1 permaneça um. Ou seja, o gráfico sempre passa pelos pontos 0,0 e 1,1. E o maior gradiente de mudança fica no limiar fornecido.
---|---
Aqui, por exemplo, está uma implementação com "[-fx](https://imagemagick.org/command-line-options/#fx)" da fórmula acima, resultante de um valor de contraste muito alto de '10' e um valor de limiar de '50%'. Esses valores foram incorporados às constantes de ponto flutuante, para acelerar a função.

  magick test.png  -fx '(1/(1+exp(10*(.5-u)))-0.006693)*1.013567' \
              sigmoidal.png

Felizmente para nós, o IM v6.2.1 tinha essa função complexa integrada como um novo operador "[-sigmoidal-contrast](https://imagemagick.org/command-line-options/#sigmoidal-contrast)", permitindo uma aplicação muito mais simples. |

    magick test.png  -sigmoidal-contrast 10,50% test_sigmoidal.png

Como bônus, o IM também fornece o inverso, uma função de 'redução de contraste sigmoidal' (como a forma mais '+' do operador), que, se aplicada com os mesmos argumentos, restaura nossa imagem original (quase exatamente). |

    magick test_sigmoidal.png +sigmoidal-contrast 10,50% \
                                             test_sigmoidal_inv.png

E aqui o aplicamos à imagem rose... |

    magick rose: -sigmoidal-contrast 10,50%  rose_sigmoidal.gif

Eu disse que '10' era um fator de contraste muito pesado. Na verdade, qualquer valor maior que este pode ser considerado mais como uma operação de limiar difuso do que um realce de contraste. Para um exemplo prático de uso deste operador, veja o Exemplo Avançado de Efeitos "Gel", onde ele é usado para acentuar a área brilhante que está sendo adicionada à cor de uma área com forma.

Operadores Diversos de Contraste

Em Construção

   -contrast  and   +contrast
         Operador de ajuste de contraste menor, bastante inútil

<a id="threshold"></a>-threshold
   Aplica limiar à imagem; qualquer valor menor ou igual ao valor fornecido é
   definido como 0 e qualquer valor maior é definido como o valor máximo.

   Observe que, assim como o level, este é um operador de canal, mas se a
   'configuração de canal' padrão for usada, apenas a intensidade em escala de
   cinza da imagem é limiarizada, produzindo uma imagem em preto e branco.

   magick rose: -threshold 45%  x:

   Você pode forçar o comportamento normal de canal, onde cada canal é
   limiarizado individualmente, usando "-channel All"

   magick rose: -channel All -threshold 45%  x:

<a id="black-threshold"></a>-black-threshold
<a id="white-threshold"></a>-white-threshold
   Isso é como o -threshold, exceto que apenas um lado do valor de limiar é
   de fato modificado.

   Por exemplo, aqui tudo que for mais escuro que 30% é definido como preto.

   magick rose: -black-threshold 30%  x:
   magick rose: -white-threshold 50%  x:

   Esses operadores, porém, não parecem ser afetados por canal, então podem ser
   adequados apenas para imagens em escala de cinza!

Ajustes usando modificação de histograma

Esta seção foi um esforço conjunto deFred Weinhaus e Anthony Thyssen. O que é um histograma? Um histograma é um tipo especial de gráfico. Ele simplesmente distribui os níveis de cor dos pixels de uma imagem em um número fixo de 'compartimentos' (bins), cada um abrangendo uma pequena faixa de valores. Assim, cada compartimento contém a contagem de quantos níveis de cor (valores de pixel) da imagem caem naquela faixa. O resultado é uma representação de como os valores de cor que compõem a imagem estão distribuídos, do preto à esquerda ao branco à direita. O histograma pode ser gerado para cada canal separadamente ou como um histograma global, que considera os valores de todos os canais combinados. O resultado costuma ser exibido como uma imagem de gráfico de barras. No IM, isso é feito usando o formato de saída especial Histogram:. Por exemplo... |

  magick rose: histogram:histogram.gif

Mas ele também pode ser exibido como um gráfico de linhas, no qual a linha conecta os topos das barras. Isso será demonstrado mais adiante na discussão abaixo. Consulte Histogram: para mais detalhes sobre esse formato de saída especial. A leitura é recomendada neste ponto, pois é a melhor forma de extrair informações de histograma sobre imagens usando o IM. A altura real de um gráfico de histograma tem pouco significado prático, já que costuma ser escalonada para que o pico mais alto encoste no topo da imagem. Assim, a altura de cada 'barra' individual não é relevante. Muito mais importante é a distribuição do histograma ao longo de toda a faixa, e como as alturas relativas se relacionam entre si em todo o gráfico. Ao observar um histograma, você consideraria os seguintes fatores.

• O histograma forma uma faixa ampla de valores? Isso significa que a imagem faz amplo uso do espaço de cor e, portanto, tem bom contraste.
• Ou está tudo concentrado num grupo estreito no meio ou em uma das extremidades da faixa? Isso significa que a imagem tem baixo contraste, com aparência 'enevoada' ou 'acinzentada', ou talvez excessivamente clara ou escura.
• Ele forma dois ou mais picos? Como resultado de áreas ou regiões bem diferentes na imagem.
• Onde está a maioria dos pixels? À esquerda, indicando que a imagem é muito escura. Ou à direita, indicando que é muito clara. Ou espalhados em torno do meio?
• Há espaços vazios ou lacunas regulares entre barras individuais? Isso geralmente significa que a imagem tem pouquíssimos pixels, não conseguindo preencher todo o histograma, ou que a imagem sofreu redução de cores, ou foi modificada de algum modo que produziu essas lacunas.

Essencialmente, um histograma é uma representação mais simples de uma imagem e, por isso, é muito mais fácil alterar ou ajustar uma imagem em termos de seu histograma. Quase toda transformação matemática de cor aplicada a uma imagem normalmente não só modifica a imagem, mas também o seu histograma. Isso inclui operações lineares como o Operador Level ou operações não lineares como o Operador Gamma, (veja acima). Os gráficos de mapeamento vistos acima representam como os níveis de cinza de uma imagem, e portanto como o histograma da imagem, devem ser transformados. Por exemplo, vamos criar uma imagem de baixo contraste para demonstrar. No entanto, o resultado final é que ela não apenas modifica a imagem, mas o faz modificando o histograma da imagem (comprimindo-o).

  magick chinese_chess.jpg -contrast -contrast -contrast -contrast \
          chinese_contrast.png

  magick chinese_chess.jpg     histogram:chinese_chess_hist.gif
  magick chinese_contrast.png  histogram:chinese_contrast_hist.gif

No caso acima, "-contrast" é um operador simples do tipo Level que adiciona apenas um pouco mais de contraste à imagem. O resultado disso é que o próprio histograma é mais espalhado, fazendo-o cobrir melhor toda a faixa de cores possível. Você também pode ver nos histogramas, antes e depois, que as cores acabam com lacunas e buracos entre os 'compartimentos', devido à forma como o esticamento foi realizado. Especificamente, ele cria um 'histograma' com todas as cores colocadas em 'compartimentos'. Essas cores 'agrupadas' são então modificadas como um todo, fazendo com que as cores da imagem fiquem agrupadas. Não é uma forma particularmente boa de tratar as cores de uma imagem. Esse operador, porém, funciona às cegas, sem qualquer conhecimento do conteúdo da imagem ou da distribuição de cores. Assim, ele não pode ser aplicado sem algum controle do usuário, pois o operador poderia facilmente piorar qualquer imagem à qual for aplicado, em vez de melhorá-la. Nesta seção veremos operadores de processamento de imagem que examinam o histograma da imagem como parte de seu processo de decisão. Ele então modifica as imagens usando o resultado desse estudo, de modo a realçar alguma qualidade da distribuição de cores da imagem. Como esses operadores fazem uso de informações reais provenientes da imagem processada, muitas vezes podem ser usados de forma mais global sobre muitas imagens, com muita verificação por parte do usuário. Operadores desse tipo incluem operadores lineares automáticos do tipo 'level', como "[-normalize](https://imagemagick.org/command-line-options/#normalize)", "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)" e "[-linear-stretch](https://imagemagick.org/command-line-options/#linear-stretch)", mas também os não lineares como "[-equalize](https://imagemagick.org/command-line-options/#equalize)", e outros que eventualmente podem vir a ser incluídos no ImageMagick, como o script "redist" de Fred Weinhaus.

Esticamento de histograma

As técnicas mais simples, como o exemplo anterior, simplesmente esticam o histograma da imagem para fora, a fim de melhorar a faixa de cores. Porém, em vez de escolher às cegas o ponto preto e o ponto branco para a operação Level, elas selecionam pontos com base no histograma da imagem. Basicamente, contam a quantidade de valores de cor em cada compartimento do histograma, a partir de cada uma das duas extremidades, em direção ao centro, até atingir algum limiar. Esses pontos são então usados como ponto preto e ponto branco para o esticamento (level) do histograma. Diagrama necessário Basicamente, as contagens do histograma fornecem os valores de nível de cinza que o esticamento forçará a preto e branco. Isso significa que todos os pixels da imagem que caem na faixa de compartimentos do preto puro até o nível de cinza correspondente ao compartimento do ponto preto selecionado acabarão em preto puro. Da mesma forma, os pixels da imagem que caem na faixa de compartimentos do branco puro até o nível de cinza correspondente ao compartimento do ponto branco acabarão em branco puro. Os pixels que estão fora desses pontos, porém, terão sido esticados para além da faixa de valores de cor possível e, como resultado, serão simplesmente ajustados aos limites da faixa. Ou seja, esses pixels são 'cortados' e 'queimados' ao serem convertidos para o extremo de preto puro ou branco puro. Como resultado, se os limites de 'limiar' para selecionar o ponto preto e o ponto branco forem ajustados alto demais, você obterá muitas áreas pretas e brancas na imagem, com o histograma resultante tendo contagens grandes (barras altas) nos compartimentos das extremidades. Exemplo de queima severa -- Imagem do Xadrez Chinês? Resumo dos operadores de 'esticamento'... -contrast-stretch e -linear-stretch geram um histograma (usando 1024 compartimentos) para determinar a posição de cor a esticar. Assim, não é 'exato'. A outra diferença está em como o 'zero' é tratado, e no fato de que -linear-stretch de fato realiza uma operação -level para fazer o esticamento, enquanto -contrast-stretch usa valores de compartimentos do histograma para o esticamento por substituição de cor (o que introduz um efeito de arredondamento de 1024 quanta. -normalize usa -contrast-stretch internamente. Um operador de esticamento por normalização matematicamente perfeito é -auto-level. Embora uma versão perfeita de 'apenas ponto branco' ou 'apenas ponto preto' seja possível, ela não foi implementada até o momento.

Auto-Level - normalização matemática perfeita

O "[-auto-level](https://imagemagick.org/command-line-options/#auto-level)" encontra os maiores e menores valores da imagem para usá-los ao esticar a imagem até a faixa Quantum completa. Em nenhum momento os valores serão 'cortados' ou 'queimados' em decorrência de o histograma ser esticado além da faixa de valores. A configuração "[-channel](https://imagemagick.org/command-line-options/#channel)" determina se todos os canais são esticados igualmente 'em sincronia' (usando o máximo e o mínimo de todos os canais) ou separadamente (cada canal individual como uma entidade distinta). Neste momento, a cor oculta de pixels totalmente transparentes também é usada na determinação dos níveis, o que pode causar alguns problemas quando há transparência envolvida. Isso é considerado um bug.

FUTURO: Precisamos, na verdade, de três modos de operação...
  canais de cor sincronizados com mascaramento por 'alpha' (e 'read').
  canais sincronizados (conforme definido por channel)       (padrão atual)
  canais separados individuais   (atualmente se -channel for definido pelo usuário)

É um esticamento de histograma puramente matemático, assim como o Operador Level manual. Ou seja, o mínimo será ajustado para zero e o máximo para a faixa Quantum, e uma equação linear é usada para ajustar todos os demais valores da imagem. Ele não usa 'compartimentos de histograma' nem qualquer outro 'agrupamento de valores' que outros métodos possam usar, seja para determinar os níveis a serem aplicados ou para outros ajustes de histograma.

Normalize

O operador "[-normalize](https://imagemagick.org/command-line-options/#normalize)" é o mais simples desses três operadores. Ele simplesmente expande o histograma em escala de cinza para que ocupe toda a faixa dinâmica dos valores de cinza, cortando ou queimando 2% na extremidade baixa (preta) e 1% na extremidade alta (branca) do histograma. Ou seja, 2% dos cinzas mais escuros da imagem se tornarão preto e 1% dos cinzas mais claros se tornarão branco. Na maioria das imagens isso não representa uma grande perda, e o resultado geral é que o contraste (faixa de intensidade) da imagem será maximizado automaticamente. Um diagrama idealizado é necessário aqui!__Exemplo usando o xadrez chinês? Aqui criamos um gradiente em escala de cinza e o expandimos para a faixa completa de preto e branco.

  magick -size 150x100 gradient:gray70-gray30 gray_range.jpg
  magick gray_range.jpg  -normalize  normalize_gray.jpg

| _Por razões práticas relacionadas às imprecisões de cor do JPEG (vejaDistorção de Cor JPEG para mais detalhes) e ao ruído de imagens digitalizadas, o "[-normalize](https://imagemagick.org/command-line-options/#normalize)" não expande exatamente as cores mais claras e mais escuras, mas vai um pouco além desses valores. Ou seja, ele equivale a um "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)" com valor de '2%,99%' (veja abaixo).

Isso significa que, se os valores de cor mais alto e mais baixo estiverem muito próximos, o "[-normalize](https://imagemagick.org/command-line-options/#normalize)" falhará e nenhuma ação será tomada.

Se você realmente quiser expandir exatamente os valores de cor mais claros e mais escuros até seus extremos, use "[-auto-level](https://imagemagick.org/command-line-options/#auto-level)" em vez disso._
---|---
Até a versão 6.2.5-5 do IM, o "[-normalize](https://imagemagick.org/command-line-options/#normalize)" funcionava puramente como um operador em escala de cinza. Ou seja, cada um dos canais vermelho, verde, azul e alfa era expandido independentemente dos demais, de acordo com a configuração "[-channel](https://imagemagick.org/command-line-options/#channel)". A partir da versão 6.2.5-5 do IM, se apenas a configuração padrão "[+channel](https://imagemagick.org/command-line-options/#channel)" for fornecida, o "[-normalize](https://imagemagick.org/command-line-options/#normalize)" vinculará todos os canais de cor e os normalizará na mesma proporção. Isso garante que as cores dos pixels dentro da imagem não sejam deslocadas. No entanto, também significa que você pode não obter um pixel de branco ou preto puro. Por exemplo, aqui adicionamos algumas cores extras (um gradiente de azul para azul-marinho) à nossa imagem de teste de normalização.

  magick -size 100x100 gradient:gray70-gray30 \
          -size  50x100 gradient:blue-navy  +append  color_range.jpg
  magick color_range.jpg -normalize  normalize.jpg

Como você pode ver no último exemplo, para imagens coloridas o "[-normalize](https://imagemagick.org/command-line-options/#normalize)" maximizou todos os canais em conjunto, de modo que um canal tem valor zero e outro tem valor máximo. Ou seja, nenhum pixel preto foi gerado, pois todas as cores azuis adicionadas já contêm valores 'zero' nos canais 'vermelho' e 'verde'. Assim, os limites inferiores da imagem não se expandiram. Se você quiser o comportamento antigo do "[-normalize](https://imagemagick.org/command-line-options/#normalize)" (anterior ao IM v6.2.5-5), precisará especificar qualquer configuração de "[-channel](https://imagemagick.org/command-line-options/#channel)" não padrão. Para imagens que não contêm canal alfa (ou matte), basta usar a configuração de canal 'all'. |

  magick color_range.jpg -channel all  -normalize   normalize_all.jpg

Alternativamente, você pode normalizar cada canal como uma imagem separada usando o operador "[-separate](https://imagemagick.org/command-line-options/#separate)" (a partir do IM v6.2.9-2) e depois "[-combine](https://imagemagick.org/command-line-options/#combine)"-los novamente em uma única imagem. |

  magick color_range.jpg -separate -normalize -combine normalize_sep.jpg

Nesses dois últimos exemplos, vemos que as áreas em escala de cinza da imagem ficaram amarelas, já que os canais 'red' e 'green' foram clareados, enquanto o canal 'blue' foi apenas ligeiramente escurecido. Isso nos leva a um ponto importante

Normalize e outros operadores de histograma são, na verdade, operadores em escala de cinza;
é preciso cautela ao usá-los com imagens coloridas.

Na verdade, o "[-normalize](https://imagemagick.org/command-line-options/#normalize)" é apenas um subconjunto do mais geral "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)", com valores padrão de 2% para o ponto preto e 1% para o ponto branco. Então, o que é o "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)"?

contrast-stretch

O operador "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)" (adicionado no IM v6.2.6) é semelhante ao "[-normalize](https://imagemagick.org/command-line-options/#normalize)", exceto que permite ao usuário especificar o número de pixels que serão cortados ou queimados. Ou seja, ele fornece algum controle sobre a seleção do 'ponto preto' e do 'ponto branco' que será usado no esticamento do histograma. Assim, o usuário especifica uma contagem (ou contagem percentual) dos cinzas mais escuros da imagem que se tornarão preto e a contagem dos cinzas mais claros que se tornarão branco. Por exemplo, isso substituirá tanto os 15% superiores quanto os 15% inferiores das cores por seus extremos (branco e preto), esticando adequadamente os 70% restantes das cores. O resultado final é tentar melhorar o contraste geral da imagem.

  magick gray_range.jpg  -contrast-stretch 15%  stretch_gray.jpg

Você também consegue ver facilmente os efeitos de 'queima' e 'corte' no topo e na base do gradiente acima, já que aquelas cores de cinza são esticadas bem além dos limites da faixa de cores. E aqui eu, propositalmente, 'queimo' 90% dos cinzas mais escuros, deixando apenas 10% dos pixels mais claros para serem esticados em um gradiente linear estreito no topo da imagem. |

  magick gray_range.jpg  -contrast-stretch 90%x0%  stretch_black.jpg

Isso pode ser bastante útil para encontrar os 'N' pixels mais claros de uma imagem, já que serão os únicos que não foram 'queimados' para um valor zero. (Uma forma melhor é usar "[-threshold-black](https://imagemagick.org/command-line-options/#threshold-black)") Um aspecto importante do "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)" é o uso de zero para as contagens de limiar do ponto preto e do ponto branco. Nesse caso, "-contast-stretch 0" localizará os compartimentos mínimo e máximo do histograma da imagem. Como as contagens de fato começam nesses compartimentos, o resultado é simplesmente esticar os compartimentos mínimo e máximo até preto pleno e branco pleno. Isso resultará em um esticamento de contraste com uma quantidade mínima, ou possivelmente nula, de corte, com todos os valores nesses 'compartimentos' tornando-se 0 e valores máximos.

| | | |
Em construção

Linear-Stretch

De várias maneiras, o "[-linear-stretch](https://imagemagick.org/command-line-options/#linear-stretch)" é muito semelhante ao operador anterior "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)". Ambas as funções podem receber argumentos de ponto preto e ponto branco como contagens brutas ou como percentuais do número total de pixels envolvidos. No entanto, há várias diferenças importantes. Uma diferença tem a ver com a forma como o ponto preto e o ponto branco padrão são calculados. Com o "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)", se apenas um valor for fornecido, o ponto preto, o ponto branco assumirá o mesmo valor. Assim, "-contrast-stretch 1" equivale a "-contrast-stretch 1x1" e "-contrast-stretch 1%" equivale a "-contrast-stretch 1x1%"". No entanto, com o "[-linear-stretch](https://imagemagick.org/command-line-options/#linear-stretch)", se apenas um valor for fornecido, o ponto preto, o ponto branco assumirá o valor complementar. Ou seja, se o ponto preto for especificado como contagem bruta, o ponto branco será o total de pixels da imagem menos a contagem do ponto preto. Da mesma forma, se o ponto preto for especificado como contagem percentual, o ponto branco será 100% menos o percentual do ponto preto. Assim, "-linear-stretch 1%" equivalerá a "-linear-stretch 1x99%". A segunda diferença tem a ver com onde as contagens começam. Considere um histograma com 256 compartimentos (alguns 'compartimentos' podem ter contagem zero) indo do nível de cinza 0 ao nível de cinza 255. No "[-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch)", as contagens começam em zero, no compartimento populado mais baixo (mín) e mais alto (máx) da imagem (que podem ou não estar no compartimento 0 ou 255 do histograma). Assim, um ponto preto de 10% acumulará contagens de todos os compartimentos após o compartimento mínimo até atingir 10% e esticará o lado preto a partir daquele nível de cinza. Assim, a quantidade queimada no lado preto do histograma acabará sendo 10% mais o que já havia sido encontrado nos 'compartimentos' mais escuros anteriores. O mesmo vale para a contagem a partir do lado claro do histograma. Com o "[-linear-stretch](https://imagemagick.org/command-line-options/#linear-stretch)", a contagem começa nas extremidades do histograma, ou seja, no compartimento 0 e no compartimento 255. Assim, a quantidade queimada no lado escuro será sempre o valor do ponto preto e a quantidade queimada no lado claro será sempre o valor do ponto branco. Como exemplo, vamos pegar um gradiente de 100 pixels e observar seu histograma. |

  magick -size 1x100 gradient: \
          -depth 8 -format "%c" histogram:info:

Como esperado, cada compartimento é igualmente populado com um único pixel, produzindo uma contagem de 1. (Para ver a listagem completa, clique na imagem de texto de saída acima). Agora vamos fazer o mesmo após usar "-contrast-stretch 10x10%"

  magick -size 1x100 gradient:   -contrast-stretch 10x10%  \
          -depth 8 -format "%c" histogram:info:

E agora "-linear-stretch 10x10%".

  magick -size 1x100 gradient:   -linear-stretch 10x10%  \
          -depth 8 -format "%c" histogram:info:

Assim, confirmamos que, para "-contrast-stretch 10x10%", obtemos 11 pixels em cada extremidade. Ou seja, equivalente à contagem nos compartimentos das extremidades mais 10% dos pixels da imagem, que é igual a 10 pixels. Então 10+1=11 pixels queimados. Por outro lado, no "-linear-stretch", os compartimentos das extremidades acabam contendo apenas 10 pixels, ou 10% da imagem. Uma consequência da diferença mencionada é que "-contrast-stretch 0x0" pode alterar a imagem, se os compartimentos populados mais baixo e/ou mais alto não forem os compartimentos das extremidades em 0 e 255. Nesse caso, a imagem será esticada entre os níveis de cinza correspondentes a esses compartimentos. Por outro lado, "-linear-stretch 0x0" nunca alterará a imagem. Por exemplo, vamos pegar o gradiente e comprimir seus níveis de cinza em 10% em cada extremidade. Ou seja, vamos mover o ponto preto para cima em 10%, para o nível de cinza 26, e o ponto branco para baixo em 10%, para o nível de cinza 230.

  magick -size 1x100 gradient:   +level 10x90%  \
          -depth 8 -format "%c" histogram:info:

Agora, vamos aplicar "-contrast-stretch 0x0" ao gradiente de contraste reduzido acima

  magick -size 1x100 gradient: -level 10x90%  -contrast-stretch 0x0  \
          -depth 8 -format "%c" histogram:info:

E agora "-linear-stretch 0x0"

  magick -size 1x100 gradient: -level 10x90%  -linear-stretch 10x10% \
          -depth 8 -format "%c" histogram:info:

Assim, vemos que a imagem original tinha um histograma que não abrangia toda a faixa dinâmica de 0 a 255. Ele ia apenas entre os níveis de cinza 26 e 230. Mas, após aplicar "-contrast-stretch 0x0", ele foi esticado para a faixa dinâmica completa. Por outro lado, "-linear-stretch 0x0" não fez nenhuma alteração no histograma resultante. A terceira diferença é que o "-contrast-stretch" é sensível ao canal, enquanto o "-linear-stretch" não é. Isso significa que, com "-contrast-stretch", qualquer um ou mais canais podem ser alterados sem afetar os demais. Assim, se nenhum canal for especificado, o histograma geral de todos os canais será usado para modificar todos os canais da mesma maneira, de modo que nenhum deslocamento de cor seja produzido. No entanto, se "-channel RGB" for especificado, cada canal será esticado separadamente e o resultado dependerá dos compartimentos das extremidades em cada canal. Se forem diferentes, será produzido um deslocamento de cor entre os canais individuais na imagem resultante. Com "-linear-stretch", todos os canais serão processados de forma comum, garantindo assim que nenhum deslocamento de cor dos canais entre si seja produzido. Então, vamos obter um identify detalhado e o histograma de uma imagem real.

  magick port.png  -verbose -identify +verbose  histogram:port_hist.gif

|

---|---

Vemos que nenhum dos canais da imagem acima abrange toda a faixa dinâmica. Note também que cada canal abrange uma faixa de valores singularmente diferente. Agora vamos aplicar "-contrast-stretch 1x1%" sem uma configuração de "[-channel](https://imagemagick.org/command-line-options/#channel)".

  magick port.png -contrast-stretch 1x1% \
          -write histogram:port_cs1_hist.gif   port_cs1.png

No resultado acima, a imagem é esticada de forma consistente em todos os canais. Assim, não há deslocamentos de cor entre os canais. Agora vamos fazer o mesmo, mas com "-channel RGB".

  magick port.png  -channel RGB  -contrast-stretch 1x1% \
          -write histogram:port_cs1rgb_hist.gif    port_cs1rgb.png

No resultado acima, como definimos "-channel RGB" em vez de usar a configuração de canal padrão, a imagem é esticada de forma diferente para cada canal. Isso provoca um deslocamento de cor entre os canais. Agora vamos aplicar "-linear-stretch" sem uma configuração de "-channel".

  magick port.png   -linear-stretch 1x1% \
          -write histogram:port_ls1_hist.gif \
          port_ls1.png

No resultado acima, a imagem é esticada de forma consistente em todos os canais. Portanto, não há deslocamento de cor entre os canais. Agora vamos fazer o mesmo, mas com "-channel RGB".

  magick port.png  -channel RGB  -linear-stretch 1x1% \
          -write histogram:port_ls1rgb_hist.gif    port_ls1rgb.png

No resultado acima com "-linear-stretch", a imagem é esticada de forma consistente em todos os canais e "-channel RGB" é ignorado. Assim, não há deslocamento de cor entre os canais e o resultado é idêntico ao anterior, sem "-channel RGB".

Redistribuição de histograma

A redistribuição de histograma é uma técnica não linear que redistribui os compartimentos de um histograma a fim de alcançar um formato específico. Os dois formatos mais comuns são o uniforme (plano) e o gaussiano (em forma de sino), embora o hiperbólico e o de Rayleigh sejam outros tipos de distribuição também utilizados.

Equalize - Redistribuição uniforme de histograma

No caso de uma distribuição uniforme, os compartimentos do histograma são deslocados, espaçados e combinados de modo que, em média, o histograma tenha altura plana ou constante em toda a faixa. Isso é chamado de equalização de histograma. A função do IM, "[-equalize](https://imagemagick.org/command-line-options/#equalize)", faz isso. Infelizmente, ela opera sobre cada canal separadamente, em vez de aplicar a mesma operação a todos os canais. Assim, deslocamentos de cor são possíveis quando ela é aplicada ao espaço de cor RGB. Aqui está um exemplo de equalização de histograma usando a função -equalize do IM. Note o deslocamento no equilíbrio de cores decorrente da equalização de cada canal de forma independente.

  magick zelda.png  -write histogram:zelda_hist.gif \
          -equalize  -write histogram:zelda_equal_hist.gif \
          zelda_equal.png

Você pode notar que o histograma não parece muito uniforme. Mas, se convertermos a imagem resultante para escala de cinza e exibirmos seu histograma, ele parecerá um pouco mais uniforme em comparação ao histograma em escala de cinza da imagem original

  magick zelda.png  -colorspace gray   histogram:zelda_ghist.gif

  magick zelda_equal.png  -colorspace gray \
          histogram:zelda_equal_ghist.gif

A outra forma de abordar a redistribuição dos compartimentos é usar uma tabela de consulta de transformação, gerada a partir dos histogramas cumulativos separados de cada canal e da curva de distribuição integrada desejada. Se não se deseja nenhum deslocamento de cor entre os canais, então usa-se o histograma combinado de todos os canais da imagem. Uma aproximação é simplesmente usar o histograma da imagem após convertê-la para escala de cinza. Fred Weinhaus desenvolveu um script, chamado "redist", que faz exatamente isso. Ele redistribui o histograma de uma imagem em uma distribuição uniforme, aplicando a mesma alteração a todos os canais de cor igualmente.

  redist -s uniform zelda.png  zelda_uniform.png

  magick zelda_uniform.png   histogram:zelda_uniform_hist.gif

Note como os resultados diferem do operador interno "[-equalize](https://imagemagick.org/command-line-options/#equalize)" do IM. Especificamente, todas as cores são preservadas, sem o deslocamento de cor visto anteriormente. O que o script faz é trabalhar sobre o histograma em escala de cinza, que ele então aplica a todos os canais de cor, de modo que todas as cores sejam mantidas juntas. Para comparação com os histogramas do "[-equalize](https://imagemagick.org/command-line-options/#equalize)" do IM, vamos mostrar aqui também os resultados do histograma em escala de cinza. Note que o histograma redistribuído parece um pouco mais nivelado (plano, ou uniforme) do que o do equalize do IM.

  magick zelda.png  -colorspace gray   histogram:zelda_ghist.gif

  magick zelda_uniform.png  -colorspace gray \
          histogram:zelda_uniform_ghist.gif

FUTURO: Adicionar exemplos de equalização em outros espaços de cor! Ou seja, o canal em escala de cinza nos espaços de cor HSL, HSB e CMYK.

Redistribuição gaussiana

Equalizar um histograma não é a única forma de alterar a distribuição de histograma de uma imagem. Na verdade, normalmente não é muito útil, exceto em aplicações de visão computacional. Aqui está a mesma imagem, mas transformada de modo que seu histograma tenha uma distribuição gaussiana (em forma de sino). Os valores usados aqui são uma média de 60% de cinza, com um decaimento (sigma) de 60 para cada lado dessa média.

  redist -s gaussian 60,60,60  zelda.png \
         zelda_gaussian.png

  magick zelda_gaussian.png -colorspace gray \
          histogram:zelda_gaussian_ghist.gif

A partir do histograma em escala de cinza resultante, você pode ver que a imagem é modificada de modo que suas cores sigam uma distribuição do tipo curva de sino gaussiana. Para fotos, isso produz um resultado de aparência mais 'natural'. A imagem não terá apenas o contraste otimizado, mas também o brilho ajustado, de modo que a maioria dos pixels da imagem tenha cerca de 60% de brilho em escala de cinza.

Metodologia da redistribuição de histograma

Então, como funciona esse tipo de ajuste direto de histograma? Basicamente, ele calcula o histograma da imagem atual e o da distribuição desejada. Em seguida, determina como o valor de nível de cinza de cada 'compartimento' precisa ser alterado para que as contagens dos compartimentos sigam da melhor forma possível a distribuição desejada. Alguns compartimentos podem ser deslocados para mais escuro, enquanto outros podem ser deslocados para mais claro. Na verdade, esse é um processo bastante elaborado, então vamos percorrê-lo passo a passo.
Primeiro, precisamos obter os dados reais de histograma do ImageMagick, em vez de uma imagem gráfica do histograma. Note que os dados vêm de todos os valores de cor combinados em uma escala de cinza. Isso foi feito para distribuir todos os canais em conjunto e ajustar o brilho geral da imagem de modo a seguir a curva desejada.

  magick zelda.png -colorspace gray \
         -depth 8 -format "%c" histogram:info:- |\
    tr -cs '0-9\012' ' ' |\
      awk '# collect the histogram data.
           { bin[$2] += $1; }
           END { for ( i=0; i<256; i++ ) {
                   print bin[i]+0;
                 }
               } ' > zelda_hist_data.txt

  # get the maximum count for any one histogram 'bin'
  max_count=`sort -n zelda_hist_data.txt | tail -n 1`

  # magick histogram into a profile graph of the data
  echo "P2 256 1 $max_count" | cat - zelda_hist_data.txt |\
    im_profile -s - zelda_hist_graph.gif

Para coletar os dados, pego os metadados de 'comentário' da imagem de histograma, que o IM inclui justamente para esse fim. Os dados são então limpos para deixar apenas os números brutos (usando um programa chamado "tr", abreviação de 'translate'). Esses dados brutos são então passados a outro utilitário chamado "awk", usado para coletar as contagens reais do histograma para cada compartimento. Para podermos observar os resultados, também processo as contagens do histograma em uma imagem de gradiente (via o formato de arquivo de imagem NetPBM, PGM texto em escala de cinza), e a exibo como um gráfico de linhas usando o script "[im_profile](../static/img/scripts/im_profile)". Essencialmente, isso é apenas uma forma diferente de gerar uma imagem de histograma, embora desta vez diretamente a partir de um arquivo de dados numéricos. Agora que temos os dados do histograma em um arquivo de texto, também precisamos do histograma da função com a qual queremos que os dados redistribuídos coincidam. Neste caso, é uma distribuição gaussiana com valor médio de 153 (60% de cinza) e largura sigma de 60. Ambos os valores estão em termos da faixa de 256 dos 'compartimentos' do histograma.

  awk '# AWK to generate gaussian distribution graph
        BEGIN { mean = 153;   sigma = 60;
                fact = 1/(2*(sigma/256)^2);
                expo = exp(1);
                for ( i=0; i<256; i++ ) {
                  print int(65535*expo^(-(((i-mean)/256)^2)*fact));
                }
              }' /dev/null  > gaussian_hist_data.txt

   # magick gaussian data into a profile graph
   echo "P2 256 1 65535" | cat - gaussian_hist_data.txt |\
     im_profile -s -b - gaussian_hist_graph.gif

Os histogramas acima são interessantes e refletem a distribuição do histograma original da imagem e o estado desejado do histograma. Mas, para fins de conversão, essa forma de histograma, embora útil para o nosso entendimento, não é muito útil para os nossos propósitos. Na verdade, o que realmente precisamos são os histogramas cumulativos. Esses histogramas são muito semelhantes a um histograma normal, exceto que cada 'compartimento' do histograma é uma contagem do seu 'compartimento' mais todos os 'compartimentos' que vieram antes dele, começando em 0. Ou seja, cada 'compartimento' é uma 'acumulação' ou contagem de todos os 'compartimentos' mais escuros. Na verdade, esses são mais fáceis de gerar diretamente a partir da imagem original. Então vamos repetir o processo, mas calculando e salvando as contagens 'cumulativas'.

  magick zelda.png -colorspace gray \
         -depth 8 -format "%c" histogram:info:- |\
    tr -cs '0-9\012' ' ' |\
      awk '# Collect the cumulative histogram for an image
               { bin[$2] += $1; }
           END { for ( i=0; i<256; i++ ) {
                   cum += bin[i];
                   print cum;
                 }
               } ' > zelda_cumhist_data.txt

  total_count=`tail -n 1 zelda_cumhist_data.txt`
  echo "P2 256 1 $total_count" | cat - zelda_cumhist_data.txt |\
    im_profile -s - zelda_cumhist_graph.gif

  awk '# AWK to generate gaussian distribution cumulative graph
        BEGIN { mean = 153;   sigma = 60;
                fact = 1/(2*(sigma/256)^2);
                expo = exp(1);
                for ( i=0; i<256; i++ ) {
                  gas[i] = expo^(-(((i-mean)/256)^2)*fact);
                  total += gas[i]
                }
                for ( i=0; i<256; i++ ) {
                  cum += gas[i];
                  print int(65535*cum/total);
                }
              }' /dev/null  > gaussian_cumhist_data.txt

  total_count=`tail -n 1 gaussian_cumhist_data.txt`
  echo "P2 256 1 $total_count" | cat - gaussian_cumhist_data.txt |\
    im_profile -s -b - gaussian_cumhist_graph.gif

Histograma
Cumulativo da Imagem |
Histograma
Cumulativo Gaussiano
---|---

Agora, o que precisamos fazer é converter o histograma cumulativo da imagem no histograma cumulativo gaussiano. Para isso, cada valor de cinza da imagem de entrada é usado para encontrar seu valor cumulativo 'normalizado'. Este é então mapeado para o mesmo valor cumulativo na distribuição gaussiana e, em seguida, encontra-se o valor de cinza correspondente. Este diagrama deve tornar o processo de mapeamento mais claro...

O comando a seguir faz a consulta para cada valor de cor de 8 bits possível, a fim de gerar uma Tabela de Consulta de Cores, ou CLUT. Essa imagem especial pode então ser usada para mapear os valores de cor da imagem original para os novos valores necessários para redistribuir o histograma da imagem.

  # Generate a CLUT to Redistribute the Histogram
  paste  zelda_cumhist_data.txt   gaussian_cumhist_data.txt |\
    awk '# AWK to generate gaussian distribution graph
              { bin[NR] = $1;   gas[NR] = $2;  }
          END { k=0;  # number of pixels less than this value
                print "P2 256 1 65535";
                for ( j=0; j<256; j++ ) {
                  while ( k<255 &&
                            gas[k]/gas[255] <= bin[j]/bin[255] ) {
                    k++;
                  }
                  print 65535*k/255;
                }
              }' |\
      magick pgm:- gaussian_clut.png

  magick zelda.png   gaussian_clut.png -clut   zelda_redist.png

Como você pode ver, converter o histograma de uma imagem para tentar seguir uma função de distribuição específica, como uma curva de sino gaussiana, é um processo bastante elaborado e altamente numérico. Aqui está tudo em um único comando bastante longo e complexo...

  magick zelda.png -colorspace gray \
         -depth 8 -format "%c" histogram:info:- |\
    tr -cs '0-9\012' ' ' |\
      awk '# AWK to generate gaussian distribution graph
            { # just read in image histogram into a 'bin' table
                  bin[$2] += $1;
                }
            END { # Generate Gaussian Histogram
                  mean = 153;   sigma = 60;
                  fact = 1/(2*(sigma/256)^2);
                  expo = exp(1);
                  for ( i=0; i<256; i++ ) {
                    gas[i] = expo^(-(((i-mean)/256)^2)*fact);
                  }
                  # Convert normal histograms to cumulative histograms
                  for ( i=0; i<256; i++ ) {
                    gas[i] += gas[i-1];
                    bin[i] += bin[i-1];
                  }
                 # Generate Redistributed Histogram
                 k=0;  # number of pixels less than this value
                 print "P2 256 1 65535";
                 for ( j=0; j<256; j++ ) {
                   while ( k<255 &&
                            gas[k]/gas[255] <= bin[j]/bin[255] ) {
                     k++;
                   }
                   print 65535*k/255;
                 }
                }' |\
        magick zelda.png   pgm:-  -clut   zelda_gaussian_redist.png

Apenas algumas palavras finais sobre a técnica acima.

• O uso do "awk" para fazer os cálculos e acelerar o script "[redist](http://www.fmwconcepts.com/imagemagick/redist/)" de Fred Weinhaus foi sugerido e contribuído por Anthony Thyssen.
• Para aplicar a técnica de redistribuição acima e gerar uma distribuição 'uniforme', ou 'equalizada', o histograma da função é simplesmente uma constante. Isso, por sua vez, resulta em uma distribuição integrada que é simplesmente a fórmula y = x, ou seja, uma reta diagonal. Aplicar a mesma técnica de conversão leva a uma imagem CLUT que acaba sendo idêntica ao histograma cumulativo da imagem de entrada. Em outras palavras, para uma equalização do histograma, basta converter o histograma cumulativo da imagem em uma CLUT e aplicá-la diretamente à imagem.
• A maioria dos pacotes de processamento de imagem, incluindo o ImageMagick neste momento, aplica as fórmulas de transformação diretamente aos valores da própria imagem, em vez de gerar uma CLUT intermediária. No entanto, como os histogramas e, portanto, os histogramas cumulativos têm um tamanho limitado (256 'compartimentos', tipicamente), isso pode levar a erros sérios, já que os valores de cor da imagem podem ser arredondados durante o processo. Contudo, com o ImageMagick, geramos uma CLUT intermediária (contendo esses mesmos erros de arredondamento) e depois passamos os valores originais não arredondados da imagem pela CLUT preparada, usando uma interpolação linear dos valores. Como resultado dessa interpolação, os valores de cor da nova imagem são mais precisos, pois não foram arredondados nem 'compartimentados' durante o processamento.

Espera-se que, no futuro, o descrito acima venha a ser incorporado ao ImageMagick. Enquanto isso, o script "redist" de Fred Weinhaus está disponível para realizar a tarefa. Você também pode se interessar pelo script "retinex" de Fred, que tenta fazer realces automáticos semelhantes nas imagens, em regiões localizadas da imagem, em vez de globalmente como faz esta técnica.

Ajustes de Nível "Faça Você Mesmo"

Ajustes Lineares Matemáticos do Histograma

As diversas formas básicas de Ajustes de Nível mostradas acima ajustam as cores da imagem de maneira linear. Essas alterações também podem ser aplicadas matematicamente. Por exemplo, multiplicando a imagem por uma cor específica, definimos todas as áreas de branco puro para essa cor. Então vamos apenas ler nossa imagem, criar uma imagem contendo a cor desejada e, em seguida, multiplicar a imagem original por essa cor usando o operador livre "[-fx](https://imagemagick.org/command-line-options/#fx)" do IM ou Operador DIY.

  magick test.png  -size 1x1 xc:Yellow \
          -fx 'u*v.p{0,0}'    fx_linear_white.png

Fazendo com que "[-fx](https://imagemagick.org/command-line-options/#fx)" leia a cor de uma segunda imagem 'v' fica fácil trocar a cor, sem precisar converter cores para valores RGB para uso na matemática. Se você estivesse usando um pacote gráfico sofisticado de processamento de imagem como o "[Gimp](http://www.gimp.org/)" ou o "[Photoshop](http://www.adobe.com/products/photoshopfamily.html)", a operação acima teria sido aplicada a uma imagem ajustando a 'curva' do gráfico do histograma de cores. Por exemplo, à direita há um gráfico gerado pelo "[gnuplot](http://www.gnuplot.info/)" (veja o script "[**im_histogram**](../static/img/scripts/im_histogram)") da fórmula matemática mostrando o que acontece com apenas um dos três canais RGB. A cor original (linha verde) é remapeada linearmente para uma cor mais escura (linha vermelha). Tingir linearmente as cores pretas também é bastante simples. Por exemplo, para mapear linearmente 'black' para uma cor dourada como 'rgb(204,153,51)' (deixando 'white' como 'white'), seria necessária uma fórmula matemática como...

          result = 1-(1-color)*(1-intensity)

Esta fórmula inverte as cores, multiplica a imagem pela cor invertida desejada e inverte a imagem de volta novamente. O resultado é o tingimento do lado preto da escala de cinza, deixando o branco inalterado.

  magick test.png  -size 1x1 xc:'rgb(204,153,51)'  \
          -fx '1-(1-v.p{0,0})*(1-u)'   fx_linear_black.png

Um gráfico de histograma do "gnuplot" da fórmula de remapeamento também é exibido acima para sua referência. Com uma fórmula um pouco mais complicada, você pode substituir linearmente tanto a extremidade 'black' quanto a 'white' da escala de cinza por cores específicas.

  magick test.png  -size 1x2  gradient:gold-firebrick \
          -fx 'v.p{0,0}*u+v.p{0,1}*(1-u)'   fx_linear_color.png

O "-size 1x2 gradient:color1-color2" acima é usado apenas para gerar uma imagem de dois pixels coloridos que a fórmula "[-fx](https://imagemagick.org/command-line-options/#fx)" referencia. A primeira cor substitui o branco, enquanto a segunda substitui o preto, e todas as demais são interpoladas entre branco e preto. Como é típico de um operador de escala de cinza, cada canal RGB é tratado como um canal de escala de cinza separado, embora a interpolação linear seja diferente para cada canal. Isso, aliás, é exatamente equivalente ao operador de Ajustes de Nível por Cor "[+level-colors](https://imagemagick.org/command-line-options/#level-colors)" No entanto, ao contrário de "[+level-colors](https://imagemagick.org/command-line-options/#colors)", as cores a usar podem, é claro, vir de qualquer fonte de imagem, e não apenas dos nomes de cores fornecidos como argumento. Contudo, até o uso direto de nomes de cores é possível. |

  magick test.png   -fx "yellow*u+green*(1-u)"  fx_linear.png

Ajustes Não Lineares Matemáticos do Histograma

Embora os ajustes lineares de cor sejam importantes e existam métodos mais rápidos, há muitas situações em que um ajuste linear de 'nível' não é o que se deseja, e é aí que o "[-fx](https://imagemagick.org/command-line-options/#fx)" Operador DIY se torna mais útil. Pois bem, uma fórmula alternativa para ajuste linear é "-fx 'v.p{0,1}+(v.p{0,0}-v.p{0,1})*u'", que tem a vantagem de que o 'u' pode ser substituído por uma única função aleatória 'f(u)' para produzir uma mudança de cor não linear. Isso permite fazer coisas mais interessantes. Por exemplo, e se no último exemplo você quisesse empurrar todas as cores para o lado 'black', fazendo com que a imagem ficasse mais na cor 'firebrick'.

  magick test.png -size 1x2  gradient:gold-firebrick \
          -fx 'v.p{0,1}+(v.p{0,0}-v.p{0,1})*u^4'  fx_non-linear.png

Em um exemplo mais prático, Adelmo Gomes precisava de um ajuste de cor para um script automatizado de Recolorização de Mapas Meteorológicos que ele estava desenvolvendo. Nesse caso, ele queria tingir as partes de preto puro da imagem para um azul de .25, mas deixar o restante da escala de cinza intacto, especialmente os cinzas brancos e de meio-tom da imagem. Apenas a cor azul precisava desse ajuste, o que ele estava fazendo à mão em um editor de imagens. Por exemplo, você poderia usar uma fórmula quadrática como 'u^2' para tingir a extremidade preta do histograma para uma cor azul '.25'. Apenas o canal azul precisa ser modificado, então o valor foi inserido diretamente na fórmula.

  magick test.png  -channel B  -fx '.25+(1-.25)*u^2'  fx_quadratic.png

No entanto, embora isso produzisse um resultado razoável, escurece ligeiramente os cinzas de meio-tom, produzindo uma cor amarelada doentia. Para evitar isso, uma função 'exponencial' pode ser usada em vez disso, dando melhor controle sobre o processo de tingimento.

  magick test.png  -channel B  -fx '.3*exp(-u*4.9)+u'  fx_expotential.png

Novamente, o gráfico mostra como o canal azul foi modificado para dar ao preto um tom azul escuro característico. O segundo valor ('4.9') é o decaimento de volta a um gráfico linear '+u'. Quanto menor esse valor, mais lento é o decaimento e mais linear se torna o ajuste. Quanto maior o valor, mais dramático é o 'decaimento'. O valor pode precisar de ajuste para diferentes valores de cor, portanto esta não é uma boa fórmula geral para tingir cores pretas em geral, mas é perfeita para tingir mapas meteorológicos. Em geral, se você conseguir expressar matematicamente o ajuste de cor desejado, poderá usar o operador "[-fx](https://imagemagick.org/command-line-options/#fx)" para obter os resultados que quer.

Ajustes de 'Curvas'

Normalmente, em um editor gráfico de fotos, você seria apresentado a um gráfico de 'curvas' do histograma, como o que mostrei à esquerda. O usuário pode então editar a 'curva' movendo quatro (ou mais) pontos de controle, e a função de ajuste do histograma seguirá esses pontos. Os pontos de controle geralmente especificam que o primeiro nível de escala de cinza, após o ajuste, se torna o segundo nível de escala de cinza. Assim, um ponto como 0.0,0.2 basicamente significa que um cinza de 0% (preto) deve, após o ajuste, tornar-se um nível de cinza de 20%. Ora, o IM não permite especificar diretamente 'pontos de controle' para gerar um ajuste de 'curva'; o que ele quer é a fórmula matemática dessa 'curva' gerada. Por sorte, existem programas que podem gerar essa fórmula de curva a partir dos pontos de controle, incluindo "[gnuplot](http://www.go.dlr.de/pdinfo_dv/gnuplot.html)", "[fudgit](http://www.go.dlr.de/pdinfo_dv/fudgit.html)", "mathematica" e "[matlab](http://www.mathworks.com/)", além de muitos outros pacotes de software matemático. A seguir está um método que você pode usar para gerar a fórmula a partir de quatro pontos de controle usando o "gnuplot", que é um pacote extra padrão que pode ser instalado na maioria das distribuições linux, bem como no windows.

  ( echo "0.0 0.2";  echo "1.0 0.9"; \
    echo "0.2 0.8";  echo "0.7 0.5"; )   > fx_control.txt

  ( echo 'f(x) = a*x**3 + b*x**2 + c*x + d'; \
    echo 'fit f(x) "fx_control.txt" via a, b, c, d'; \
    echo 'print a,"*u^3 + ",b,"*u^2 + ",c,"*u + ",d'; \
  ) | gnuplot 2>&1 | tail -1             > fx_funct.txt

|

Pontos de Controle
Função FX Ajustada pelo Gnuplot

| _Observe que o número de parâmetros ('a' a 'd' acima) necessários para o ajuste da curva deve ser igual ao número de pontos de controle que você fornecer. Assim, se quiser cinco pontos de controle, precisa incluir mais um termo 'e' na função.

Se a curva do seu histograma passar pelos pontos de controle fixos 0,0 e 1,1, você realmente só precisa de dois parâmetros, pois 'd' será igual a '0' e 'c' será igual a '1-a-b'.

_
---|---
Um guia de uso mais detalhado do procedimento acima, voltado especificamente a usuários do Windows, mas que também funciona para usuários de linux, foi publicado no StackOverflow: Curvas no IM usando Gnuplot no Windows. Como você pode ver na imagem extra gerada pelo "gnuplot" acima, a função gerada ajusta-se perfeitamente aos pontos de controle. Além disso, como ela gerou uma fórmula no estilo "-fx", pode ser usada como está como um argumento do IM. Por exemplo... |

  magick test.png    -fx "`cat fx_funct.txt`"     fx_funct_curve.png

Para facilitar aos usuários a conversão de pontos de controle em uma função de ajuste de histograma, criei um script de shell chamado "[**im_fx_curves**](../static/img/scripts/im_fx_curves)" que chama o "gnuplot" e produz uma equação polinomial de aparência mais agradável a partir dos pontos de controle fornecidos. Gabe Schaffer também forneceu uma versão em perl (usando um módulo de biblioteca "Math::Polynomial" baixado) chamada "[**im_fx_curves.pl**](../static/img/scripts/im_fx_curves.pl)" para fazer a mesma coisa. Qualquer um dos scripts pode ser usado. Por exemplo, aqui está uma curva diferente com 5 pontos de controle...

    im_fx_curves  0,0.2  0.3,0.7  0.6,0.5  0.8,0.8  1,0.6  > fx_curve.txt

| | |

No entanto, a função FX é muito lenta. Mas, a partir do IM 6.4.8-9, você agora pode passar diretamente os coeficientes descobertos da expressão polinomial ajustada para um Método de Função Polinomial. Você pode gerar a lista de coeficientes separados por vírgula usando "[**im_fx_curves**](../static/img/scripts/im_fx_curves)" com uma opção especial '-c'...

    im_fx_curves -c  0,0.2  0.3,0.7  0.6,0.5  0.8,0.8  1,0.6  > coefficients.txt

| | |

Por exemplo, vamos aplicar essas curvas à nossa imagem de teste... |

  magick test.png  -function Polynomial `cat coefficients.txt`  test_curves.png

Um exemplo mais prático desse método é detalhado no exemplo avançado de Efeitos "Aqua". Uma maneira alternativa de gerar 'curvas' é examinada na Discussão do Fórum do IM Curvas arbitrárias de reprodução tonal.

Tingindo Imagens

Tingimento Uniforme de Imagens com Cor

Tipicamente, o tingimento de uma imagem é obtido misturando a imagem com uma cor em uma certa proporção. Isso pode ser feito usando um Operador Evaluate ou técnicas de Mesclagem de Imagens, mas essas não são simples de usar. Por sorte, um método mais simples de sangrar uma cor uniforme em uma imagem está disponível usando o operador de imagem "[-colorize](https://imagemagick.org/command-line-options/#colorize)". Esse operador mistura a cor "[-fill](https://imagemagick.org/command-line-options/#fill)" atual em todas as imagens da sequência de imagens atual. O canal alfa da imagem original é preservado, com apenas os canais de cor sendo modificados. Por exemplo, para clarear uma imagem (em escala de cinza ou não), usamos "[-colorize](https://imagemagick.org/command-line-options/#colorize)" para misturar certa quantidade de branco na imagem, tornando-a mais brilhante sem saturá-la completamente.

  magick test.png  -fill white -colorize 50%  colorize_lighten.png

De forma semelhante, podemos usar uma cor de preenchimento 'black' para escurecer uma imagem.

  magick test.png  -fill black -colorize 50%  colorize_darken.png

Para acinzentar ambas as extremidades da imagem em direção aos meio-tons, você usaria uma cor de preenchimento cinza específica. A cor 'gray50' é a cor exata do meio do espectro de cores RGB.

  magick test.png  -fill gray50 -colorize 40%  colorize_grayer.png

  magick test.png -alpha off \
          -fill blue -colorize 100% \
          -alpha on  colorize_shape.png

Sem essa proteção, o colorize teria apagado totalmente a tela para a cor fornecida... |

  magick test.png -fill blue -colorize 100% colorize_blank.png

No entanto, se houver a possibilidade de usar uma versão do IM anterior ao IM v6.7.9, recomendo incluir uma operação "-alpha opaque" ou "-alpha off" no exemplo acima para garantir que a imagem resultante seja a imagem completamente em branco que você espera. Observe que você pode limpar telas mais rápido usando o operador de Ajustes de Nível por Cor com uma única cor, em vez de um intervalo de cores. Veja também Telas em Branco.

Tingimento de Cor nos Meio-tons

Enquanto o operador Colorize aplica a cor "[-fill](https://imagemagick.org/command-line-options/#fill)" para tingir linearmente todas as cores de uma imagem, o operador "[-tint](https://imagemagick.org/command-line-options/#tint)" aplica a cor "[-fill](https://imagemagick.org/command-line-options/#fill)" de modo a tingir apenas as cores de meio-tom de uma imagem. O operador é um operador de escala de cinza, e a cor é moderada ou realçada pelo percentual fornecido (0 a 200). Para limitar seus efeitos, ele também é ajustado usando uma fórmula matemática de modo a não afetar o preto e o branco, mas ter o maior efeito nas cores de meio-tom de cada canal de cor. Um "-tint 100" essencialmente tinge uma cor cinza perfeita de modo que ela se torne metade da intensidade da cor de preenchimento. Um valor menor a tingirá para uma cor mais escura, enquanto um valor maior a tingirá em direção a uma correspondência perfeita dessa cor.

  magick test.png  -fill red  -tint 40 tint_red.png

A cor verde na imagem de teste não é um verde RGB verdadeiro, mas um 'green' do Scaled Vector Graphics, que é apenas metade tão brilhante quanto uma cor verde verdadeira. Como tal, também é uma cor de meio-tom e, portanto, é afetada pelo operador "[-tint](https://imagemagick.org/command-line-options/#tint)", ficando mais escura, ao contrário dos pontos de cor vermelha e azul da imagem de teste. Você também pode tingir os componentes de cor individuais, usando uma lista de percentuais separados por vírgula. Por exemplo, "-tint 30,40,20,10". Isso, porém, pode ser complicado de usar e talvez exija alguma experimentação para acertar. Melhor especificar a cor que você quer para cinzas perfeitos de 50%. | _ O operador "[-tint](https://imagemagick.org/command-line-options/#tint)" funciona tomando de algum modo a cor e os percentuais fornecidos e então ajustando as cores individuais da imagem de acordo com a intensidade das cores "[-fill](https://imagemagick.org/command-line-options/#fill)", conforme a fórmula a seguir. (veja o gráfico à direita)

_ f(x)=(1-(4.0*((x-0.5)*(x-0.5)))) _Uma função quadrática, cujo resultado é usado como vetor para a cor existente na imagem. Como você pode ver, produz uma substituição completa da cor para um cinza médio puro, sem ajuste algum para branco ou preto.

Ou, para operadores de nível mais baixo que você pode usar para fazer você mesmo esse tipo de coisa, veja Operador FX, bem como Operadores Evaluate e Function.

_
---|---
O operador de tingimento é perfeito para ajustar os resultados da saída de "[-shade](https://imagemagick.org/command-line-options/#shade)" (veja Imagens de Realce por Sobreposição de Sombreamento), como os exemplos em Imagens de Marcadores 3D. Você também pode usar "[-tint](https://imagemagick.org/command-line-options/#tint)" para clarear ou escurecer as cores de meio-tom de uma imagem. Isso é uma espécie de 'ajuste de gama' para imagens, embora não exatamente. Por exemplo, usar um valor de tint maior que 100 com uma cor 'white' clareará os meio-tons.

  magick test.png  -fill white  -tint 130 tint_lighter.png

Enquanto um valor menor que 100 escurecerá as cores.

  magick test.png  -fill white  -tint 70 tint_darker.png

| _No momento, uma cor cinza de meio-tom puro não será mapeada para a cor "[-fill](https://imagemagick.org/command-line-options/#fill)".

O argumento percentual não é um 'percentual de mesclagem', mas na verdade mais um 'percentual de brilho'. Ele, por exemplo, não funcionará de forma alguma para uma cor de preenchimento 'black'.

Não sei por que foi projetado dessa maneira nem a história por trás disso. No entanto, isso torna o controle exato das cores finais ao tingir imagens em escala de cinza muito trabalhoso.

Usar o Tingimento por Composição de Sobreposição abaixo fornecerá um tingimento de cor mais exato (embora muito linear, em vez de parabólico) dos cinzas de meio-tom.

_
---|---

Coloração em Tom Sépia

Uma técnica especial de recolorização fotográfica, "[-sepia-tone](https://imagemagick.org/command-line-options/#sepia-tone)" basicamente consiste em converter a imagem em escala de cinza e colorir todos os meio-tons com uma cor marrom especial. |

  magick rose:  -sepia-tone 65%     sepia-tone.jpg

O argumento fornecido é o 'ponto médio' da escala de cinza que deve tornar-se o mais próximo da cor sépia, que é semelhante à cor 'Goldenrod'. O uso mais comum disso é gerar um Efeito Duotone de modo a produzir fotos com 'aparência antiga' (veja a wikipedia sobre Tom Sépia). Por exemplo, aqui eu Tinjo uma imagem de rosa em escala de cinza com contraste realçado, usando várias cores, para obter efeitos semelhantes ao tom sépia. Qual cor você deve usar depende do efeito exato que procura.

  magick rose: -colorspace gray -sigmoidal-contrast 10,40%  rose_grey.jpg
  for color in      goldenrod  gold  khaki  wheat
  do
    magick rose_grey.jpg  -fill $color   -tint 100    sepia_$color.jpg
  done

Eu mesmo acho que misturar ou mesclar uma imagem em tom sépia com a original, de modo a reduzir seu efeito, também pode produzir um melhor efeito 'desbotado'. |

  magick rose: \( +clone -sepia-tone 60% \) -evaluate-sequence mean  sepia-tone_blended.jpg

Veja também Tabelas de Consulta de Cores Hald para um método pelo qual você pode salvar variações de mudança de cor muito mais complexas, como o último exemplo acima.

Efeito Duotone

Um 'duotone' é um método de impressão em que se mistura a escala de cinza de uma imagem (tinta preta) com alguma outra cor para produzir um resultado melhor, com orçamento ou equipamento de impressão limitados. Por exemplo, a razão pela qual todas as fotos antigas que você vê hoje têm um aspecto sépia é que as tintas em tom sépia sobreviveram e não se deterioraram nem desbotaram com o tempo. Outros formatos de imagens em 'preto e branco' desbotaram até se tornarem inúteis. Veja o Operador Sepia Tone acima. Outra técnica de duotone conhecida como 'Cianotipia' (mais comumente conhecida como 'blue-prints', ou plantas azuis) tornou-se amplamente usada como método de fazer cópias em larga escala dos desenhos originais em preto e branco dos arquitetos. Lembre-se de que essa técnica era usada muito antes da invenção dos lasers e, a partir dela, das fotocópias (e do Xerox). Para mais informações, veja o verbete da Wikipedia sobre Duotone, e também Duotones falsos vs Duotones reais. O Operador Tint acima, porém, produz um fac-símile razoável do efeito duotone, tal como fez para o efeito semelhante ao sépia acima.

  magick rose: -colorspace gray -sigmoidal-contrast 10,40%  rose_grey.jpg
  for color in      blue  darkcyan  goldenrod  firebrick
  do
    magick rose_grey.jpg   -fill $color   -tint 100    duotone_$color.jpg
  done

Observe que geralmente escolhi uma versão mais escura da cor do 'duotone', mas você também pode ajustar isso usando o argumento do Operador Tint. O brilho e o contraste também podem ser ajustados usando os argumentos do Operador Sigmoidal Contrast. Outra maneira mais precisa de gerar um duotone a partir de três cores (as cores do ponto preto, ponto médio e ponto branco) é usar uma Tabela de Consulta de Cores (veja abaixo). Aqui está apenas um exemplo rápido em que crio um duotone bastante incomum usando as cores 'Black', 'Chocolate' e 'LemonChiffon' para o duotone. E sim, a cor do ponto preto normalmente é deixada em preto, razão pela qual costuma ser chamada de duo -tone.

  magick -size 1x1 xc:Black xc:Chocolate xc:LemonChiffon \
                                   +append     duotone_clut.gif
  magick -size 20x256 gradient: -rotate 90   duotone_clut.gif \
          -interpolate Bicubic -clut       duotone_gradient.gif
  magick rose_grey.jpg   duotone_clut.gif \
          -interpolate Bicubic -clut       rose_duotone.jpg

A vantagem do procedimento acima é o controle exato da cor do ponto médio (ao contrário do Tint, que não é exato). Você também pode usar diretamente qualquer uma das três cores que quiser, tal como no exemplo acima, ou usar um gradiente expandido das cores para um controle mais fino das cores entre os três (ou mais) pontos de controle. A técnica também oferece uma maneira muito compacta de armazenar o efeito duotone específico, para uso repetido e futuro. Veja também Tabelas de Consulta de Cores Hald para um método mais complexo de salvar mudanças de cor, que vai além de colorir imagens em escala de cinza.

Tingimento de Cor, Faça Você Mesmo

Um dos maiores problemas com "[-tint](https://imagemagick.org/command-line-options/#tint)" é que ele é um operador de escala de cinza (ou vetor). Ou seja, ele lida com cada um dos canais vermelho, verde e azul de forma completamente separada dos demais. Isso, por sua vez, significa que uma cor primária e secundária como 'blue' ou 'yellow' não são afetadas por "[-tint](https://imagemagick.org/command-line-options/#tint)", embora todos os níveis de cinza sejam. No entanto, graças a diversas transformações matemáticas de canal, como o Operador FX e os mais rápidos Operadores Evaluate e Function, você pode gerar suas próprias sobreposições de cor para modificar a imagem. Ou seja, Tingir a imagem de forma semelhante ao que o Operador Colorize faz. Por exemplo, aqui converto o nível de brilho em escala de cinza de uma imagem em uma sobreposição semitransparente da cor específica desejada. |

  magick test.png  \( +clone -colorspace gray \
               -function polynomial -4,4,0 -background Gold -alpha shape \) \
          -composite   tint_diy_compose.png

Atenção: isso não preserva corretamente a transparência da imagem, mas funcionará bem para imagens totalmente opacas. Observe que, ao contrário do tint, qualquer cor pode ser usada, incluindo 'black', já que a cor não é tratada como uma adição vetorial, mas como uma composição alfa. O resultado não é exatamente o mesmo que você obteria com um tint normal.

Sobreposição de Tingimento de Cor

Os métodos especiais de Composição Alfa '[Overlay](compose.html#overlay)' e '[Hardlight](compose.html#hardlight)' foram, na verdade, projetados tendo em mente o tingimento de cor (e de padrões). Esses métodos de composição também substituem os cinzas de meio-tom, deixando intactos os realces de preto e branco da imagem. Por exemplo, aqui rapidamente gero uma imagem de sobreposição colorida e a componho para tingir a imagem original. |

  magick test.png \( +clone -alpha off -fill gold -colorize 100% \) \
          -compose overlay -composite  tint_overlay.png

Como você pode ver, a composição alfa não preserva nenhuma transparência da imagem original, exigindo o uso de uma segunda operação de composição alfa para corrigir esse problema. |

  magick test.png \
          \( +clone -alpha off -fill gold -colorize 100% \
             +clone +swap -compose overlay -composite \) \
          -compose SrcIn -composite  tint_overlay_fixed.png

Usar '[Overlay](compose.html#overlay)' é uma forma de tingimento muito mais linear do que a função quadrática usada acima e, como "[-tint](https://imagemagick.org/command-line-options/#tint)", é aplicado a cada canal da imagem separadamente, de modo que as cores primárias e secundárias também permanecem inalteradas. Além disso, nenhum controle de ajuste é fornecido por esse método de composição alfa, então, se você quiser controlar o nível de tingimento, precisará ajustar a transparência da imagem de sobreposição antes de aplicar o tint. É claro que, ao contrário dos outros métodos de tingimento que mostrei até agora, você não está limitado a tingir com uma cor simples, mas pode aplicar um tint usando uma imagem, ou um padrão de mosaico. |

  magick test.png \
          \( -size 150x100 tile:tile_disks.jpg \
             +clone +swap -compose overlay -composite \) \
          -compose SrcIn -composite  tint_overlay_pattern.png

Isso, porém, está saindo do escopo do tratamento básico de cores, então vou deixar o tingimento de imagens por aqui. | _O método de composição alfa '[HardLight](compose.html#hardlight)' produzirá os mesmos resultados que '[Overlay](compose.html#overlay)', mas com as imagens de origem e destino trocadas.

Isso poderia ter sido usado no lugar do "+swap" nos últimos exemplos._
---|---

Modificadores Globais de Cor

Modular Brilho, Saturação e Matiz

O operador "[-modulate](https://imagemagick.org/command-line-options/#modulate)" é especial porque modifica uma imagem no espaço de cor HSL (matiz-saturação-luminosidade). Ele converte cada pixel de cor para esse espaço de cor, modifica-o e o converte de volta ao espaço de cor original. Recebe três valores (embora os valores posteriores sejam opcionais) como porcentagem, de forma que 100 não altera a imagem. Por exemplo.. |

  magick rose: -modulate 100,100,100  mod_noop.gif

O primeiro valor, brilho , é um multiplicador do brilho geral da imagem.

  magick rose:  -modulate 0     mod_bright_0.gif
  magick rose:  -modulate 50    mod_bright_50.gif
  magick rose:  -modulate 80    mod_bright_80.gif
  magick rose:  -modulate 100   mod_bright_100.gif
  magick rose:  -modulate 150   mod_bright_150.gif
  magick rose:  -modulate 200   mod_bright_200.gif

Note que, embora um argumento de brilho igual a '0' produza uma imagem preta pura, não é possível produzir uma imagem branca pura usando esse operador isoladamente. O segundo valor, saturação , também é um multiplicador que ajusta a quantidade geral de cor presente na imagem.

  magick rose:  -modulate 100,0     mod_sat_0.gif
  magick rose:  -modulate 100,20    mod_sat_20.gif
  magick rose:  -modulate 100,70    mod_sat_70.gif
  magick rose:  -modulate 100,100   mod_sat_100.gif
  magick rose:  -modulate 100,150   mod_sat_150.gif
  magick rose:  -modulate 100,200   mod_sat_200.gif

Uma saturação de '0' produz uma imagem em tons de cinza, como também foi mostrado em Convertendo Cor para Tons de Cinza acima. O cinza, porém, mistura os três canais de cor igualmente, conforme definido pelo espaço de cor HSL, e por isso não produz um verdadeiro cinza de 'intensidade'. Essencialmente, valores pequenos produzem cores mais 'pastel', enquanto valores maiores que '100' produzem imagens mais coloridas e caricatas. Note que, como o brilho e a saturação são multiplicadores percentuais, seria preciso multiplicar por um número muito grande para levar quase todos os valores de cor da imagem próximos ao máximo. Ou seja, seria necessário um fator de brilho próximo de um milhão para tornar brancas todas as cores exceto o preto puro.

Modulação de Matiz

O último valor, Matiz , é na verdade muito mais útil. Ele rotaciona as cores da imagem de forma cíclica. Para isso, o valor de Matiz informado produz uma 'adição modular', em vez de uma multiplicação. Porém, atenção: a matiz é rotacionada usando uma porcentagem, e não um ângulo. Isso pode parecer estranho, mas "[-modulate](https://imagemagick.org/command-line-options/#modulate)" sempre funcionou assim. As fórmulas de conversão entre ângulo e o argumento de modulate são...

_hue_angle_ = ( _modulate_arg - 100_ ) * 180/100
_modulate_arg_ = ( _hue_angle * 100/180_ ) + 100

Isso significa que '100' (para os três argumentos) não produz alteração. Já um valor de '0' ou '200' efetivamente inverte as cores da imagem (mas não a intensidade). Por exemplo...

  magick rose:  -modulate 100,100,0      mod_hue_0.gif
  magick rose:  -modulate 100,100,33.3   mod_hue_33.gif
  magick rose:  -modulate 100,100,66.6   mod_hue_66.gif
  magick rose:  -modulate 100,100,100    mod_hue_100.gif
  magick rose:  -modulate 100,100,133.3  mod_hue_133.gif
  magick rose:  -modulate 100,100,166.6  mod_hue_166.gif
  magick rose:  -modulate 100,100,200    mod_hue_200.gif

0
(vermelho <-> ciano) |
33.3
(vermelho -> azul) |
66.6 |
100%
sem efeito |
133.3 |
166.6
(vermelho -> verde) |
200
(igual a 0)
---|---|---|---|---|---|---

Como se pode ver, um valor de '33.3' produz uma rotação negativa, ou anti-horária, de todas as cores em aproximadamente 60 graus, mapeando efetivamente o vermelho para azul, o azul para verde e o verde para vermelho. Usar valores de '0' ou '200' produz uma inversão completa de 180 graus das cores, sem inverter o brilho da imagem. Note que as matizes são cíclicas, de modo que usar um valor de '300' produz uma rotação de cor de 360 graus, resultando em nenhuma alteração na imagem. Para exemplos de uso da 'Modulação de Matiz' para modificar cores em imagens, veja Mascaramento por Chroma Key e Alfinetes em um Mapa.
Esses tipos de operações, e outras, também podem ser aplicados usando técnicas avançadas de Espaço de Cor, como no Operador de Matriz de Recoloração (abaixo), mas para a 'modulação' básica de uma imagem, esse operador simplifica muito as coisas. Para troca de cores primárias, tanto o Operador de Matriz de Recoloração quanto a troca de canais (veja Operadores Separar/Combinar) são provavelmente técnicas mais precisas, embora bem menos versáteis. Veja também Tabelas de Consulta de Cor Hald para um método pelo qual você pode salvar variações de mudança de cor, especialmente mudanças de Matiz, para reutilizar depois.

Modulate Faça Você Mesmo

Se você realmente quiser, pode "Fazer Você Mesmo". Basicamente você converte a imagem para o espaço de cor apropriado, modifica os valores e converte de volta. Lembre-se de que no Espaço de Cor HSL, o canal Green armazena o valor de Saturação e o canal Blue armazena o valor de Luminância. Por exemplo, aqui está o equivalente a um "-modulate 80,120" (escurecer levemente, aumentar a saturação de cor), usando o espaço de cor HSL padrão...

  magick rose: -colorspace HSL \
          -channel B -evaluate multiply 0.80 \
          -channel G -evaluate multiply 1.20 \
          +channel -colorspace sRGB   modulate_channel.png

É claro que, se você modificar a Matiz (canal vermelho) usando esse método, será preciso garantir que o valor final 'dê a volta' (um módulo), em vez de simplesmente recortar o valor no máximo ou no mínimo (ambos correspondem à matiz 'vermelha'). Por isso, provavelmente é mais fácil usar diretamente o Operador Modulate para modificações de Matiz.

Modulate em Outros Espaços de Cor

O maior problema com "[-modulate](https://imagemagick.org/command-line-options/#modulate)" surge ao lidar com imagens que contêm muitas cores 'quase brancas'. Como ele trabalha no espaço de cor HSL, cores que não são exatamente brancas ficam mais 'saturadas' à medida que o brilho é reduzido. Você pode ver isso na folha branca da imagem da rosa acima, que apresenta muitos artefatos de cor ao ser escurecida em 50%. Isso é especialmente um problema ao lidar com formatos de imagem JPEG, que tendem a gerar cores quase brancas (na verdade, todas as cores geralmente ficam ligeiramente alteradas no JPEG) devido ao seu algoritmo de compressão com perdas. Por exemplo...

  magick wedding_party_sm.jpg  -modulate 85  modulate_off-white.png

O problema aqui é que, em HSL, todas as cores quase brancas ficam concentradas em uma pequena área de 'ponto branco' do espaço de cor usado (um cone duplo). Quando o brilho é então reduzido, as cores quase brancas se expandem à medida que o cone de cor se expande, fazendo com que a cor quase branca gere um conjunto de cores quase brancas mais coloridas (saturadas). Ou seja, pequenas variações de cor são exageradas. A solução para isso é aplicar "[-modulate](https://imagemagick.org/command-line-options/#modulate)" no espaço de cor HSB, em vez do espaço de cor HSL. | _O 'B' em HSB significa Brightness (brilho), mas também é comumente conhecido como HSV, com o 'V' significando Value (valor). São o mesmo espaço de cor, mas 'V' é um termo confuso, já que um valor normalmente significa 'um número armazenado'.

Existe também um espaço de cor HSI (usando 'I' de Intensity), mas ele é incomum e desnecessário, dada a adição do espaço de cor cíclico HCL (onde 'L' significa Luminance) (veja abaixo).

_
---|---
No espaço de cor HSB, o 'branco' não é um único ponto, mas um grande 'disco', e por isso os quase-brancos não estão 'próximos' uns dos outros. Assim, quando você reduz o brilho, os quase-brancos se contraem igualmente, reduzindo quaisquer pequenas variações de cor em vez de expandi-las. Dessa forma, os brancos simplesmente se tornam cinza, e não mais coloridos. Para modular a imagem no Espaço de Cor HSB, você pode tanto usar a técnica Faça Você Mesmo (veja acima) nesse espaço de cor, ou, com o IM v6.5.3-7 e posteriores, você pode Definir um Controle Operacional de 'modulate:colorspace' com um dos espaços de cor de 'Matiz'. |

  magick wedding_party_sm.jpg \
          -define modulate:colorspace=HSB -modulate 85 \
          modulate_HSB.png

Outros espaços de cor de 'Matiz' são HWB e HCL (veja a próxima seção). É claro que, se você redimensionou a imagem para esse tamanho pequeno, uma solução ainda melhor é NÃO salvar a imagem em JPEG, que foi a causa dos valores quase brancos. Melhor ainda: não salve a imagem de forma alguma até terminar, para manter todos os valores de cor na melhor configuração de qualidade em memória. A razão pela qual o espaço de cor HSB não é usado por padrão no modulate é que, se você clareia uma imagem nesse espaço de cor, as cores ficam mais saturadas e intensas, em vez de a imagem ficar mais brilhante e branca. Aqui, por exemplo, está um aumento de brilho de 150% da imagem 'rose' no HSL padrão e em um espaço de cor HSB especificado, para comparação.

  magick rose:         -modulate 150        mod_bright_HSL.gif
  magick rose: -define modulate:colorspace=HSB \
                         -modulate 150        mod_bright_HSB.gif

HSL |
HSB
---|---

| _Antes do IM v6.4.0-10, o operador "[-modulate](https://imagemagick.org/command-line-options/#modulate)" de fato usava o espaço de cor HSB em vez do HSL. Isso foi alterado por causa de um relato de bug de um usuário sobre a situação acima.

O ponto é que, para algumas imagens, você se prejudica se usar HSL, e para outras imagens você se prejudica se usar o espaço de cor HSB. Depende do que você está tentando fazer!

_
---|---

Modulate em LCHab e Outros Espaços de Cor

  for i in   0 25 50 75 100 125 150 175;  do
    magick rose: -define modulate:colorspace=LCHab \
                            -modulate 100,100,$i     mod_lch_$i.gif
  done

0% & 200% |
25%
(vermelho->azul) |
50% |
75% |
100%
sem efeito |
125% |
150% |
175%
---|---|---|---|---|---|---|---

Note que as matizes se distribuem de forma diferente em relação aos espaços de cor de Matiz mais tradicionais. Mas, mais importante, a intensidade da imagem original é preservada. Por causa disso, você nunca passará ciclicamente de uma cor primária/secundária pura para outra cor primária/secundária pura, já que nenhuma delas tem a mesma intensidade. A progressão de cores ao longo das matizes, porém, flui de forma mais suave, com 'picos' menos acentuados nas cores primárias e secundárias. Aqui está uma comparação de uma simples rotação de matiz de vermelho para azul no espaço de cor 'LCHab' versus o 'HSL' normal (usando as porcentagens de rotação apropriadas).

Original | |
LCHab
25% |
HSL/HSB
33.3%
---|---|---|---

Note como o azul não fica nem de longe tão escuro, mas é um tom que combina melhor com o tom da imagem original. Para mais informações sobre matizes do espaço de cor HCL, veja os exemplos em A Roda de Cores LCH. | _Antes do IM v6.8.4-7, você teria usado o espaço de cor 'HCL ' (introduzido no IM v6.7.9-1). Esse espaço de cor é exatamente igual ao 'LCHuv ', mas com a ordem dos canais invertida (Matiz armazenada no canal Vermelho da imagem, apenas pela forma como esse espaço de cor foi definido). Isso significava que você também tinha que trocar os vários canais para que o Operador Modulate funcionasse corretamente.

Os espaços de cor 'LCHab ' e 'LCHuv ' ordenam os canais da mesma forma que o 'HSL ', de modo a permitir que o modulate funcione corretamente, e diretamente no espaço de cor, sem exigir a reordenação dos canais.

_
---|---
| _Note que, para cores muito escuras, o 'LCHuv ' pode gerar valores de cor com descontinuidades. Isso, porém, não deve acontecer com imagens reais, apenas com imagens geradas diretamente no espaço cilíndrico.

_
---|---

Operador de Matriz de Cor

O operador "[-color-matrix](https://imagemagick.org/command-line-options/#color-matrix)" recolore imagens usando uma técnica de matriz. Ou seja, você fornece a ele uma matriz de valores que representa como mesclar linearmente os valores dos vários canais de cor de uma imagem para produzir novos valores de cor. O uso típico é fornecer ao operador 9 valores, que formam três funções (linhas) ou três multiplicadores (colunas). Assim, os três primeiros números são a fórmula de cor para o canal 'vermelho'. Os três seguintes para o 'verde', e assim por diante. Por exemplo... |

  magick rose: -color-matrix ' 1 0 0
                                0 1 0
                                0 0 1 '   matrix_noop.png

Equivale a aplicar as equações...

Nesse caso específico, nenhuma alteração é feita na imagem. A matriz forma um arranjo especial, conhecido como 'matriz identidade'. Ao embaralhar as linhas, você pode usá-la para trocar os vários canais. Por exemplo, aqui eu troco os valores dos canais vermelho e azul. |

  magick rose: -color-matrix ' 0 0 1
                                0 1 0
                                1 0 0 '  matrix_red_blue_swap.png

Ou simplesmente copie o canal vermelho para os outros dois canais, para extrair ou separar o 'canal vermelho' (veja também Separando Imagens de Canal)... |

  magick rose: -color-matrix ' 1 0 0
                                1 0 0
                                1 0 0 '  matrix_red_channel.png

ou converta a imagem para tons de cinza usando uma proporção de tons de cinza 2/5/3 (veja Convertendo Cor para Tons de Cinza)... |

  magick rose: -color-matrix ' .2 .5 .3
                                .2 .5 .3
                                .2 .5 .3 '  matrix_grayscale.png

Você pode usar uma matriz maior, de até um conjunto de 6 linhas e colunas. Elas correspondem aos canais: 'Red', 'Green', 'Blue', 'Black' (se definido), 'Alpha' (se definido) e uma constante. Note que os canais 'Black' e 'Alpha' ainda precisam ser fornecidos se a matriz for tão grande, mesmo que o próprio valor não esteja presente ou não seja usado. A última coluna, a constante, é apenas uma simples adição (ou subtração, se negativa) à fórmula. A 6ª linha (se fornecida) é simplesmente ignorada e não utilizada. Por padrão, a definição da 'matriz' segue a mesma estrutura de um Núcleo de Morfologia/Convolução Definido pelo Usuário e é tratada como um núcleo 'quadrado' se nenhuma geometria de tamanho for especificada. O deslocamento do núcleo atualmente não é usado. O 'arranjo de valores' fornecido é então sobreposto a uma 'matriz identidade 6x6' maior (uma diagonal de 1's) antes de ser aplicado à imagem. Esse tratamento interno significa que você pode, na verdade, simplificar o valor da matriz usando apenas algumas linhas de números, em vez de todas. Isso é especialmente útil quando você precisa incluir a 'constante' nos cálculos de cor, ou quer modificar apenas um canal. Por exemplo, inverta (invertido) a imagem. |

  magick rose: -color-matrix '6x3: -1  0  0 0 0 1
                                     0 -1  0 0 0 1
                                     0  0 -1 0 0 1'  matrix_negate.png

Defina todos os valores do canal vermelho no máximo (usando a 'constante')... |

  magick rose: -color-matrix '6x1: 0,0,0,0,0,1'  matrix_red_max.png

Por causa da sobreposição na matriz identidade, nenhum dos valores dos outros canais é afetado, embora ainda sejam recalculados internamente. | Antes do IM v6.6.1-0, "[-color-matrix](https://imagemagick.org/command-line-options/#color-matrix)" chamava-se "-recolor.
---|---

Exemplos de Matriz de Cor

Cor Sépia , ou pelo menos uma forma linear dessa operação |

  magick rose: -color-matrix ' 0.393 0.769 0.189
                                0.349 0.686 0.168
                                0.272 0.534 0.131  ' matrix_sepia.png

Cores vívidas , numa técnica chamada Digital Velvia... |

  magick rose: -color-matrix '  1.2 -0.1 -0.1
                                -0.1  1.2 -0.1
                                -0.1 -0.1  1.2 ' matrix_vivid.png

Essa matriz clareia cada canal de cor enquanto subtrai as cores dos outros canais, tornando as cores mais vívidas na imagem RGB. Isso não é exatamente o mesmo que usar Modulate para aumentar a saturação de cor de uma imagem em 20%, mas é semelhante. Cor Polaroid... |

  magick rose: -color-matrix \
            '6x3:  1.438 -0.122 -0.016  0 0 -0.03
                  -0.062  1.378 -0.016  0 0  0.05
                  -0.062 -0.122 1.483   0 0 -0.02 ' matrix_polaroid.png

Futuro: Rotações de matiz usando uma matriz de cor...
Como descrito na página web do Grafica Obscura.
Para mais informações sobre o uso de uma matriz de cor, veja...

• Tutorial de Filtro de Matriz de Cor do Adobe Flash
• Transformações de Cor e a Matriz de Cor
• ColorMatrix Unleased
• Grafica Obscura - Operações de Matriz para Processamento de Imagem
• Filtro de Matriz de Cor SWF (para rotação de matiz com preservação de luminância)

Porém, atenção: a maioria dessas implementações usa uma forma Transposta Diagonalmente da matriz, na qual as colunas formam a equação, em vez das linhas. Ou envolve menos canais (número menor de linhas/colunas).

Coloração por Solarização

"[-solarize](https://imagemagick.org/command-line-options/#solarize)" uma imagem é basicamente 'queimar' as cores mais brilhantes até o preto. Quanto mais brilhante a cor, mais escura fica a cor solarizada. Isso acontece na fotografia quando o filme químico é superexposto. |

  magick rose:  -solarize 90%     solarize.jpg

Basicamente, tudo acima do nível de tons de cinza informado é invertido. Então, se você fornecer um argumento de '0%', você basicamente tem um Operador de Inverter de pobre. Por exemplo, aqui está uma "[-solarize](https://imagemagick.org/command-line-options/#solarize)" simulada usando uma fórmula matemática "[-fx](https://imagemagick.org/command-line-options/#fx)". |

  magick rose:  -fx  '.9>u ? u : 1-u'     solarize_fx.jpg

Esse operador é particularmente adequado para extrair as cores cinza de tons médios das imagens. Por exemplo, aqui eu uso uma operação de Contraste Sigmoidal muito forte para produzir uma espécie de limiar 'difuso' em 70% de cinza. Em seguida, Solarizo o resultado para gerar um pico difuso em vez de um limiar difuso. Um ajuste final de nível então leva o pico ao brilho máximo para gerar um efeito de 'filamento'.

  magick -size 10x300 gradient: -rotate 90 \
                         -sigmoidal-contrast 50x70%   fuzzy_thres.png
  magick fuzzy_thres.png  -solarize 50%   fuzzy_spike.png
  magick fuzzy_spike.png  -level 0,50%    filament.png

À PARTE: As imagens acima, mostrando gráficos de 'perfil' do gradiente, foram geradas usando o "[im_profile](../static/img/scripts/im_profile)" no diretório Scripts do IM Examples. Note como tudo que é branco se torna preto, enquanto os cinzas de tons médios ao redor do pico central são preservados. A difusão e o posicionamento do pico são determinados pelo operador "[-sigmoidal-contrast](https://imagemagick.org/command-line-options/#sigmoidal-contrast)". Eu o chamo de 'filamento' porque, tipicamente, o resultado se parece notavelmente com filamentos elétricos incandescentes, ou descargas de raios. Veja Fluxo Aleatório para outro exemplo desse efeito. Essa extração de cinzas de tons médios também é bem aproveitada em técnicas para gerar Contornos de Borda a partir de Formas Bitmap, e para a multiplicação de dois gradientes enviesados. Outro uso original dessa operação é determinar se uma imagem é basicamente um esboço ou desenho puramente em preto e branco (como o de um livro), em vez de uma imagem em tons de cinza sombreados ou colorida. Veja Determinando se uma imagem é: Preto e Branco Puro, ou Tons de Cinza

Recolorindo Imagens com Tabelas de Consulta

Embora você possa recolorir imagens usando os vários ajustes de cor por histograma mostrados acima, há outra técnica para recolorir imagens, simplesmente 'consultando' os valores modificados a partir de um gradiente de cor pré-preparado, ou "Tabelas de Consulta de Cor" (Color LUT, ou CLUT). Existem dois tipos de Color LUT: as LUT simples unidimensionais, ou 'por canal', e as LUT de cor 3D. Uma LUT de canal tem três tabelas de consulta independentes: uma para cada canal R, G e B. Cada entrada na LUT de canal mapeia um valor de canal de entrada para um valor de canal de saída. O canal vermelho da imagem de saída é afetado apenas pelo valor vermelho original da imagem de entrada. Uma LUT de cor 3D, porém, permite que toda a cor seja substituída como uma função de toda a cor de entrada. Ou seja, o valor de saída do canal vermelho pode depender de qualquer um, ou de todos, os valores de entrada de vermelho, verde e azul. Isso é às vezes chamado de interferência entre canais (cross-talk).

Tabelas de Consulta de Cor (por Canal)

Um requisito comum de uma ferramenta de processamento de imagem é a capacidade de substituir toda a faixa de cores a partir de uma tabela de cores pré-preparada. Isso permite converter imagens de um conjunto de cores (geralmente tons de cinza) em um conjunto de cores completamente diferente, apenas consultando sua cor de substituição em uma imagem especial. É claro que você precisa de uma imagem de 'Tabela de Consulta' da qual ler as cores de substituição. Para estes primeiros exemplos, escolhi usar um gradiente vertical de cores para a LUT, de modo que o gerador "[gradient:](canvas.html#gradient)" do IM possa ser usado para simplificar a geração da 'tabela de consulta de cor'. Bem, chega de teoria. Vamos testá-la recolorindo uma simples imagem de Plasma em Tons de Cinza, substituindo os tons de cinza por um gradiente de cores que vai do azul-escuro ao quase-branco.

  magick -size 100x100 plasma:fractal -virtual-pixel edge -blur 0x5 \
          -shade 140x45  -normalize \
          -size 1x100 xc:black -size 9x100 gradient: \
          +append  gray_image.jpg
  magick -size 10x100  gradient:navy-snow       gradient_ice-sea.png
  magick gray_image.jpg  gradient_ice-sea.png -clut  gray_recolored.jpg

  magick gray_image.jpg  gradient_ice-sea.png \
          -fx 'v.p{0,u*v.h}'  gray_recolored_fx.jpg

O problema é que, mesmo para um processo simples como o acima, o operador "[-fx](https://imagemagick.org/command-line-options/#fx)" é muito lento e precisa ser projetado especificamente para uma LUT de linha ou de coluna. Mas funciona. A LUT não precisa ser muito grande. Por exemplo, aqui usamos uma LUT muito pequena, com um número muito limitado de cores.

  magick -size 1x6 gradient:navy-snow  gradient_levels.png
  magick gray_image.jpg  gradient_levels.png  -clut  gray_levels.jpg

Ampliei a imagem do gradiente para a exibição na página acima, caso contrário seria pequena demais para ser vista adequadamente. A LUT tem, na verdade, apenas 6 pixels de tamanho. No entanto, se você observar o resultado, verá que o Operador de Consulta de Cor suaviza essas 6 cores em um gradiente contínuo. O que está acontecendo é que o IM está fazendo uma Consulta Interpolada da imagem LUT. Ou seja, em vez de simplesmente escolher a cor encontrada, ele faz uma média ponderada de todas as cores próximas para representar melhor a LUT. Nesse caso específico, ele usou a configuração padrão '[Bilinear](misc.html#bilinear)', que simplesmente conecta cada pixel colorido por segmentos de linha reta. Diferentes configurações de "[-interpolate](https://imagemagick.org/command-line-options/#interpolate)" geram diferentes níveis de suavização das cores ao usar uma LUT de cor muito pequena. Aqui, por exemplo, mostro vários tipos de suavização interpolada das cores da LUT.

  magick gray_image.jpg  gradient_levels.png \
          -interpolate Integer         -clut  gray_levels_integer.jpg
  magick gray_image.jpg  gradient_levels.png \
          -interpolate NearestNeighbor -clut  gray_levels_nearest.jpg
  magick gray_image.jpg  gradient_levels.png \
          -interpolate Average         -clut  gray_levels_average.jpg
  magick gray_image.jpg  gradient_levels.png \
          -interpolate Blend           -clut  gray_levels_blend.jpg
  magick gray_image.jpg  gradient_levels.png \
          -interpolate BiLinear        -clut  gray_levels_bilinear.jpg
  magick gray_image.jpg  gradient_levels.png \
          -interpolate Catrom          -clut  gray_levels_catrom.jpg
  magick gray_image.jpg  gradient_levels.png \
          -interpolate Spline          -clut  gray_levels_spline.jpg

Integer |
Nearest |
Average |
Blend |
BiLinear |
Catrom |
Spline
---|---|---|---|---|---|---

As configurações '[Integer](misc.html#integer)' e '[Nearest](misc.html#nearest)' são especiais por não suavizarem as cores de forma alguma. Ou seja, nenhuma nova 'cor misturada' será adicionada; apenas os valores de cor exatos presentes serão usados para colorir uma imagem em tons de cinza. Note, porém, como a consulta das cores difere entre as duas. É uma diferença sutil, mas pode ser muito importante. A configuração '[Average](misc.html#average)', por outro lado, também gerou faixas de cor, mas usando apenas uma mistura das cores, resultando em uma cor a menos que o tamanho da imagem da tabela de consulta de cor. '[Blend](misc.html#blend)', porém, mistura '[Average](misc.html#average)' e '[Nearest](misc.html#nearest)', para adicionar mais pixels. Esse tipo de 'faixamento' de cor (ou Artefatos de Blocagem) é, na verdade, bastante comum em mapas geográficos e gráficos de temperatura, pois dá uma melhor representação da forma exata do mapa. As bordas de fronteira acentuadas são conhecidas como isolinhas. Adicionar um leve Desfoque de um pixel à imagem final pode melhorar a aparência dessas bordas, tornando-as um pouco mais suaves, sem destruir o faixamento de cor. A configuração '[BiLinear](misc.html#bilinear)' também gerará faixamento, mas apenas na forma de mudanças bruscas de gradiente, quando as cores mudam abruptamente (não neste exemplo). Já '[Catrom](misc.html#catrom)' suavizará as mudanças de cor. Por fim, '[Spline](misc.html#spline)' desfocará as cores e pode não gerar nenhuma das cores presentes na CLUT fornecida. Para evitar problemas de interpolação, ou definir melhor os gradientes de cor, a melhor ideia é usar uma LUT bem mais longa. Idealmente, ela deve cobrir toda a faixa de valores de intensidade possíveis. Para o ImageMagick Q16 (compilado com qualidade de 16 bits), isso exige uma LUT com altura de 65536 pixels. Mas a Interpolação de Pixel permite usar uma imagem de gradiente LUT mais razoável, de 500 pixels, adequada para a maioria das tarefas de recoloração de imagem. Note que a LUT de gradiente vertical usada nos exemplos acima aparece de cabeça para baixo aos nossos olhos, pois o índice preto, ou '0', está no topo da imagem. Normalmente, nós humanos preferimos ver gradientes com o nível preto na parte inferior (graças ao nosso passado evolutivo). Se você preferir salvar a imagem de gradiente 'do lado certo para cima', pode aplicar "[-flip](https://imagemagick.org/command-line-options/#flip)" na imagem ao lê-la. Por exemplo, vamos testar uma LUT mais complexa, invertendo verticalmente o gradiente antes de usá-lo na imagem.

  magick -size 1x33 gradient:wheat-brown gradient:Brown-LawnGreen \
          gradient:DodgerBlue-Navy   -append  gradient_planet.png
  magick gray_image.jpg \
          \( gradient_planet.png -flip \) -clut   gray_planet.jpg

Como você pode ver, para um gradiente vertical, invertê-lo antes de usar faz muito sentido. Para mais exemplos de geração de gradientes, veja Gradientes de Cor. Você também pode se interessar por uma forma de ladrilhar imagens em tons de cinza usando uma imagem para cada nível de cinza, o que pode produzir imagens ainda melhores no estilo 'mapa'. Veja Pontilhamento com Padrões.

Conversão de Função para Color LUT

Estas "Imagens de Tabela de Consulta" (ou LUT) pré-preparadas também podem ser usadas para aumentar muito a velocidade de operações "[-fx](https://imagemagick.org/command-line-options/#fx)" muito complexas e, portanto, lentas. Assim, em vez de o IM interpretar a string funcional 3 ou 4 vezes por pixel, ele pode fazer uma consulta muito mais rápida da cor de substituição. O procedimento para isso é bastante simples: aplique a função a um gradiente linear não modificado, ou substitua o 'u' na função pelo valor '(i/w)' ou '(j/h)' para calcular o valor de substituição com base em sua posição. Por exemplo, no exemplo avançado de Efeitos 'Aqua', usei uma função "[-fx](https://imagemagick.org/command-line-options/#fx)" complexa para ajustar a saída em tons de cinza do operador Shade". Além disso, como esse ajuste em tons de cinza também é sobreposto a uma forma 'DodgerBlue', não há razão para que os resultados desses dois operadores não pudessem ser combinados em uma única tabela de consulta de gradiente. Ou seja, geramos uma LUT a partir da fórmula "[-fx](https://imagemagick.org/command-line-options/#fx)" e da sobreposição de cor. Também, para estes exemplos, decidi gerar uma única linha de pixels em vez de uma coluna, como fiz anteriormente.

  magick -size 1x512 gradient: -rotate 90 -alpha off \
          -fx '3.5u^3 - 5.05u^2 + 2.05u + 0.3' \
          -size 512x1 xc:DodgerBlue -compose Overlay -composite \
          aqua_gradient.png

| O polinômio "[-fx](https://imagemagick.org/command-line-options/#fx)" acima pode agora ser gerado de forma mais direta e rápida usando uma Função Polinomial. Por exemplo

_"[-function](https://imagemagick.org/command-line-options/#function) Polynomial 3.5,-5.05,2.05,0.3"_

---|---
Essa LUT pré-gerada pode agora ser aplicada à forma sombreada de maneira muito mais rápida, ao custo mínimo de armazenar uma imagem muito pequena.

  magick -font Candice -pointsize 72 -background None label:A \
          -trim +repage  aqua_mask.png
  magick aqua_mask.png -alpha Extract -blur 0x6 -shade 120x21 \
          -alpha On -normalize  aqua_shade.png
  magick aqua_shade.png  aqua_gradient.png -clut aqua_font.png

AVISO: o acima está incompleto (as bordas não foram escurecidas)

Como você pode ver, o resultado é muito eficaz e, uma vez gerado um gradiente LUT apropriado, você pode reutilizar o mesmo gradiente indefinidamente, quantas vezes quiser.

CLUT e Tratamento de Transparência

O operador "[-clut](https://imagemagick.org/command-line-options/#clut)" é controlado pela configuração "[-channel](https://imagemagick.org/command-line-options/#channel)", mas, na verdade, ele apenas substitui os valores de canal individuais dentro da imagem. Isso significa que, normalmente, cada canal individual da imagem de origem é usado para 'consultar' o valor de substituição apenas daquele canal na tabela de consulta de cor. Isso inclui o canal alfa, o que geralmente é muito inconveniente e difícil de aplicar. Tipicamente, o operador "[-clut](https://imagemagick.org/command-line-options/#clut)" é usado ou para colorir uma imagem de origem em tons de cinza (veja os exemplos anteriores), OU para fazer um ajuste de histograma de uma imagem colorida usando uma CLUT (Tabela de Consulta de Cor) em tons de cinza. Em outras palavras, normalmente uma das imagens costuma estar em tons de cinza. A partir do IM v6.4.9-8, se uma configuração "[-channel](https://imagemagick.org/command-line-options/#channel)" especifica que você quer substituir/ajustar o canal alfa de uma imagem (um 'A' está presente), e a imagem de 'origem' ou a imagem 'CLUT' não tem canal alfa definido, então o IM assumirá que essa imagem está em tons de cinza e agirá de acordo. Por exemplo, aqui eu gero um triângulo simples e desfocado, como uma imagem em tons de cinza. Posso então colori-lo usando uma Tabela de Consulta de Cor que inclui transparência. Desta vez, não inverti a imagem CLUT, então a substituição do preto ficará no topo e a substituição do branco na parte inferior.

  magick -size 100x100 xc:  -draw 'polygon 50,10 10,80 90,80' \
          -blur 0x10  blurred_shape.jpg
  magick -size 1x5 xc:none \
          -draw 'fill red    point 0,2' \
          -draw 'fill yellow rectangle 0,0 0,1'   gradient_border.png
  magick blurred_shape.jpg -alpha off    gradient_border.png \
          -channel RGBA  -interpolate integer -clut  clut_shape.png

Lembre-se de que o acima só funcionará como esperado se a imagem em tons de cinza não tiver canal alfa (desativado usando "[-alpha](https://imagemagick.org/command-line-options/#alpha) off" ou "[-alpha off](https://imagemagick.org/command-line-options/#matte)"), e você especificar que também quer consultar os valores do canal alfa (usando "[-channel](https://imagemagick.org/command-line-options/#channel) RGBA"). E aqui está o outro caso especial, em que temos uma imagem com transparência (e canal alfa) que precisa ser ajustada usando um gradiente de ajuste de histograma em tons de cinza (sem canal alfa habilitado).

  magick -size 100x100 xc:none -draw 'polygon 50,10 10,80 90,80' \
          tile_disks.jpg -compose In -composite shape_triangle.gif
  magick shape_triangle.gif -channel A -blur 0x10 +channel shape_blurred.png
  magick -size 1x50 gradient: xc:black -append -flip \
          -sigmoidal-contrast 6x0%  feather_histogram.jpg
  magick shape_blurred.png \( feather_histogram.jpg -alpha off \) \
          -channel A    -clut    shape_feathered.png

O acima é um problema típico de Suavização de Bordas de Imagem. O halo 'preto' na imagem intermediária é causado pela operação "[-blur](https://imagemagick.org/command-line-options/#blur)", que torna visíveis as áreas totalmente transparentes ao redor do triângulo. Como o totalmente transparente tem uma cor indefinida, o IM assume preto por padrão. A própria imagem CLUT foi projetada para garantir que qualquer pixel com menos de 50% de transparência seja tornado totalmente transparente, efetivamente tornando transparentes de novo as partes anteriormente totalmente transparentes da imagem. Para este exemplo, exagero o 'desfoque' inicial e depois supercorrijo o ajuste do canal alfa. O resultado é um arredondamento severo das pontas do triângulo. Para a suavização normal de bordas de imagem, você tipicamente usaria valores bem menores tanto para o "[-blur](https://imagemagick.org/command-line-options/#blur)" quanto para o ajuste de alfa com "[-sigmoidal-contrast](https://imagemagick.org/command-line-options/#sigmoidal-contrast)". Fred Weinhaus implementou uma técnica de suavização por desfoque em seu script "feather", para facilitar seu uso.

Tabelas de Consulta de Cor 3D Hald

A partir do IM v6.5.3-4, você também pode usar uma Tabela de Consulta de Cor 3D completa, que pode ser usada para substituir diretamente todas as cores de múltiplas imagens. Ou seja, em vez de apenas consultar o valor de cada canal de cor como uma entidade separada (como na CLUT acima), toda a cor é usada para consultar a nova cor. Porém, tabelas de cor 3D geralmente exigem formatos de arquivo especiais para armazenar corretamente o array 3D de valores de cor. No entanto, usando um arranjo especial de valores de cor, a tabela 3D pode ser armazenada em uma imagem 2D, conhecida como Hald Color LUT. Essa é apenas uma imagem normal e, portanto, QUALQUER bom formato de arquivo de imagem pode ser usado para salvar uma Hald Color LUT 3D. Para mais detalhes e exemplos de Imagens HALD, veja o site oficial Hald Images, Clut Technology. Para gerar uma tabela de cor 3D Hald, use o gerador de imagem 'HALD:{_level_}'. Por exemplo, aqui está uma pequena que ampliei para que você possa ver os pixels individuais...

  magick  hald:3    hald_3.png

A tabela contém um cubo de cor com um lado de '{_level_}2' cores, ou 9 cores. O cubo de cor completo contém '9 × 9 × 9' cores, dando um total de 729 cores, que são armazenadas em uma imagem cujo tamanho é a raiz quadrada desse número, ou 27x27 pixels. As cores são armazenadas de modo que as 9 primeiras cores (no canto superior esquerdo) formam um gradiente que vai do 'preto puro' ao 'vermelho puro'. A cada 9ª cor forma-se então um gradiente em 'verde', e a cada 81ª cor forma-se um gradiente de 'azul'. A última cor, no canto inferior direito, é 'branco puro'. Você pode pensar na imagem como um array 1D de pixels ainda mais simples, referenciado como um cubo de cor 3D, se isso ajudar a imaginá-la. Agora, esta é apenas uma pequena imagem HALD CLUT. Mais tipicamente, você usaria pelo menos uma Hald de nível 8 (o padrão), que contém um cubo de cor com 64 cores por lado, ou 64^3 = 262144 cores, e produz uma imagem de 512x512 pixels de tamanho, salva em uma imagem PNG de aproximadamente 10 Kbytes. Isso não é o total de todas as cores de 8 bits, mas é bastante bom. Para uma imagem HALD com todas as cores de 8 bits, você precisaria de uma versão de nível 16, produzindo uma imagem de 4096x4096. O que só prova que mesmo as imagens normais de câmeras digitais geralmente não conseguem conter todas as cores possíveis de 8 bits. No entanto, uma imagem Hald menor pode ser usada, pois o IM interpolará as 8 cores vizinhas da Hald para determinar a cor final da substituição por consulta. Ela simplesmente não será uma representação tão boa quanto a de uma versão maior. Imagens Hald maiores que 8 não são recomendadas e exigiriam imagens muito grandes, com pelo menos 16 bits de profundidade por valor para armazená-las.Agora, essas imagens hald geradas são as imagens CLUT 'identidade' ou 'sem efeito'. Ou seja, são os valores de cor normais que formam o cubo de cor 3D e, portanto, não produzirão nenhuma alteração na imagem. Por exemplo, vamos aplicar uma imagem Hald 'sem efeito', usando o operador "[-hald-clut](https://imagemagick.org/command-line-options/#hald-clut)"...

  magick rose:  hald_3.png -hald-clut   rose_hald_noop.png

Esta imagem é exatamente igual à original, e a imagem Hald não continha alterações. No entanto, ao modificar a imagem Hald, seja manualmente ou usando uma modificação de cor, você pode substituir as cores originais pelas cores modificadas. Por exemplo, aqui eu crio um esquema de cor de tom sépia mesclado...

  magick hald_3.png \( +clone -sepia-tone 60% \) -evaluate-sequence mean hald_sepia.png
  magick rose.png   hald_sepia.png -hald-clut   rose_hald_sepia.png

É claro que, se você pode aplicar uma modificação de cor específica a uma imagem Hald, também pode aplicá-la diretamente à imagem real. Mas agora você pode salvar suas modificações de cor para reutilizá-las, e aplicá-las quantas vezes quiser. Isso significa que você pode concentrar seu esforço na Hald e salvá-la para o futuro. Você também pode enviar ou baixar imagens Hald CLUT para outras pessoas e até para outros aplicativos. Você poderia até editar diretamente as cores em uma Hald, usando um editor de imagem como o "Gimp" ou o "Photoshop", ou, se salva como uma Imagem de Texto de Pixel Enumerado, usar um editor de texto simples! Tudo isso vale especialmente para modificações de cor muito complexas. Por favor, envie-me quaisquer imagens Hald CLUT que você tenha achado interessantes ou úteis, e eu as exemplificarei aqui. Você será creditado, aqui também!

Limitações da Hald CLUT

Ao contrário da consulta de gradiente 1-dimensional mais simples usando o Operador CLUT, você pode usar uma Hald CLUT para rotacionar cores. Por exemplo, trocar as cores vermelha e azul. É um método CLUT muito mais versátil. Porém, ele não é tão bom para fazer coisas mais simples, como colorir uma imagem em tons de cinza, ou fazer um ajuste de histograma dos valores de cor. Ele também pode substituir cores por valores transparentes, ou semitransparentes, salvando essas cores de substituição na imagem Hald CLUT. No entanto, essa consulta de substituição é apenas por cor. Você não pode usá-la para substituir cores transparentes de formas específicas. Afinal, não é um hipercubo de consulta de cor 4D!

Substituição de Cor usando Hald CLUT

Agora, como todo o valor de cor é usado para consultar a substituição de cor, você também poderia usar isso como um método para substituir diretamente todas as cores de uma imagem por alguma outra cor. Porém, como o IM atualmente faz uma consulta interpolada linear da Hald, você precisará definir a cor de substituição em todas as 8 células de cor vizinhas do cubo de cor 3D.

Em Construção

Isto precisa de mais trabalho, e pode exigir uma configuração de Consulta Hald 'do vizinho mais próximo' (digamos, usando -interpolate), em vez de uma consulta interpolada linear 3D, para funcionar melhor para substituição de cor específica. Além disso, alguma forma fácil de localizar cores específicas em uma Hald (vizinho mais próximo, ou os 8 vizinhos) facilitaria muito isso. Se você tiver ideias, sugestões, ou melhor ainda, pequenos exemplos, então por favor contribua enviando-os para mim, ou para os Fóruns de Discussão do IM. Outra ideia é que, se você tiver duas imagens, a original e a convertida, então deveria ser possível preencher uma imagem Hald CLUT a partir da comparação das duas imagens. Quando as cores imediatas tiverem sido preenchidas, o restante do cubo de cor deveria poder ser, ao menos aproximadamente, derivado por ajuste de curva das cores presentes. Ou seja, criar uma superfície de cor 4-D a partir das mudanças de cor descobertas. Quando concluída, você pode aplicar a Hald CLUT a qualquer outra imagem, de modo a fazer a mesma transformação de cor (em qualquer direção) em qualquer outra imagem.

Substituição Completa de Mapa de Cores

FUTURO: Substituir todas as cores de um mapa de cores por cores de outro mapa de cores. Sugestões sobre a melhor forma de fazer isso são bem-vindas, ou programadores para implementar alguma função de mapa de cores de imagem. Um método pode ser usar as ideias apresentadas em Pontilhamento com Símbolos. A melhor solução conhecida (mas longe de ideal) é atualmente fornecida por Fred Weinhaus em seu script "[mapcolors](http://www.fmwconcepts.com/imagemagick/mapcolors/index.php)". Esse script essencialmente mapeia cada cor uma de cada vez, mascarando os pixels envolvidos de uma imagem para uma nova imagem inicialmente em branco. Outra ideia é, de alguma forma, mapear uma substituição de cor tridimensional em uma Tabela de Cor HALD. Isso não apenas mapeará as cores especificadas, mas também remapeará as cores entre as cores especificadas de maneira lógica. Procura-se um gerador HALD.

Em Construção

Mais opções de cor ainda a serem examinadas em detalhe...

  -contrast
  -brightness-contrast

Ciclagem de Cores?
    -cycle     desloca o mapa de cores (para animações de fractais???)

Pontos de Cromaticidade de Cor???
   –white-point x,y
   –red-primary x,y
   –green-primary x,y
   –blue-primary x,y


Limiares  (após inversão)
  Especificamente  -white-threshold e -black-threshold