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

Exemplos de ImageMagick -- Noções Básicas de Cor e Canais

Exemplos de ImageMagick: Prefácio e Índice
O que é a Cor

Imagens raster, que é com o que o ImageMagick lida (em geral), basicamente consistem em um arranjo de pontos individuais ou pixels de cor. Modificar os pontos individuais e como eles são representados é o que veremos nesta seção. Na próxima seção veremos a modificação global mais geral das cores em uma imagem como um todo.

O que é a Cor?

Para realmente entender a cor, você precisa saber exatamente o que a cor é. No mundo físico a cor é na verdade uma ilusão. Vemos cores porque nossos olhos percebem o mundo físico de uma forma muito especial e limitada. Basicamente em nossos olhos temos sensores especiais para Vermelho, Verde, Azul, e um sensor menor e secundário para visão periférica e condições de pouca luz. Este último é o motivo pelo qual vemos apenas cores cinzas à noite. Diagrama IM Para mais informações veja Wikipedia, Células Cone, o gráfico à direita que é a resposta de um olho humano típico a diferentes comprimentos de onda de luz. Por causa disso só percebemos o mundo em termos de comprimentos de onda eletromagnéticos Vermelho, Verde e Azul, e é por isso que imagens e processamento de imagens geralmente giram em torno de Vermelho, Verde e Azul, ou RGB. No entanto não é tão simples assim. Cada um dos nossos sensores de cor na verdade responde a uma faixa de comprimentos de onda. Por exemplo, quando vemos uma luz amarela, na verdade percebemos a luz usando tanto os sensores vermelho quanto verde. Se nossos sensores de cor fossem estritamente detectores puros de vermelho e verde, não veríamos nenhuma cor amarela. Arcos-íris na verdade mostrariam 'lacunas' neles. Isso significa que uma TV ou tela de computador na verdade nos engana fazendo-nos ver amarelo ao emitir exatamente a mistura certa de luz vermelha e verde, em vez de luz amarela real. Nossos sensores de cor percebem a mesma intensidade que perceberiam para uma luz amarela pura, e como resultado vemos amarelo, mesmo que na realidade estejamos vendo duas frequências de cor diferentes. Simplesmente não conseguimos distinguir entre um amarelo puro e uma mistura de luz vermelha e verde. De forma semelhante, as cores azul-vermelho (roxo) na verdade não existem como um único comprimento de onda específico, mas apenas como uma mistura de pelo menos duas frequências de cor, embora estritamente falando o violeta seja uma frequência específica à qual reagimos, principalmente pelo azul, e muito ligeiramente pelos outros dois sensores. Note que na verdade temos um quarto sensor de visão, mas ele não é de cor, e sim um detector de pouca luz, usado para visão noturna, quando os sensores cone já não funcionam muito bem. É por isso que o período noturno parece monocromático, e o luar é todo em tons de cinza. Esse sensor provavelmente também é a razão pela qual o espaço de cor sRGB (veja abaixo) tem um estranho componente linear para cores muito escuras nele. À PARTE: Outros animais têm sensores diferentes dos nossos. Abelhas e a maioria dos outros insetos têm sensores para ultravioleta, então para eles nossas imagens impressas, TVs e outdoors provavelmente fariam muito pouco sentido. Muito provavelmente essas imagens artificiais pareceriam mais uma imagem de falsa cor bastante horrível do que a cor quase perfeita que nós, humanos, somos enganados a ver. Alguns animais têm 4 sensores de cor, enquanto outros têm apenas um (preto e branco) ou dois. Além disso, alguns animais enxergam movimento muito melhor do que qualquer cor específica. Um touro, por exemplo, não consegue ver o vermelho, mas sim comprimentos de onda azul-violeta e verde; porém uma capa esvoaçante apareceria como um clarão de uma cor de 'movimento'. Para um touro, o ciclo de atualização de 50/60Hz de um monitor provavelmente pareceria um clarão de 'movimento' em vez de qualquer tipo de imagem sensata! Para mais informações veja Wikipedia, Visão de Cor e Wikipedia, Cor.

Espaço de Cor RGB, e Canais

Então o espaço de cor RGB é na verdade uma forma de representar imagens usando três valores: Vermelho, Verde e Azul, que nos enganam fazendo-nos pensar que estamos vendo algo no mundo real. As imagens podem assim ser armazenadas como 3 arranjos de valores, com cada um dos três valores formando um único pixel, ou ponto de cor, a ser exibido. Cada um dos três arranjos de valores é conhecido como um canal, que é simplesmente uma imagem em tons de cinza representando a quantidade de luz a ser criada para apenas um dos nossos sensores de cor. Por exemplo, aqui estão os componentes vermelho, verde e azul de uma imagem de rosa. [Saída IM]
Rosa | | [Saída IM]
Vermelho | [Saída IM]
Verde | [Saída IM]
Azul
---|---|---|---|---
Note como a imagem 'Vermelho' é muito mais brilhante para exibir uma rosa do que os outros dois componentes de cor. Mas todas as três imagens são brilhantes para o pedaço branco perto da parte inferior. RGB são Cores Aditivas Agora, as cores Vermelho, Verde e Azul são chamadas de cores 'aditivas'. Ou seja, as cores são somadas para formar a imagem de cor final. Isso ocorre porque essas são as cores dominantes que nossos olhos veem, e ao combiná-las podemos efetivamente gerar quase todas as cores que nossos olhos conseguem ver. Elas são aditivas no sentido de que, partindo do preto, como um monitor em branco, você então adiciona luz vermelha, verde e azul para gerar as cores apropriadas para a imagem que vemos. A chave para isso é que você começa com o preto, ou a ausência de luz, e então adiciona quantidades apropriadas de vermelho, verde e azul. Você também pode obter o mesmo efeito iluminando com três lanternas com celofane vermelho, verde e azul colado nas extremidades, em uma sala escura. Quando as três cores incidem no mesmo ponto, digamos em uma parede branca, vemos branco. É por causa de como nossos olhos realmente veem essas cores 'primárias' que as imagens coloridas são geralmente expressas em termos de valores RGB, que também são chamados de 'canais de cor'.

Espaço de cor CMY

Quando você está imprimindo, tem um problema diferente. Um pedaço de papel não pode gerar luz, apenas refleti-la. Por isso você precisa começar com uma superfície que reflita toda a luz que a atinge, em todas as direções. Ou seja, o que é uma superfície branca. Esperançosamente a luz que ela está refletindo é, ela própria, uma luz branca pura, seja do sol entrando pela janela, seja gerada pelas lâmpadas dos nossos ambientes iluminados artificialmente. Agora, para criar uma imagem naquele papel, você precisa aplicar tinta naquela superfície, o que na verdade remove comprimentos de onda específicos de luz. Como nós 'percebemos' as cores vermelho, verde e azul, essas são as cores que queremos remover seletivamente da luz refletida por aquele pedaço de papel branco. Consequentemente usamos uma tinta ciano para remover a luz vermelha, magenta para remover a luz verde, e amarela para remover a luz azul. A quantidade de tinta Ciano, Magenta e Amarela necessária para gerar uma cor específica produz o que é chamado de espaço de cor CMY. Aqui eu gero as máscaras de tinta necessárias para gerar uma imagem de rosa usando apenas tintas ciano, magenta e amarela (supondo que as tintas sejam 'lineares') [Saída IM]
Rosa | | [Saída IM]
Ciano | [Saída IM]
Magenta | [Saída IM]
Amarelo
---|---|---|---|---
Ou seja, quanto mais brilhantes os valores da máscara ciano, mais tinta ciano será necessária para remover mais do vermelho. Em outras palavras, uma máscara ciano é o exato negativo da quantidade de luz vermelha que queremos que o papel reflita. Na verdade, todas as três imagens de canal acima são o exato negativo do que foi gerado para o espaço de cor RGB. Então, na verdade, para magick uma imagem RGB em uma imagem CMK, tudo o que você precisa fazer é Negar a Imagem e então declarar que a imagem está no espaço de cor CMY. Como estamos removendo comprimentos de onda seletivamente, Ciano, Magenta e Amarelo são conhecidas como 'cores subtrativas'.

Espaço de cor CMYK

O grande problema de remover comprimentos de onda seletivamente é que apenas remover toda a luz vermelha, verde e azul, aplicando todas as três tintas ciano, magenta e amarela, na verdade não remove toda a luz que está sendo refletida. Como resultado, você ficará não com uma cor preta, mas com uma horrível cor marrom enlameada. As tintas (ou filtros de luz) não são perfeitas, assim como nossos próprios olhos não são perfeitos. Como mencionei antes, cada um dos nossos sensores de cor não enxerga apenas um comprimento de onda de luz, mas uma faixa de comprimentos de onda que interpretamos como sendo 'vermelho', 'verde' ou 'azul' (ou uma mistura dessas cores). Tanto que nosso sensor de luz 'azul' na verdade consegue ver (embora não muito bem) um pouco de ultravioleta. À PARTE: o filtro de uma 'luz negra' é propositalmente imperfeito, de modo que possamos 'mal ver' a luz dessa lâmpada, para sabermos se ela está ligada ou não. É por causa desse 'vazamento' de cor das tintas CMY, e dos nossos próprios olhos imperfeitos, que também adicionamos uma tinta preta pura à mistura, permitindo que ela seja usada para eliminar TODA a luz que poderia ser refletida do papel. Para evitar que seja confundida com o azul (Blue), a tinta ou canal preto recebe a letra K. Assim, para impressão usamos quatro tintas coloridas: Ciano, Magenta, Amarelo e preto (blacK); e definimos imagens usando essas tintas, para formar um espaço de cor CMYK. Por exemplo, aqui estão os componentes CMYK apropriados separados desta imagem. [Saída IM]
Rosa | | [Saída IM]
Ciano | [Saída IM]
Magenta | [Saída IM]
Amarelo | [Saída IM]
preto (blacK)
---|---|---|---|---|---
Note como a quantidade de ciano, magenta e amarelo foi reduzida e agora está mais escura do que no espaço de cor CMY, pois seu uso foi substituído por uma quantidade apropriada de preto. Ou seja, quando todas as três tintas estão presentes para um determinado pixel, o preto é usado no lugar. Assim, para imprimir, digamos, preto puro, você usa apenas tinta preta pura, e nenhuma outra tinta. Lembre-se de que o 'blacK' acima é a quantidade de tinta preta a aplicar em um pedaço de papel, então quanto mais brilhante a imagem do canal em tons de cinza, mais tinta preta deve ser usada. Por isso ela também é uma imagem de aparência negativa, assim como as outras três imagens. Claro que adicionar um preto puro em uma impressora colorida torna a impressão de texto preto muito mais simples, pois você não precisa mais imprimir três tintas diferentes, sobrepostas perfeitamente no mesmo ponto, para gerar linhas, letras e formas pretas puras. Isso significa muito menos tinta, com o papel ficando menos 'molhado' e menos propenso a borrar ou manchar, o que é especialmente bom para impressoras. Para outra discussão semelhante sobre como funcionam as cores RGB e CMYK veja a página de introdução de. XaraXone Workbook, Defining Color.

Outros Espaços de Cor

Outros espaços de cor são apenas outras formas de representar essas mesmas cores, ou algumas das outras além do estrito RGB que nossos olhos imperfeitos também conseguem distinguir. No entanto, esses espaços de cor têm pouca relação com a exibição dessas cores em um monitor ou com a impressão. Eles basicamente representam outras formas de manipular e/ou processar as cores de uma imagem, de modo a realçar ou destacar coisas específicas como...

  • Melhor tratamento não-linear de Cores Escuras (sRGB)
  • Arco-íris e matizes de cor (espaços de cor HSB,HSL,HSI,OTHA - intensidade não preservada)
  • Definição padronizada de cores (XYZ)
  • Diferenças de Cor Precisas ou Perceptuais (espaços de cor LAB e LUV, e seus equivalentes cíclicos de matiz LCHab e LCHuv)
  • Faixas de Alta Dinâmica Expandidas (para uso com imagens HDRI) (scRGB)
  • Melhor compressão dos valores de cor (como em YIQ e YUV)
  • Transmissão para TVs (YCbCr, YPbPr, onde Y = sinal P&B)

Um último espaço de cor que ainda não mencionei é 'Tons de Cinza' (GrayScale), mas esse é apenas um simples arranjo único de valores de pixel. Como você interpreta esses valores é variável, pois eles poderiam representar muitas coisas diferentes. Tipicamente, tal imagem é considerada Tons-de-Cinza-Linear e semelhante ao RGB linear (em oposição ao sRGB não-linear). O IM versão 6 na verdade não possui esse espaço de cor de tons de cinza, e apenas o simula com o espaço de cor RGB linear, definindo todos os valores RGB como o mesmo valor. Se os três valores não forem iguais, a imagem já não é mais de tons de cinza. No IM versão 7, Tons de Cinza é uma imagem de canal único (uso de memória muito menor). | _As mudanças acima no 'colorspace' de uma imagem são apenas um arranjo grosseiro das cores de uma imagem na memória. Elas também fornecem conversões de cor muito básicas (simplistas) entre diferentes espaços de cor.

Para especificações e conversões de cor exatas, Perfis de Cor devem ser usados em vez disso, mas isso só funciona ao usar formatos de arquivo de imagem que possam lidar com perfis de cor.

_
---|---

Correção de Gama e Espaço de Cor sRGB

Percepção Humana de Cor

Acima vimos que você pode representar imagens de muitas maneiras diferentes. Todos os espaços de cor que vimos acima são conhecidos como espaços de cor 'lineares', o que significa que o valor real usado representa os valores reais de 'intensidade' da cor em uma imagem. No entanto, a vida real nunca é tão simples. Nunca é! Por exemplo, vamos gerar e salvar uma imagem com uma sequência linear simples de valores de cinza... | 

  magick -size 100x100 gradient:'gray(100%)-gray(0)' \
          -set colorspace sRGB gradient.gif

[Saída IM]
Notas...

  • O uso de "gradient:'gray(100%)-gray(0)'" garante que o IM gere um gradiente de dados RGB lineares, que estará no espaço de cor RGB linear.
  • O "-set colorspace sRGB" diz ao IM que esse gradiente 'linear' está na verdade em "sRGB" e, portanto, não precisa de 'correção' ao ser salvo em um formato de arquivo GIF que só pode armazenar valores no espaço de cor sRGB.

Agora, os valores de cor reais usados nesta imagem formam um gradiente linear que deveria mudar suavemente de branco no topo para preto na parte inferior, com um cinza 50% matematicamente exato e perfeito no meio. No entanto, se você olhar a imagem, verá que ela na verdade parece conter muito mais cores escuras (quase pretas) do que cores claras (quase brancas). Por quê? Bem, a visão humana, quando recebe uma intensidade de luz que é apenas metade de sua faixa máxima ('branco'), não vê o cinza médio puro que o valor de cor indica, mas uma cor muito mais escura. Como resultado, o gradiente linear acima não parece uma distribuição linear uniforme de cores do branco ao preto, mas tem muito mais cores escuras do que deveria. A relação entre o valor real da imagem e o valor percebido é aproximadamente uma 'função de potência' da forma...

**_cinza_percebido_ = _valor_ 2.2**

O valor '2.2' é o valor médio da função gama, típico da maioria dos seres humanos.

Correção de Gama

A Correção de Gama é uma forma de ajustar os valores de cor que são realmente salvos, de modo que a imagem final pareça muito mais uniforme em sua distribuição de cores. Basicamente, enquanto a visão humana faz a luz parecer mais escura usando um fator de potência de 2.2, para fazer uma imagem linear 'parecer' linear precisamos reverter essa função de potência, usando um valor de 1/2.2. Ou seja, para fazer uma imagem parecer linear, precisamos corrigi-la usando a seguinte fórmula...

**_valor_corrigido_por_gama_ = _valor_ 1/2.2**

O IM fornece correção de Gama tanto através do Operador Level, Argumento Gamma, quanto, mais especificamente, usando o Operador Gamma. No entanto, você também pode modificar diretamente os valores da imagem usando a função POW de Evaluate.

Então vamos aplicá-la e ver o resultado de uma 'imagem corrigida por gama'.. | 

  magick -size 100x100 gradient:'gray(100%)-gray(0)' -gamma 2.2 \
          -set colorspace sRGB gradient_gamma.gif

[Saída IM]
Note como a imagem agora tem quantidades muito mais iguais de cores claras e escuras. No entanto, os valores reais dentro da imagem já não são mais 'lineares', o que pode causar problemas ao processar essa imagem mais tarde. A correção de gama é apenas um método 'rápido' e aproximado de ajustar as cores para fazer uma imagem 'parecer' correta. Não é o método usual nem mesmo o melhor método de corrigir uma imagem para a resposta humana. Para exemplos mais específicos de correção de gama para processamento de imagens veja Redimensionar com Correção de Gama Para mais informações sobre Correção de Gama veja

Você também pode querer dar uma olhada no operador "[-auto-gamma](https://imagemagick.org/command-line-options/#auto-gamma)", que tenta ajustar a gama para produzir uma imagem RGB linear, com quantidades iguais de claro e escuro (no espaço linear).

A Gama do seu Monitor

Afaste-se alguns metros (jardas) do seu monitor e olhe para a imagem à esquerda. Se o seu monitor (e navegador web) estiver exibindo a imagem sRGB corretamente, o ponto onde o padrão central em 'hachura' tem brilho aproximadamente igual ao gradiente sRGB ao redor deve estar bem no meio. A maioria dos monitores de computador falha neste teste! No entanto, TVs HDMI deveriam sair perfeitas. A imagem foi criada usando... | 

  magick -size 45x256 gradient: -size 10x256 pattern:gray50 \
          -duplicate 1,0 +append -set colorspace sRGB -colorspace RGB \
          monitor_sRGB.png

[Saída IM]
Aqui estão algumas imagens semelhantes com diferentes níveis de 'gama' para que você possa ver o quão perto seu monitor está de uma exibição de gama '2.2' correta para a percepção humana. 

  for gamma in 1.6 1.8 2.0 2.2 2.4
  do
    magick -size 45x256 gradient: -size 10x256 pattern:gray50 \
            -duplicate 1,0 +append -gamma $gamma monitor_g$gamma.png
  done

[Saída IM]
Gama 1.6 | [Saída IM]
Gama 1.8 | [Saída IM]
Gama 2.0 | [Saída IM]
Gama 2.2 | [Saída IM]
Gama 2.4
---|---|---|---|---

A imagem em que (ao se afastar) o ponto de brilho igual fica em torno da marca de 50% indica o nível de gama aproximado do seu monitor. Se ajustado corretamente, seu monitor deve ter um nível de gama de 2.2, que corresponde muito de perto ao do espaço de cor sRGB. Quando escrevi isto, minha antiga tela (fornecida pelo trabalho) era extremamente ruim. Tinha uma configuração de Gama de cerca de 1.8, e na verdade tinha uma Gama diferente no topo da tela (mais escura) do que na parte inferior (mais clara). Algo que me causou problemas ao comparar imagens em locais diferentes da tela, pois a mesma imagem parece diferente quando colocada em posições verticais diferentes! Por outro lado, meu laptop pessoal (na época) tinha uma tela muito uniforme, com uma razoável configuração de gama 2.0 segundo o teste acima.

Correção de Espaço de Cor sRGB

Salvar uma imagem usando um espaço de cor sRGB é muito semelhante a corrigir uma imagem por gama, mas é um pouco mais complicado de modo a reproduzir melhor a resposta real do olho humano, especificamente com tonalidades de cor muito escuras. Então vamos salvar nosso gradiente linear em um espaço de cor corrigido sRGB. | 

  magick -size 100x100 gradient:'gray(100%)-gray(0)' \
          -set colorspace RGB -colorspace sRGB    gradient_sRGB.gif

[Saída IM]
| A partir do IM v6.7.7 o comando acima é simplificado para apenas | 

  magick -size 100x100 gradient:white-black gradient_sRGB.gif

_Isso ocorre porque o gradiente linear será sempre gerado em um espaço de cor linear (RGB) (que é a única forma sensata para o operador funcionar).

No entanto, como cores sRGB 'white-black' estão sendo solicitadas, o gradiente de dados lineares será automaticamente convertido para o espaço de cor sRGB, produzindo valores de dados não-lineares e um gradiente perceptualmente linear.


| _Antes da versão 6.7.5 do IM, o comando acima teria falhado pois o IM tinha os significados dos espaços de cor 'sRGB' e 'RGB' invertidos. Por isso, em versões mais antigas do IM, os dois nomes de espaço de cor precisavam ser trocados. Por exemplo... | 

  magick -size 100x100 gradient: -set colorspace sRGB \
          -colorspace RGB gradient_sRGB.gif

_Essa estranheza no tratamento do espaço de cor foi considerada por muito tempo um bug do IMv7, e, embora estivesse previsto para ser corrigido apenas no IMv7, foi retroportada para o IMv7.


Note que o exemplo acima (ou qualquer outro gradiente) não é perfeito, pois a perfeição é simplesmente impossível: cada um vê as coisas à sua própria maneira, com pequenas diferenças. Em resumo: _o que você vê nunca é exatamente o que as outras pessoas veem (é na verdade muito Zen). Tudo o que o sRGB é, é uma aproximação muito boa para a maioria das pessoas, segundo numerosas pesquisas, e muitos especialistas em impressão/tinta/cor. Para detalhes da fórmula exata do sRGB veja Wikipedia, Espaço de Cor sRGB. Uma 'resposta de luminância humana' mais completa e acurada foi desenvolvida, e pode ser vista on-line na tese Visão Humana, Diferença Mínima Perceptível. Isso inclui a resposta adaptativa em situações de grandes mudanças de iluminação. A World Wide Web padronizou o uso do sRGB como o espaço de cor padrão recomendado (e ainda razoavelmente simples), e ele deve, portanto, ser usado para todas as imagens que não contenham nenhuma informação de perfil de espaço de cor. Ou seja, para imagens como GIF, PNG, JPEG e TIFF. Todos esses formatos (exceto GIF) permitem o uso de Perfis de Cor para especificar definitivamente o espaço de cor da imagem. No entanto, formatos de arquivo de imagem como PbmPlus tipicamente não são considerados como estando no espaço de cor sRGB. Por isso, ao trabalhar com esses formatos de arquivo, geralmente é uma boa ideia usar "-set colorspace ..." para garantir que o espaço de cor seja como você espera. E aqui estão as três imagens juntas para que você possa compará-las. [Saída IM]
Linear | [Saída IM]
Gama | [Saída IM]
sRGB
---|---|---
Como você pode ver, as imagens corrigidas por Gama e por sRGB são quase idênticas, e a diferença, quando representada graficamente, é na verdade extremamente pequena. Assim, embora usar sRGB seja o método mais correto, usar Correção de Gama é provavelmente mais fácil de aplicar. As maiores diferenças entre a imagem sRGB e a Gama estão em imagens extremamente escuras. Para um valor de Cinza de 8 bits igual a 1, o sRGB é 60 vezes mais brilhante que o equivalente em Gama. Um valor de 8 é 5 vezes mais brilhante. Isso não fará nenhuma diferença perceptível na maioria dos casos, mas pode fazer quando uma imagem muito escura é manipulada.

Processando Imagens Reais

A maioria dos operadores de processamento de imagens não se importa com qual espaço de cor uma imagem está usando; eles simplesmente aplicam suas operações aos dados do canal, independentemente de seu espaço de cor. Embora alguns tenham que fazer um esforço especial para lidar com os dados extras de canal para o 'Preto' e, como você verá mais adiante, para o 'Alfa' (ou transparência 'Alfa'). No entanto, o espaço de cor de uma imagem pode influenciar muito o resultado final de muitas operações. Por isso, fazer processamento de imagens em um espaço de cor diferente pode gerar resultados melhores. Este exemplo mostra mais claramente por que processar em sRGB não é uma boa ideia. A partir de uma discussão sobre Borrões de Cor e 'Cores Quebradas', no Fórum de Usuários do IM. Pegamos duas cores usando canais de cor diferentes e as borramos juntas de modo que, dentro do canal, a cor seja borrada até zero (um valor de cor baixo). Primeiro vamos fazer isso usando o canal de entrada padrão sRGB. | 

  magick -size 40x80 xc:red xc:lime +append \
          -blur 0x20 blur_sRGB.png

[Saída IM]
Se você olhar os resultados, parece que as cores estão se borrando do vermelho através do preto e depois para o verde. Ou seja, porque, para nossos olhos, os valores parecem mais escuros do que deveriam no espaço de cor sRGB. Aqui eu borro a mesma imagem novamente, mas usando um espaço de cor RGB linear. | 

  magick -size 40x80 xc:red xc:lime +append \
          -colorspace RGB -blur 0x20 -colorspace sRGB blur_RGB.png

[Saída IM]
Como você pode ver, desta vez obtemos um resultado muito mais sensato, com as cores vermelha e verde se borrando através do laranja. Você também obtém resultados semelhantes usando outros espaços de cor lineares como LAB ou LUV, que veremos com mais detalhe abaixo. Basicamente, ao processar imagens que envolvam mistura de cores, por exemplo em operações como Quantização de Cor (redução de cor), mas também em Redimensionamento de Imagens e, mais geralmente, em Distorção de Imagens, você deve processar as imagens em um espaço de cor linear para resultados mais precisos, embora, na realidade, poucas pessoas façam isso. | _Helmut Dersch (famoso pela Distorção de Barril e pela Correção de Lente) recomenda que você considere usar o espaço de cor linear 'LAB' para processar imagens, especialmente para redimensionamento e distorções de imagens.

Eu só recomendo que você mude do espaço de cor 'de entrada' sRGB para algum outro espaço de cor 'linear' ao fazer desenho, composições, redimensionamento ou distorções de imagens. Se isso é RGB linear, LAB ou LUV não deveria importar tanto.

_
---|---
Aqui, por exemplo, estão borrões de vermelho-azul nos 3 principais espaços de cor lineares. Escolhi essas cores porque parecem mostrar a maior diferença nas cores intermediárias geradas. 

  for colorspace in RGB LUV LAB
  do
    magick -size 80x40 xc:red xc:blue -append \
            -colorspace $colorspace -blur 0x30 -colorspace sRGB \
            colorspace_$colorspace.png
  done

[Saída IM]
RGB | [Saída IM]
LUV | [Saída IM]
LAB
---|---|---

Para mais exemplos de processamento de imagens com relação ao espaço de cor veja Redimensionando com Correção de Espaço de Cor. Veja também os avisos sobre nomes de cor e desenho em espaço de cor linear, em Desenhando com Correção de Gama e Espaço de Cor

Especificação de Cor

As cores no IM podem ser especificadas de muitas maneiras. O melhor guia sobre isso está no site oficial do IM Color Names.

Cores por Nome

Muitas cores receberam nomes específicos, o que as torna mais fáceis de usar. Por exemplo, "RoyalBlue" é uma cor azul levemente desviada muito bonita e brilhante. [Saída IM] À direita está uma imagem contendo todas as cores nomeadas, incluindo as com números, que estão disponíveis no ImageMagick. As cores foram primeiro classificadas em 3 grupos: Off-Whites (quase brancos), Mid-Tones (tons médios) e Dark Colors (cores escuras), e então plotadas em três rodas de cores HSL separadas, cada uma com um deslocamento vertical diferente. As cores branco puro e preto aparecem como seus próprios pontos separados no topo e na base do gráfico, formando os extremos da faixa vertical. O script que o gerou é "[hsl_named_colors](../static/img/scripts/hsl_named_colors)" e segue uma técnica vista em Posicionamento Programado de Imagens em Camadas. | _Tecnicamente, como desenho as cores HSL na forma tridimensional de um 'bi-cone' em vez de um 'cilindro', o raio de cada ponto de cor foi definido como igual à 'Croma' da cor ('Saturação'/'Brilho'), em vez de apenas sua 'Saturação'. VejaWikipedia: HSL e HSV.

Para ser ainda mais correto, Pirâmides Hexagonais também deveriam ter sido usadas em vez de Cones, embora isso seja muito mais difícil de calcular, com pouco ganho.

_
---|---
Como você pode ver, há muitos nomes de cor associados ao vermelho até o amarelo e um grupo menor nas matizes do ciano ao verde. Com um agrupamento semelhante em amarelos e cianos quase brancos. Mas há pouco em termos de cores quase verdes nomeadas. Essencialmente, há algumas áreas do espaço de cor HSL que têm muito poucas cores nomeadas. Pode ser difícil encontrar um nome de cor específico para usar. Mas, ao carregar a imagem à direita no programa "[display](basics.html#display)" do IM, você pode usar o botão central do mouse para ver o nome da cor ImageMagick para a cor específica que foi plotada.

Nomes de Cor Especiais

Existem algumas cores especiais, que são usadas para fins especiais dentro do ImageMagick. 'None' ou 'Transparent' é uma cor preta totalmente transparente, e geralmente usada para especificar transparência de fundo, como ao criar uma Tela de Cor Sólida, ou ao usar Camadas de Imagem. 'Opaque' é apenas um alias para 'Black', e por isso raramente é usado. Ele é tipicamente usado apenas quando se quer dizer QUALQUER cor opaca, como ao fazer Processamento de Canal Alfa.

Conflitos de Nomes de Cor

Os nomes de cor podem vir de três fontes diferentes, SVG, X11 e XPM, e a maioria dos nomes produz a mesma cor independentemente da fonte de definição. Mas há alguns nomes de cor que produzem cores diferentes, dependendo da especificação de cor que está sendo usada. O maior problema é a cor SVG 'Green' (verde meio-brilhante) que é diferente da cor X11/XPM 'Green' (verde RGB puro). Se você quer um verde puro, é melhor usar o nome de cor SVG 'Lime', que não tem conflito. A Wikipedia tem um excelente artigo sobre os conflitos de nomes de cor, bem como uma boa tabela dos nomes de cor reais, em X11 color names. Você também pode querer dar uma olhada no artigo Web Colors, que fornece um conjunto de tabelas bem ordenadas de algumas faixas de cor. Os conflitos mais notáveis estão em quatro cores específicas. Aqui está uma tabela dos conflitos de nomes de cor conhecidos. Lembre-se de que a cor SVG é a que o IM usará por padrão. Conflito
Nome da Cor | Resultado SVG
(padrão do IM) | Resultado X11
para o Nome | Nome X11
Equivalente | Nome de Cor
Alternativo
---|---|---|---|---
Green | | #008000 | | #00FF00 | | | Lime
Maroon | | #800000 | | #B03060 | | FireBrick |
Purple | | #FF00FF | | #A020F0 | | Magenta |
Gray | | #7E7E7E | | #BEBEBE | | | Grey
Notas sobre o que está acima...

  • O X11 'Grey' é uma cor cinza médio visual. Também é muito próximo (mas não exatamente igual) da cor X11 'Gray74' e da cor SVG 'Silver' ('gray(192)').
  • O 'Gray' padrão (SVG) é muito próximo de um cinza matemático perfeito, que é melhor especificado usando os nomes de cor 'Gray50' ou 'gray(128)' (para uso de 8 bits).
  • Como todas as cores nomeadas são especificadas usando valores de 8 bits (0-255), nenhuma delas gerará uma cor cinza pura de 16 bits perfeita!
  • Quando um cinza é necessário para processamento matemático, como em Fase DC de FFT, Detecção de Bordas, Imagens Sombreadas, Efeitos de Iluminação de Composição e Mapas de Deslocamento Relativo, é muito melhor usar a fórmula de cor 'gray(50%)' que de fato gera um cinza de tom médio matemático perfeito em qualquer profundidade de bits de cor.

Recomenda-se cautela ao selecionar uma cor para um propósito específico.

Cores e Espaço de Cor

Embora muitas cores tenham nomes, a maioria das cores encontradas em imagens não tem; elas são apenas um conjunto de valores, geralmente 3, que especificam uma cor específica. No entanto, três valores por si só não definem totalmente uma cor; você também precisa especificar o 'espaço de cor' ou 'sistema de cor' ao qual esses valores pertencem. Todas as cores 'nomeadas' acima estão no espaço de cor sRGB, que é o espaço de cor no qual foram definidas. Mas às vezes você quer definir uma cor em um espaço de cor diferente. Por exemplo, em HSL, ou CYMK, ou até como uma cor XYZ. O ImageMagick pode fazer isso, e você pode ver os detalhes dessas especificações em ImageMagick Color Names. Futuro: Exemplos de uso de outros espaços de cor (ainda em desenvolvimento) | _Embora RGB no ImageMagick represente um espaço de cor RGB linear, é uma prática aceita que um nome de cor 'rgb(value,value,value)' esteja na verdade definindo uma cor sRGB.

Para de fato definir uma cor RGB linear em vez de uma cor sRGB, use a fórmula de cor 'icc-color(RGB,value,value,value)' (veja a seguir).
---|---
A partir do IM v6.7.8-3, você pode usar a função 'icc-color(colorspace,color...)' para definir uma cor, ou redefinir o espaço de cor de uma cor específica. _Futuro: Exemplos de uso

Cores Semitransparentes

Você pode especificar diretamente cores semitransparentes de apenas duas maneiras diferentes. O método mais comum de definir uma cor semitransparente é usar um valor hexadecimal. Por exemplo, aqui estão algumas especificações de cor mostrando vários níveis de transparência de cor. Exibi as imagens de cor geradas sobre um padrão de fundo para que você possa ver esse padrão através da transparência da imagem. 

  magick -size 50x50    xc:'#00FF00FF'   color_hex_1.png
  magick -size 50x50    xc:'#00FF00C0'   color_hex_2.png
  magick -size 50x50    xc:'#00FF0090'   color_hex_3.png
  magick -size 50x50    xc:'#00FF0060'   color_hex_4.png
  magick -size 50x50    xc:'#00FF0030'   color_hex_5.png
  magick -size 50x50    xc:'#00FF0000'   color_hex_6.png

[Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM]

| Antes do IM v6.3.0, o último conjunto de dígitos hexadecimais continha a transparência das cores na forma de um valor 'matte' ou 'opacity'. Ou seja, o hexadecimal final '00' representava 'opaco' e 'FF' era transparente.

No entanto, após o IM v6.3.0, esse valor foi invertido para representar um valor de transparência 'alfa', a fim de alinhar o IM aos padrões SVG e a outros pacotes gráficos. Em outras palavras, 'FF' agora representava totalmente-opaco e '00' é totalmente transparente.
---|---
Você também pode especificar cores usando a função de cor especial 'rgba()'. Onde os valores RGB vão de 0 a 255, e o canal alfa é especificado como uma fração decimal entre 0.0 (transparente) e 1.0 (opaco). 

  magick -size 50x50   xc:'rgba(255,0,0, 1.0)'   color_rgba_1.png
  magick -size 50x50   xc:'rgba(255,0,0, 0.8)'   color_rgba_2.png
  magick -size 50x50   xc:'rgba(255,0,0, 0.6)'   color_rgba_3.png
  magick -size 50x50   xc:'rgba(255,0,0, 0.4)'   color_rgba_4.png
  magick -size 50x50   xc:'rgba(255,0,0, 0.2)'   color_rgba_5.png
  magick -size 50x50   xc:'rgba(255,0,0, 0.0)'   color_rgba_6.png

[Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM]

| Antes da versão 6.2.7 do IM, o 'rgba()' também usava um valor matte para o valor do canal alfa. Ou seja, um valor de 0 para totalmente opaco e 255 para totalmente transparente. Isso foi alterado conforme definido pela "recomendação do W3C CSS3 Color Module para especificar cores", como parte do IM se tornar mais compatível com outros padrões de imagem, particularmente para uso na WWW e SVG.
---|---
Atualmente é impossível especificar diretamente uma cor semitransparente por nome, com uma configuração extra de valor alfa. No entanto, você pode improvisar gerando essa cor nomeada e depois modificando a transparência da imagem. Você também tem a complicação adicional de que deve Definir o Canal Alfa antes de poder de fato definir a transparência da cor. 

  magick -size 50x50   xc:RoyalBlue                   color_name_1.png
  magick -size 50x50   xc:RoyalBlue -alpha set \
                        -channel A -evaluate set 80%   color_name_2.png
  magick -size 50x50   xc:RoyalBlue -alpha set \
                        -channel A -evaluate set 60%   color_name_3.png
  magick -size 50x50   xc:RoyalBlue -alpha set \
                        -channel A -evaluate set 40%   color_name_4.png
  magick -size 50x50   xc:RoyalBlue -alpha set \
                        -channel A -evaluate set 20%   color_name_5.png
  magick -size 50x50   xc:RoyalBlue -alpha set \
                        -channel A -evaluate set  0    color_name_6.png

[Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM]

Sim, isso é um incômodo, e seria bom se a transparência pudesse ser definida como parte da especificação do nome da cor. Se você gostaria de ver isso, faça um pedido no Fórum de Desenvolvedores do IM. Também é possível desenhar uma cor de preenchimento nomeada usando Configurações de Desenho MVG, embora você precise de uma tela inicial transparente para que isso funcione corretamente. Por exemplo... | 

  magick -size 50x50 xc:none \
          -draw "fill Tomato fill-opacity 0.5 rectangle 0,0 49,49" \
          color_name_draw.png

| [Saída IM]

| Note que uma cor totalmente transparente, embora completamente invisível, ainda tem uma cor. No entanto, a maioria dos operadores do IM reconhece que qualquer cor que seja totalmente transparente é igual a qualquer outra cor totalmente transparente. Por causa disso e da forma como a matemática interna funciona, muitos operadores frequentemente substituem uma cor totalmente transparente por preto totalmente transparente (também conhecido como a cor especial 'none').
---|---

Canais de Cor

Os dados de cor reais de uma imagem são armazenados como arranjos de valores, conhecidos como canais. Tipicamente, uma imagem terá pelo menos 3 canais, representando valores de cor vermelho, verde e azul. Mas, como você viu acima, os valores armazenados poderiam representar outros espaços de cor.

Espaço de Cor e Nomeação de Canais

O propósito principal do operador "[-colorspace](https://imagemagick.org/command-line-options/#colorspace)" é mudar a forma como o IM armazena as cores de uma imagem na memória. Normalmente cada imagem tem 3 (ou 4) canais de dados de imagem. O 'espaço de cor' atual de uma imagem determina o que os dados de cada canal representam. Agora, normalmente os canais são nomeados 'Vermelho', 'Verde', 'Azul', pois esse é normalmente o tipo de dados de imagem armazenado nesses canais. No entanto, esse nem sempre é o caso. Não pense no canal 'R' ou 'Vermelho' como sendo vermelho, pense nele como 'canal 1', que poderia conter dados para 'vermelho', 'matiz', 'ciano' ou outras coisas dependendo do espaço de cor da imagem. 'Vermelho' é apenas um rótulo para o canal tipicamente usado para 'vermelho', ou o primeiro canal. O segundo espaço de cor mais comum usado é o 'CMYK', que define a quantidade de 'tinta' de cor que deve ser aplicada para escurecer um pedaço de papel 'branco' (um espaço de cor subtrativo). Note que K é abreviação de "blacK" (preto), que são os valores de intensidade negados da imagem. Como isso é muito comum, os canais 'RGB' também têm uma nomeação alternativa de 'Ciano', 'Magenta' e 'Amarelo', ou apenas as letras 'C', 'M' e 'Y', embora na realidade se refiram ao mesmo conjunto de canais usado para imagens 'RGB'. Um quarto canal de cor especial também é adicionado para o canal de cor 'Preto' ou 'K'. Isso basicamente significa que o canal de cor para "Green" na verdade se refere ao exato mesmo canal de cor que seria usado para "Magenta". Se os próprios dados são 'verde' ou 'magenta' depende NÃO do nome do canal, mas do 'espaço de cor' da imagem na memória. A mesma coisa acontece para outros espaços de cor. Por exemplo, usar um espaço de cor 'LAB' significa que o canal 'Vermelho' contém o valor de 'Luminosidade' (Lightness), enquanto o canal 'Verde' contém o valor 'A' (ou vermelho-verde), e o canal 'Azul' contém o valor 'B' (ou azul-amarelo).
De forma semelhante, os nomes de canal 'Alpha' ('A'), 'Opacity' ('O') e 'Matte' são todos aliases para a configuração "[-channel](https://imagemagick.org/command-line-options/#channel)" referindo-se à informação de transparência das imagens. Não importa que um canal 'alfa' seja o inverso de um canal 'matte'; ele ainda se refere ao mesmo canal e produz o mesmo resultado, o Canal Matte Interno da imagem. Se um operador trata os dados internos do canal alfa como 'alfa' ou valor depende do operador. Operadores de canal de baixo nível como "[-threshold](https://imagemagick.org/command-line-options/#threshold)" trabalham nos dados 'matte' brutos do canal na memória. No entanto, a maioria dos operadores de nível mais alto como "[-fx](https://imagemagick.org/command-line-options/#fx)" e "[-composite](https://imagemagick.org/command-line-options/#composite)" tratam esses dados como representando dados 'alfa', para fins de operação. Há ainda outro método de controlar o espaço de cor dos dados de imagem armazenados. O "[-set](https://imagemagick.org/command-line-options/#set) colorspace" (Adicionado no IM v6.4.3-7) mudará apenas a configuração de 'espaço de cor' em memória. Ou seja, ele pode magick uma imagem RGB em uma imagem HSL, mas sem mudar ou modificar os dados de pixel reais que a imagem está usando. O uso mais típico disso é quando você está manualmente Combinando Dados de Canal para definir qual é o espaço de cor final da imagem combinada.
Então vamos ver como podemos manipular canais de cor. Lembre-se de que cada canal é apenas um arranjo de valores. Todos os canais então se combinariam para representar a cor real de cada pixel dentro da imagem.

Separando Imagens de Canal

A maneira mais fácil de separar os canais de cor individuais é usar o operador "[-separate](https://imagemagick.org/command-line-options/#separate)" para extrair o conteúdo atual de cada canal como uma imagem em tons de cinza. 

  magick rose: -channel R -separate separate_red.gif
  magick rose: -channel G -separate separate_green.gif
  magick rose: -channel B -separate separate_blue.gif

[Saída IM] [Saída IM] [Saída IM] [Saída IM]

Note como a rosa vermelha é proeminente na imagem do canal vermelho, enquanto é bastante escura nos canais azul e verde. Por outro lado, as folhas verdes são proeminentes no canal verde, mas não nos outros. O branco perto da parte inferior da imagem é brilhante em todos os canais. No IM v5 e anteriores, "-channel" não era apenas uma configuração para operações de imagem posteriores, mas também, em algumas ocasiões, um 'operador de imagem' que convertia o canal especificado em uma imagem em tons de cinza. Muito confuso! No IM v6, o "-separate" foi criado para 'separar' essas duas tarefas muito diferentes. A opção "-channel" é apenas uma configuração usada por operações de imagem posteriores, enquanto "-separate" extrairá os canais especificados em imagens separadas em tons de cinza e totalmente opacas.
A partir do IM v6.2.9-3, o operador "-separate" permite separar múltiplos canais de cor de acordo com a configuração "-channel". O número de itens na configuração "-channel" determinará o número de imagens criadas (na ordem RGBA). Por exemplo, como a configuração padrão de "-channel" é 'RGB', a ação padrão é criar três imagens, que eu produzo abaixo. 
  magick rose: -separate separate_RGB_%d.gif

[Saída IM] [Saída IM] [Saída IM] [Saída IM]

E aqui usamos o operador "-colorspace" para magick a forma como o IM está armazenando os dados de cor da imagem em uma representação de cor CMYK. Em seguida, extraímos os quatro canais de cor envolvidos. 

  magick rose: -colorspace CMYK -separate separate_CMYK_%d.gif

[Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM]

A última imagem (o canal 'Black' ou 'K') é especialmente interessante, pois parece ser uma imagem em tons de cinza negada da imagem original. Na realidade, ela representa a quantidade de 'tinta' que uma impressora CMYK deve depositar no papel, reduzindo a quantidade de cor necessária pelos outros canais de cor. Note que, por padrão, a configuração "-channel" não inclui o especial Canal de Transparência Matte da imagem. Se você quiser sempre gerar todos os canais presentes, pode usar uma configuração de canal "-channel ALL", ou usar a configuração "-channel" 'RGBA' ou 'CMYKA'.

Canais em Tons de Cinza a partir de Representações de Espaço de Cor

Você pode extrair valores de canal específicos de espaços de cor para fins especiais. Por exemplo, aqui extraímos o brilho ou intensidade em tons de cinza da imagem da rosa, usando várias representações diferentes. 

  magick rose: -colorspace Gray                      channel_gray.gif
  magick rose: -grayscale Rec709Luma                 channel_luma709.gif
  magick rose: -grayscale Rec601Luma                 channel_luma601.gif
  magick rose: -colorspace HSI  -channel B -separate channel_average.gif
  magick rose: -colorspace HSL  -channel B -separate channel_lightness.gif
  magick rose: -colorspace HSB  -channel B -separate channel_brilliance.gif
  magick rose: -colorspace CMYK -channel K -negate -separate channel_black.gif
  magick rose: -colorspace LAB  -channel R -separate channel_lab_light.gif

[Saída IM]
Gray
Cinza | [Saída IM]
Rec709Luma
| [Saída IM]
Rec601Luma (Y)
YUV/YIQ | [Saída IM]
Média (I)
HSI/OHTA | [Saída IM]
Luminosidade
HSL | [Saída IM]
Brilho
HSB | [Saída IM]
Preto Neg
CMYK | [Saída IM]
Luminância*
LAB / LUV
---|---|---|---|---|---|---|---

Para as fórmulas reais veja a referência oficial da opção "[-colorspace](https://imagemagick.org/command-line-options/#colorspace)". Note que, a partir do IM v6.7.7, as imagens em tons de cinza são armazenadas sem modificações de gama ou sRGB, tanto na memória quanto ao serem salvas. Por isso, elas tendem a ser mais escuras do que eram antes desta versão. Note que 'Gray' (também conhecido como 'Intensidade' ou, mais exatamente, 'Luminância') e a 'Luma' do espaço de cor YUV são equivalentes. De forma semelhante, o 'Brilho' do espaço de cor HSB e o canal 'blacK' Negado do espaço de cor CMYK são equivalentes (e tipicamente excessivamente brilhantes para uso em tons de cinza). Note que o canal 'Luminosidade' (Lightness) do espaço de cor LAB (e também LUV) (não confundir com 'Luminosidade' do HSL) é considerado a melhor correspondência com a percepção visual humana, embora não seja comumente usado para gerar imagens em tons de cinza. Note que, dada uma imagem em tons de cinza, todas as imagens em tons de cinza dos espaços de cor produzem exatamente a mesma imagem da imagem em tons de cinza de entrada, com exceção da imagem do canal 'Luminosidade*' ('R') para um espaço de cor LAB / LUV.

Outros Métodos de Separação de Canal

Um método é copiar um canal para todos os outros canais, para gerar uma imagem em tons de cinza, exatamente como o que o Operador Separate gera. Um método simples, mas lento, é usar o Operador FX Faça-Você-Mesmo. 

  magick rose: -fx R channel_red.gif
  magick rose: -fx G channel_green.gif
  magick rose: -fx B channel_blue.gif

[Saída IM] [Saída IM] [Saída IM] [Saída IM]

Isso é frequentemente considerado a solução 'mais simples' de entender, e tem sido usada em outros tutoriais do IM. Outros métodos envolvem o uso de uma multidão de técnicas para 'zerar' os canais indesejados. Esses são listados em Zerando Canais de Cor abaixo, e geralmente são muito mais rápidos do que usar "[-fx](https://imagemagick.org/command-line-options/#fx)".

Combinando Imagens de Canal RGB

Depois que você separou todos os canais de cor da imagem e os processou, você também precisará ser capaz de reunir as imagens novamente. Isso pode ser feito usando o operador de lista especial "[-combine](https://imagemagick.org/command-line-options/#combine)", que é basicamente exatamente o inverso de "-separate". 

  magick separate_red.gif separate_green.gif separate_blue.gif \
           -combine -set colorspace sRGB rose_combined.gif

[Saída IM] [Saída IM] [Saída IM] [Saída IM]

Essas então "[-combine](https://imagemagick.org/command-line-options/#combine)" para criar uma imagem que é declarada como sendo uma imagem no espaço de cor sRGB. Um usuário queria poder trocar os canais vermelho e azul de uma imagem; isso torna isso fácil: separar os canais, trocar e recombinar. | 

  magick rose: -separate -swap 0,2 -combine rose_rb_swap.gif

[Saída IM]
Lembre-se de que a configuração padrão de "[-channel](https://imagemagick.org/command-line-options/#channel)" é 'RGB', e define quais imagens de canal estão sendo unidas. Se nem todos os canais que estão sendo combinados estiverem definidos, os outros canais são definidos usando os valores de cor da configuração atual de "-background". Você deve, no entanto, notar que tanto "[-combine](https://imagemagick.org/command-line-options/#combine)" quanto "-separate" ignoram a ordem em que os canais são definidos pelo "[-channel](https://imagemagick.org/command-line-options/#channel)". Os canais serão sempre processados e gerados na ordem de canal padrão 'Red,Green,Blue,Matte', para cada canal definido na configuração "[-channel](https://imagemagick.org/command-line-options/#channel)". Por isso, mesmo que você use uma configuração "-channel BR" ou apenas "blue,red", o operador "-combine" ainda esperará que as duas imagens sejam a vermelha primeiro e depois a azul. Os valores de verde e alfa (se as imagens tiverem transparência) serão definidos a partir dos valores da configuração atual de "-background". Por Exemplo... 

  magick separate_red.gif separate_blue.gif -background black \
           -channel blue,red  -combine    rose_red_blue.gif

[Saída IM] [Saída IM] [Saída IM]

Combinando Imagens de Canal não-RGB

A partir do IM v6.4.3-7, você também pode "[-combine](https://imagemagick.org/command-line-options/#combine)" imagens de canal que representam outros espaços de cor, mas você precisa dizer ao IM em qual espaço de cor a imagem resultante deve estar. Isso é feito usando o operador especial "[-set](https://imagemagick.org/command-line-options/#set) colorspace". Isso basicamente muda o espaço de cor de uma imagem na memória, mas sem mapear os dados de pixel da imagem, deixando-os como estão. Uma vez que a imagem tenha sido combinada no espaço de cor correto, você pode usar um operador "[-colorspace](https://imagemagick.org/command-line-options/#colorspace)" normal para mapear os dados de pixel de volta para dados RGB normais. | 

  magick separate_HSB_?.gif  -set colorspace HSB  -combine  \
          -colorspace sRGB  rose_HSB_combined.gif

[Saída IM]
Este método também funciona para imagens CMYK, que muitas vezes é difícil de manipular devido à necessidade de um quarto canal de cor. | 

  magick separate_CMYK_?.gif  -set colorspace CMYK  -combine  \
          -colorspace sRGB  rose_CMYK_combined.gif

[Saída IM]
Uma solução alternativa (para versões anteriores do IM) é carregar uma imagem (o canal vermelho) e alterá-la para que esteja no espaço de cor correto. Depois disso, cada imagem de canal individual pode ser carregada e Copiada por Canal para dentro dessa imagem pré-preparada. | 

  magick separate_HSB_0.gif -colorspace HSB \
          separate_HSB_0.gif -compose CopyRed   -composite \
          separate_HSB_1.gif -compose CopyGreen -composite \
          separate_HSB_2.gif -compose CopyBlue  -composite \
          -colorspace sRGB   rose_HSB_combined_alt.gif

[Saída IM]
Claro que, se você usou a operação "[-set](https://imagemagick.org/command-line-options/#set) colorspace", os dados do primeiro canal já estarão no lugar, pois isso não muda os dados de pixel reais, apenas a forma como os dados são interpretados. | O último exemplo não funcionará para imagens 'CMYK', pois a imagem do canal 'Black' na verdade não contém um canal preto! Por isso, "-compose CopyBlack" falhará em encontrar dados válidos para copiar. Considerei isso um bug, mas atualmente é improvável que seja corrigido.
---|---

Usar outros espaços de cor pode ser útil. Por exemplo, aqui pego a imagem de rosa embutida e quero negar o canal de luminância da imagem no espaço de cor 'Lab'. Quando terminado, recombino para construir uma imagem sRGB novamente. | 

  magick rose: -colorspace Lab -separate \
          \( -clone 0 -negate \) -swap 0 +delete \
          -combine -set colorspace Lab \
          -colorspace sRGB   rose_light_neg.gif

[Saída IM]
| _Anteriormente, este exemplo usava o espaço de cor 'HSL', mas esse é um espaço de cor linear, e queremos negar em um 'espaço de cor perceptual' como o fornecido pelo 'Lab'.

_
---|---
Note que a imagem ainda tem as mesmas cores, mas o brilho (luminosidade) das cores foi invertido, produzindo um efeito estranho. Você pode substituir o "-negate" pelo seu próprio conjunto de operações para ajustar os níveis de brilho de uma imagem. No entanto, como o "-negate" é, ele próprio, um operador controlado por canal, não tivemos que fazer "-separate" do canal de luminância para negá-lo. | 

  magick rose: -colorspace Lab \
          -channel R   -negate   +channel \
          -colorspace sRGB rose_light_neg2.gif

[Saída IM]
Como você pode ver, isso simplifica as coisas, mas pode nem sempre ser prático para o efeito que você quer alcançar.

Zerando Canais de Cor

Às vezes você tem uma imagem (RGB ou algum outro espaço de cor) na qual você só quer limpar ou 'zerar' um ou dois dos canais de cor, mas deixar todos os outros canais como estão. Por exemplo, para fazer uma imagem em tons de cinza sem usar Técnicas de Conversão para Tons de Cinza RGB, você poderia 'zerar' o canal de Saturação ('G') em um espaço de cor HSL, de modo a fazer uma imagem em tons de cinza. O valor de 'Matiz' não tem significado quando a saturação é zero, então você fica com uma imagem em tons de cinza. A técnica mais direta é frequentemente usar o Operador Evaluate para zerar todos os valores no canal indesejado... | 

  magick rose: -colorspace HSL \
          -channel G  -evaluate set 0  +channel \
          -colorspace sRGB rose_grey.gif

[Saída IM]
No entanto, há muitas maneiras não tão óbvias de fazer isso... 

  # Evaluate (rápido e direto)
    -channel G -evaluate set 0 +channel

  # Zeramento com FX (direto e simples, mas lento)
    -channel G -fx 0 +channel

  # Separe os canais que você quer manter,
  # depois combine usando uma cor de fundo para definir os outros canais
    -channel RB -separate -background black -combine +channel

  # Gamma que é um uso indevido do operador, mas funciona MUITO bem!
  # ( 1 = deixar como está;  0 = zerar o canal;  -1 = maximizar o canal )
  # Isto é curto, simples, não precisa de configuração de canal, mas é muito obscuro!
    -gamma 1,0,1

  # Aplicar threshold nos canais para zerar
    -channel G -threshold 101% +channel

  # Aplicar threshold no valor máximo e então negar para zerar
    -channel G -threshold -1 -negate +channel

  # Multiplicar com uma cor primária/secundária apropriada
  # A cor especifica os canais a preservar!  'magenta' = 'red'+'blue'
    \( +clone +level-colors magenta \) -compose multiply -composite

  # Colorizar canais específicos para preto
  # (0 = deixar como está;   100% definido a partir do preenchimento (preto) )
    -fill black -colorize 0,100%,0

Você consegue pensar em outra maneira de zerar (ou maximizar) um canal de cor que eu não listei acima? -- envie-me um e-mail

Espaços de Cor

Até agora nos concentramos nos espaços de cor 'sRGB', 'RGB' e 'CMYK'. Isso porque esses são os espaços de cor tipicamente usados para exibição, impressão e armazenamento tradicional de imagens em arquivos. Mas, embora esses espaços de cor sejam práticos, eles não representam como nós, humanos, realmente vemos o mundo. Nossos olhos podem ver em comprimentos de onda vermelho, verde e azul, mas nossos cérebros os interpretam como: matiz da cor (qual cor), grau de cinza (quão colorido) e intensidade (quão brilhante/escuro). Por causa disso, muitos espaços de cor e sistemas de cor foram desenvolvidos, frequentemente a partir de requisitos completamente independentes. Pintores, por exemplo, desenvolveram um sistema de cores (baseado em fontes de cor como lápis-lazúli), tonalidades e matizes. Mais tarde, os sistemas de computador usando RGB precisaram de melhores formas para que os usuários selecionassem ou modificassem cores, de maneiras que não fossem computacionalmente intensivas.

Espaços de Cor Baseados em Matiz

Provavelmente uma das alternativas mais conhecidas é o sistema baseado em matiz cíclico, que foi desenvolvido como uma interface de seleção de cor para cores RGB. Basicamente, o cubo de cor RGB foi rotacionado em 3 dimensões de modo que o eixo diagonal preto-cinza-branco do cubo se tornasse um eixo do espaço de cor. E isso especificava quão escura ou clara era uma cor. A característica principal dessa mudança foi uma conversão simples a partir dos valores RGB que espaçava as cores primárias igualmente ao redor desse eixo, de modo a formar um Matiz que cicla de vermelho, passando pelo verde, depois azul e de volta ao vermelho. Quão distante a cor estava desse eixo (radialmente) era conhecido como saturação ou croma.
Por exemplo, vamos Separar os canais da imagem 'rose:' embutida após transformá-la no espaço de cor 'HSB' (Hue, Saturation, Brilliance, também conhecido como HSV, com V de Value/Valor). 

  magick rose: -colorspace HSB -separate separate_HSB_%d.gif

[Saída IM] [Saída IM] [Saída IM] [Saída IM]

Ou o semelhante, mas não exatamente igual, 'HSL' (Hue, Saturation, Lightness / Matiz, Saturação, Luminosidade). 

  magick rose: -colorspace HSL -separate separate_HSL_%d.gif

[Saída IM] [Saída IM] [Saída IM] [Saída IM]

Note como a imagem do canal 'Matiz' em ambos os espaços de cor é o mesmo mosqueado de cores quase puramente preto e branco. Ou seja, porque um Matiz é na verdade circular. Isto é, tanto o preto quanto o branco na imagem de canal acima são na verdade representações de um Matiz 'Vermelho', e pequenas variações fazem o matiz saltar de um lado do vermelho (produzindo branco) para o outro (produzindo preto). Se isso for um problema, você pode rotacionar a configuração de matiz usando o Operador Modulate de modo que o vermelho passe a ser representado por algum outro valor de matiz. A diferença real entre 'HSL' e 'HSB' está em quão brilhantes as cores primárias são definidas. Mas, para ver isso, é melhor olharmos para representações mais práticas do espaço de cor, usando rodas de cores. Se você olhar as últimas imagens de 'brilho/luminosidade' nas separações acima, verá que o 'HSB' trata uma cor 'vermelho' forte (quase primária) como quase branca, enquanto o 'HSL' a trata mais como uma intensidade de cinza de tom médio.

Gerando uma Roda de Cores HSL

As separações brutas acima da cor de uma imagem ainda são difíceis de entender. Para entender melhor o espaço de cor, precisamos tentar visualizá-lo. O espaço de cor é mais usualmente representado como um gradiente polar circular, mostrando alguma parte do espaço de cor. Você pode gerar as imagens de valor de canal separadas e Combiná-las para gerar tipos específicos de imagens que são difíceis de gerar de outras maneiras. Por exemplo, aqui geramos uma roda de cores 'HSL' perfeita. 

  magick -size 100x300 gradient: -rotate 90 \
          -distort Arc '360 -90.1 50' +repage \
          -gravity center -crop 100x100+0+0 +repage  angular.png
  magick -size 100x100 xc:white                     solid.png
  magick -size 100x100 radial-gradient: -negate     radial.png

  magick angular.png solid.png radial.png \
          -combine -set colorspace HSL \
          -colorspace sRGB colorwheel_HSL.png

[Saída IM]
Matiz | [Saída IM]
Saturação | [Saída IM]
Luminância | | [Saída IM]
Roda de Cores HSL
---|---|---|---|---

| _As imagens em tons de cinza são geradas como um gradiente linear usando valores sRGB. Por isso, os gradientes tendem a parecer um pouco mais escuros do que deveriam. No entanto, é o valor nas imagens de entrada que importa aqui, não o espaço de cor de visualização.

Por outro lado, a imagem resultante, embora gerada no espaço de cor RGB linear, está sendo salva no espaço de cor sRGB para garantir que navegadores e outros programas de exibição de imagem exibam o gradiente de uma forma que funcione bem visualmente._
---|---
Note também que o Matiz é um valor 'módulo' (modulus), que dá a volta no vermelho (valor de matiz = 0). Isso pode ser um incômodo ao fazer processamento de imagens, pois você tem duas cores vermelhas que visualmente são idênticas, mas que, em termos de valor, estão a uma distância de matiz máxima. Este não é um bom espaço de cor para usar ao trabalhar com diferenças de cor. Na verdade, os canais de luminosidade/brilho dos espaços de cor HSB e HSL não são muito úteis, pois os vários Matizes não são tratados igualmente. Basicamente, ele 'equaliza' a intensidade das cores primárias. Por exemplo, rotacionar um matiz 'amarelo' para se tornar um matiz 'azul' fará com que a cor muito brilhante fique muito escura, e vice-versa. Para mais detalhes veja Desvantagens do HSL. Recomenda-se cautela.
Há vários espaços de cor que também usam esse mesmo sistema de matiz baseado em 'hex cone'. HSB, HCL e HCLp (HCL perceptual). Aqui estão as rodas de cores de todos esses quatro espaços de cor 'hex-cone'. 

  magick angular.png solid.png radial.png \
          -combine -set colorspace HSL \
          -colorspace sRGB colorwheel_HSL.png
  magick angular.png solid.png radial.png \
          -combine -set colorspace HSB \
          -colorspace sRGB colorwheel_HSB.png
  magick angular.png solid.png radial.png \
          -combine -set colorspace HCL \
          -colorspace sRGB colorwheel_HCL.png
  magick angular.png solid.png radial.png \
          -combine -set colorspace HCLp \
          -colorspace sRGB colorwheel_HCLp.png

[Saída IM]
HSL | [Saída IM]
HSB | [Saída IM]
HCL | [Saída IM]
HCLp
---|---|---|---

Lembre-se de que todas as cores mostradas acima são geradas com uma saturação de cor máxima. No entanto, o espaço de cor 'HSB' produzirá cores primárias com luminosidade máxima (o HSL gerou essas com metade da intensidade). Por causa disso, o branco só pode ser gerado quando a saturação é zero. Como resultado, em vez de uma área branca ao redor das bordas, você obtém cores totalmente saturadas. O espaço de cor 'HCL' usa os mesmos cálculos de matiz 'hex-cone', mas ajusta o canal de 'luminosidade' de modo a usar a intensidade de cor, em vez de valores RGB lineares diretos. Como resultado, ao usar o 'HCL', as cores primárias estão localizadas em diferentes níveis de intensidade, com o azul mais próximo da cor preta central, e as cores vermelhas muito mais brilhantes e mais afastadas. A área de 50% de intensidade do espaço de cor 'HCL' não produz cores fortes, mas em vez disso gera cores pastel mais naturais. Por exemplo, aqui está uma comparação dos matizes saturados entre os espaços de cor HSL e HCL a 50% de intensidade. 

  magick -size 100x100 xc:black \
          -fill white  -draw 'circle 49.5,49.5 40,4' \
          -fill black  -draw 'circle 49.5,49.5 40,30' \
          -alpha copy -channel A -morphology dilate diamond anulus.png
  magick hue_angular.png -size 100x100 xc:white xc:gray50 \
          -combine -set colorspace HSL -colorspace RGB \
          anulus.png -alpha off -compose Multiply -composite \
          anulus.png -alpha on  -compose DstIn -composite \
          -colorspace sRGB hues_HSL.png
  magick hue_angular.png -size 100x100 xc:white xc:gray50 \
          -combine -set colorspace HCL -colorspace RGB \
          anulus.png -alpha off -compose Multiply -composite \
          anulus.png -alpha on  -compose DstIn -composite \
          -colorspace sRGB hues_HCL.png

[Saída IM]
HSL/HSB | [Saída IM]
HCL
---|---

Ou seja, não que o 'HCL' não contenha cores puras; elas apenas não são 'forçadas' a um plano comum como são no espaço de cor 'HSL'. Em particular, note como todas as tonalidades no HCL têm a mesma intensidade de 50% (como solicitado), ao contrário dos resultados dos matizes do espaço de cor HSL. O verde é provavelmente a mais próxima de todas as cores principais a uma intensidade de 50%, então tem uma boa resposta em matizes de 50%. Recomenda-se usar este espaço de cor para rotações de matiz, de modo a preservar o brilho geral de todas as cores na imagem. Veja os exemplos em Modulate no Espaço de Cor HCL. Espaço de cor HWB ???

Espaços de Cor Perceptuais

Os espaços de cor 'Lab' e 'Luv' são projetados de modo a separar completamente a intensidade em tons de cinza dos componentes de cor de uma imagem. Diferentemente dos espaços de cor 'RGB' e 'sRGB'. Isso torna o espaço de cor muito mais fácil de processar e modificar em geral, uma vez que você pega o jeito. Mais especificamente, o 'Luv' foi projetado para ser 'perceptualmente linear'. Ou seja, que uma pequena mudança de cor em uma parte do espaço de cor pareça ser aproximadamente igual a uma mudança semelhante em outra parte do espaço de cor. Isso torna o espaço de cor Luv muito mais adequado para comparações de diferença de imagens. Os dois espaços de cor são muito semelhantes e geralmente produzem resultados semelhantes ao processar imagens. Aqui separamos os canais para os espaços de cor 'Lab' e 'Luv', apenas para mostrar quão semelhantes os dois espaços de cor realmente são. 

  magick rose: \( -clone 0 -colorspace LAB -separate +append \) \
                \( -clone 0 -colorspace LUV -separate +append \) \
          -delete 0 -append -set colorspace sRGB separate_lab_luv.png

[Saída IM] | | [Saída IM] | Lab

Luv
---|---|---|---

Melhores exemplos do espaço de cor 'Lab' e 'Luv' podem ser vistos usando sua variação cilíndrica 'LCHab' 'LCHvu', em A Roda de Cores LCH abaixo. Para um exemplo prático de uso desses espaços de cor veja Redimensionando no espaço de cor Lab.

Espaços de Cor baseados em Lab e Luv

O espaço de cor 'HCL' é baseado no espaço de cor 'LCHuv', que é uma representação cilíndrica do espaço de cor 'Luv', porém com uma fórmula mais simples para o canal de luminosidade, de modo a gerar branco puro na luminosidade máxima. Por completude, aqui estão as representações cilíndricas dos espaços de cor 'Lab' e 'Luv', que são conhecidas como 'LCHab' e 'LCHuv' respectivamente. No entanto, note que a ordem dos canais é o inverso do espaço de cor 'HCL' equivalente mostrado acima. 

  magick radial.png solid.png angular.png \
          -combine -set colorspace LCHab \
          -colorspace sRGB colorwheel_LCHab.png
  magick radial.png solid.png angular.png \
          -combine -set colorspace LCHuv \
          -colorspace sRGB colorwheel_LCHuv.png

[Saída IM]
Luminosidade* | [Saída IM]
Croma | [Saída IM]
Matiz | | [Saída IM]
LCHab | [Saída IM]
LCHuv
---|---|---|---|---|---

Note que o espaço de cor 'LCH' é um alias para 'LCHab'. No exemplo acima você pode ver que o 'LCHuv' tem uma descontinuidade onde cores irreais estão sendo definidas usando o processo da roda de cores. Conversões normais de imagens não gerarão essas cores.

Espaço de Cor scRGB de Alta Faixa Dinâmica

Wikipedia:  http://en.wikipedia.org/wiki/ScRGB

Este é essencialmente um método de armazenar uma cor de alta faixa dinâmica
(com negativos e até 10 vezes a faixa do RGB linear) em um inteiro de 16 bits,
com apenas 1/2 da resolução de cor de uma imagem sRGB de 16 bits normal.

Como usa inteiros de 16 bits, pode ser armazenado em formatos de arquivo de imagem
que possam salvar tais imagens (PNG, PPM, MIFF), embora um perfil de cor, ou algum
outro método, deva ser usado para marcar essas imagens como contendo dados no
espaço de cor scRGB.

Você teria que ter muito cuidado com muitos operadores de processamento de imagens
neste espaço de cor, pois ele tem um 'deslocamento' (offset) para permitir lidar com
números negativos. E embora alguns operadores como resize e distort possam ser usados
diretamente neste espaço de cor, provavelmente é uma ideia melhor usar uma versão HDRI
do ImageMagick, e magick para RGB linear (com negativos), para processamento de imagens
mais geral.

_Exemplos e mais informações sobre o uso deste espaço de cor seriam bem-vindos_

Substituindo Cores em Imagens

O ImageMagick naturalmente fornece uma série de opções para substituir uma cor específica e cores aproximadas por outra cor. Isso é ótimo ao lidar com ícones e imagens do tipo 'bitmap' que contêm muito poucas cores, mas tende a falhar ao lidar com imagens que contêm tonalidades de cor ou pixels de borda anti-serrilhada. Basicamente, você precisa lembrar que as cores são substituídas por uma única tonalidade. Então, se você substituir um conjunto ou vizinhança de cores, todas essas cores são substituídas por uma cor única específica e não por uma faixa de cores correspondente. Isso não quer dizer que seja impossível fazer uma substituição de cor com tonalidades, apenas não é simples de fazer neste momento, sem muito trabalho. Mesmo assim, imagens GIF não permitem o uso de semitransparência, então substituir cores dessa forma é um bom método para controlar a transparência de fundo de GIFs (Veja GIFs sobre um Padrão de Fundo para exemplos) O outro aspecto é que, embora você possa mapear todas as 'cores próximas' para um determinado mapa de cores, usando Mapas de Cor Pré-Definidos, não há operador para fazer um mapeamento direto um-para-um de um grande conjunto de cores para outro conjunto completamente diferente de cores. Esta é uma limitação que pode mudar em uma versão futura do IM. Com essa ressalva, vamos ver as maneiras que o IM fornece para a substituição direta de uma cor específica por outra cor.

Substituir uma Cor Específica

Os operadores "[-opaque](https://imagemagick.org/command-line-options/#opaque)" e "[-transparent](https://imagemagick.org/command-line-options/#transparent)" são projetados para substituir uma cor em uma imagem por outra. Por exemplo, para substituir uma cor 'blue' por, digamos, 'white', você usaria um comando como este... | 

  magick balloon.gif  -fill white -opaque blue   balloon_white.gif

[Saída IM] [Saída IM]
Basicamente, qualquer cor que era 'blue' foi substituída pela cor "[-fill](https://imagemagick.org/command-line-options/#fill)" atual. No entanto, a partir do IM v6.2.7, esse operador é limitado pela configuração "[-channel](https://imagemagick.org/command-line-options/#channel)". Por isso, para magick uma cor (digamos blue) em transparência, você precisará especificar um "[-channel](https://imagemagick.org/command-line-options/#channel)" que inclua o canal alfa para tornar as cores transparentes. Você também precisará garantir que a imagem tenha um canal alfa ou 'matte' habilitado, para conter a informação de transparência. | 

  magick balloon.gif   -alpha set  -channel RGBA \
                        -fill none -opaque blue   balloon_none.gif

[Saída IM] [Saída IM]
Como substituir uma cor por transparência é uma operação tão comum, o comando acima tem seu próprio operador especial de substituição por transparência "[-transparent](https://imagemagick.org/command-line-options/#transparent)". | 

  magick balloon.gif  -transparent blue   balloon_trans.gif

[Saída IM] [Saída IM]
A partir da versão 6.3.7-10 do IM, as versões 'plus' desses operadores invertem a seleção de cor. Ou seja, as cores que NÃO correspondem à cor dada serão substituídas. Por exemplo, aqui substituo qualquer cor que NÃO seja preto puro por branco, deixando apenas as bordas pretas puras da imagem. | 

  magick balloon.gif  -fill white +opaque black   balloon_borders.gif

[Saída IM] [Saída IM]
Isso pode não parecer grande coisa, mas quando você o combina com um Fator Fuzz (veja abaixo), isto se torna uma ferramenta muito poderosa. | Antes do IM v6.3.7-10, a operação inversa exigia o uso de alguns truques usando máscaras de imagem. Basicamente, você substitui a cor que quer preservar por transparência, depois "[-colorize](https://imagemagick.org/command-line-options/#colorize)" todas as outras cores para a cor desejada, criando uma máscara de sobreposição. Esta é então sobreposta na imagem original para 'mascarar' as cores que não corresponderam! | | 

  magick balloon.gif \
          \( +clone -alpha set -transparent black \
             -fill white  -colorize 100% \) \
          -composite    balloon_mask_non-black.gif

[Saída IM] [Saída IM]
Como você pode ver, a forma 'plus' do operador simplificou enormemente a operação de substituição 'não esta cor'.
Para técnicas de substituição mais avançadas, sugiro que você dê uma olhada em Remoção de Fundo. | _Esteja avisado de que, como todas as cores correspondentes (especialmente 'cores correspondidas de forma fuzzy', veja abaixo) são substituídas por uma única cor uniforme, você não terá nenhum anti-serrilhamento nas bordas das áreas coloridas. E você perderá toda e qualquer sombra ou outros efeitos de sombreamento que possam estar presentes. Isso pode ter um efeito seriamente prejudicial na aparência de qualquer imagem não-simples que não seja do tipo desenho animado.

Este tipo de substituição de cor não é projetado tendo em mente imagens práticas do mundo real, mas mais para efeitos de mascaramento de imagem. Recomenda-se cautela._
---|---
O substituição de cor "[-opaque](https://imagemagick.org/command-line-options/#opaque)" não pode substituir uma cor por um padrão lado a lado (tiled pattern). Ele só substituirá cores por outra cor única específica. No entanto, ambos os métodos de substituição de cor "[-draw](https://imagemagick.org/command-line-options/#draw)" e "[-floodfill](https://imagemagick.org/command-line-options/#floodfill)" podem (veja abaixo).

Substituir usando uma Cor na Imagem

Você também pode usar a Substituição de Cor com Draw para recolorir imagens com base nas cores presentes na própria imagem, em vez de uma cor específica. | 

  magick present.gif -fill red -draw 'color 0,0 replace' present_blue.gif

[Saída IM] [Saída IM]
Note que eu nunca especifiquei a cor a ser substituída, apenas a localização da cor a ser substituída. É a cor naquela localização que é usada para 'corresponder' quais áreas devem ser preenchidas, independentemente de qual seja essa cor. Você pode ver no exemplo acima o problema com a substituição de cor: a cor específica pode aparecer em outros lugares além dos pretendidos, dando-nos uma linha de pixels vermelhos dentro da imagem 'present' acima. A transparência também não apresenta problema, embora algumas partes internas da imagem também tenham sido tornadas transparentes assim como ficaram vermelhas no exemplo acima... | 

  magick present.gif -alpha set -fill none \
                      -draw 'color 0,0 replace' present_none.gif

[Saída IM] [Saída IM]
Note, no entanto, que, diferentemente de "[-opaque](https://imagemagick.org/command-line-options/#opaque)" e "[-transparent](https://imagemagick.org/command-line-options/#transparent)", a Substituição de Cor com Draw não permite que você inverta as 'cores correspondentes' a serem substituídas. O Draw também tem uma Substituição Matte especial, onde apenas a transparência da cor de preenchimento é substituída. Ou seja, você pode tornar todas as cores correspondentes transparentes, ou semitransparentes, sem na verdade mudar a cor do próprio pixel. Com o formato de arquivo apropriado, claro. | 

  magick present.gif -alpha set -fill '#00000080' \
            -draw 'matte 0,0 replace' present_semi.png

[Saída IM] [Saída IM]
Isso se torna muito mais útil quando um Fator Fuzz também é especificado. A maior vantagem de usar "[-draw](https://imagemagick.org/command-line-options/#draw)" é que você também pode substituir a cor por um padrão lado a lado (tile pattern). Por exemplo.. | 

  magick present.gif -tile pattern:right30 \
                -draw 'color 0,0 replace' present_tile.gif

[Saída IM] [Saída IM]
Para técnicas de substituição mais avançadas, sugiro que você dê uma olhada em Remoção de Fundo.

Preenchimento por Inundação com Draw

Os métodos de Cor com Draw também fornecem um método simples de substituir uma cor por 'preenchimento por inundação' (floodfilling). Ou seja, em vez de substituir TODAS as cores correspondentes dentro da imagem, você pode selecionar apenas as cores que estão 'conectadas a' ou 'ligadas a' um ponto especificado na imagem. O ponto especificado não apenas especificará o ponto inicial (ponto semente / seed point), mas também a cor que você está tentando substituir. | 

  magick present.gif -fill red -draw 'color 0,0 floodfill' present_fill.gif

[Saída IM] [Saída IM]
Note que as áreas vermelhas que não estavam 'ligadas' ao pixel 0,0 não foram substituídas. Para substituição de fundo isso pode ser um problema, mas a solução é igualmente fácil. Expanda a imagem ligeiramente para que o preenchimento por inundação possa 'vazar' para dentro da imagem a partir de todas as direções, depois remova esse espaço extra quando terminar. | 

  magick present.gif -bordercolor white -border 1x1 \
          -fill red     -draw 'color 0,0 floodfill' \
          -shave 1x1               present_bgnd.gif

[Saída IM] [Saída IM]
Claro que você pode ajustar quais cores são 'correspondidas' usando a configuração de controle Fator Fuzz abaixo, que é especialmente importante para imagens JPEG.

Operador de Preenchimento por Inundação

O operador "[-floodfill](https://imagemagick.org/command-line-options/#floodfill)" foi adicionado para tornar o preenchimento por inundação um pouco mais fácil, especialmente quando você quer especificar exatamente a cor que você quer especificamente substituir. Isso pode ser especialmente importante ao usar a correspondência de cor com Fator Fuzz. No entanto, esteja avisado de que, se esse ponto semente não estiver dentro de uma correspondência de Fator Fuzz da cor que você está procurando, então o "[-floodfill](https://imagemagick.org/command-line-options/#floodfill)" não faz nada. Isso pode ser considerado tanto uma característica do operador quanto sua maldição.

Um pequenoFator Fuzz é recomendado para preenchimento por inundação.
Ou garanta que o ponto semente corresponda exatamente à cor procurada.

Por exemplo, adicione uma borda de cor conhecida para preencher por inundação a partir das bordas... | 

  magick present.gif -bordercolor white -border 1x1 \
          -fill red    -floodfill +0+0 white \
          -shave 1x1              present_floodfill.gif

[Saída IM] [Saída IM]
Isso substituirá qualquer cor que seja 'white' por 'red' que seja diretamente parte da área ao redor do pixel semente começando em +0+0, que é garantidamente 'white' devido à borda adicionada. Você também pode preencher por inundação com um padrão lado a lado (tile pattern). | 

  magick present.gif -bordercolor white -border 1x1 \
                -tile pattern:left30   -floodfill +0+0 white \
                -shave 1x1           present_pattern.gif

[Saída IM] [Saída IM]
O argumento 'color ' às vezes pode ser um incômodo, no sentido de que ele deve corresponder à cor do ponto semente, ou nenhuma ação ocorrerá. Mas isso também pode ser útil, pois garantirá que o preenchimento por inundação faça exatamente o que você queria, e não o inesperado. Por exemplo, aqui tento preencher discos brancos com várias cores... | 

  magick disks.gif \
          -fill Red   -floodfill +30+50 white \
          -fill Green -floodfill +60+60 white \
          -fill Blue  -floodfill +10+40 white \
          floodfill_hit_miss.gif

[Saída IM]
Neste caso, apenas as operações de preenchimento por inundação 'Green' e 'Blue' 'acertaram um disco' (e o preencheram), enquanto o preenchimento 'Red' não correspondeu a um disco, então nenhum disco foi preenchido, sem preencher acidentalmente o fundo da imagem. Isso também significa que, se você já preencheu uma área específica, preenchimentos posteriores não 'reencherão' a mesma área se dois pontos acertarem essa área. Isso pode economizar muito tempo. Você também pode querer dar uma olhada em Dilatação Condicional, que representa uma operação de preenchimento por inundação de nível mais baixo a partir de múltiplos pontos 'semente' na imagem.

Fator Fuzz - Correspondência de Cores Similares/Múltiplas

Os resultados gerais de apenas selecionar uma única cor para substituir, como mostrado nos exemplos anteriores, geralmente não são muito agradáveis. As bordas ou áreas de cores sólidas geralmente têm uma mistura de cores na borda, devido ao anti-serrilhamento (Veja Anti-Serrilhamento para mais informações). Por isso, você deve evitar a substituição direta de cor, se possível. Por exemplo, aqui pego o que parece ser uma simples 'vaca' preta e branca e tento torná-la uma vaca vermelha. 

  magick cow.gif -fill red -opaque black  cow_replace_red.gif

[Saída IM] [Saída IM]

Como você pode ver, apenas as partes centrais das áreas 'pretas' realmente ficaram vermelhas. Ou seja, porque, embora a imagem pareça ser preta e branca, ela é na verdade uma imagem em tons de cinza com quase todas as bordas em várias tonalidades de cinza. Ou seja, elas não são exatamente preto puro na cor. O fator fuzz, ("[-fuzz](https://imagemagick.org/command-line-options/#fuzz)") representa uma correspondência de 'similaridade' em distância esférica multidimensional entre cores, usando qualquer espaço de cor que a imagem esteja usando. Bem, ok, vamos tentar isso em português simples. Você tem uma cor específica. Outra cor será tratada como sendo a mesma que a cor procurada, se a diferença entre essas cores for menor que a configuração do fator fuzz. Quanto maior o 'fator fuzz', mais cores 'próximas' corresponderão e serão substituídas. Então vamos tentar isso em nossa imagem de vaca, de modo a magick para vermelho não apenas o preto puro, mas também cores quase pretas. 

  magick cow.gif -fuzz 40%  -fill red -opaque black  cow_replace_fuzz.gif

[Saída IM] [Saída IM]

Como você pode ver, agora substituímos todos os pixels 'escuros' da imagem por vermelho. Mas o resultado ainda é muito ruim, com um tom acinzentado na borda e fortes efeitos de Serrilhamento. A substituição direta de cor não é uma boa solução para esta imagem, mesmo que você consiga fazê-la funcionar usando um grande 'fator fuzz'. Veja os exemplos em Ajustes de Nível por Cor para a solução ideal para esta imagem. Este problema é ainda pior para imagens em que você está tentando substituir uma cor de fundo por transparência. Você basicamente acaba com um 'halo' ao redor do objeto naquela cor de fundo. Isso é muito difícil de resolver, e problemas como este são examinados em detalhe em Remoção de Fundo. Que operações usam o fator fuzz O operador "[-fuzz](https://imagemagick.org/command-line-options/#fuzz)" afeta praticamente qualquer operador que compara cores específicas dentro de uma imagem. Isto inclui: "[-opaque](https://imagemagick.org/command-line-options/#opaque)", "[-transparent](https://imagemagick.org/command-line-options/#transparent)", "[-floodfill](https://imagemagick.org/command-line-options/#floodfill)", "[-trim](https://imagemagick.org/command-line-options/#trim)", "[-deconstruct](https://imagemagick.org/command-line-options/#deconstruct)", "[-draw](https://imagemagick.org/command-line-options/#draw) 'color'", "[-draw](https://imagemagick.org/command-line-options/#draw) 'matte'", e provavelmente outros. Também afeta o "[-layers](https://imagemagick.org/command-line-options/#layers) [OptimizeTransparency](anim_opt.html#opt_trans)" de GIF, e o tratamento de "[-compose](https://imagemagick.org/command-line-options/#compose) [ChangeMask](compose.html#changemask)". Também afeta os resultados de "magick compare" e especificamente o "[-metric](https://imagemagick.org/command-line-options/#metric) AE" ou Contagem de Pixels de Erro Absoluto.

Distância do Fator Fuzz

A configuração "[-fuzz](https://imagemagick.org/command-line-options/#fuzz)" é na verdade uma forma de configuração de 'distância' de cor. Qualquer cor que esteja dentro da distância dada da cor procurada corresponderá a essa cor, mesmo que não seja uma correspondência exata. Um valor de '200' representa uma distância de 200 unidades de cor na profundidade de cor atual do IM em uso. Para um IM Q16 (qualidade de 16 bits para armazenamento de cor) isso é bem pequeno; para um IM Q8 isso é MUITO grande, e fará com que muitas cores correspondam umas às outras. Aqui, por exemplo, mudo todas as cores que estão dentro de 30.000 unidades de cor (para IM Q16) de 'blue' para branco. Com meus programas ImageMagick Q16, isso representa aproximadamente a distância de 'blue a 'navy' (azul escuro pela metade), | 

  magick colorwheel.png \
          -fuzz 30000 -fill white -opaque blue \
          opaque_blue.jpg

[Saída IM]
Para tornar isso mais fácil de entender, aqui inverto as cores correspondentes, tornando as cores não correspondentes brancas. | 

  magick colorwheel.png \
          -fuzz 30000 -fill white +opaque blue \
          opaque_blue_not.png

[Saída IM]
Se o seu IM for mais antigo que a versão 6.3.7-10, quando a forma 'plus' do operador "[-opaque](https://imagemagick.org/command-line-options/#opaque)" foi adicionada, você pode usar este método de mascaramento para inverter o resultado da correspondência de cor... | 

  magick colorwheel.png \
          \( +clone  -fuzz 30000 -transparent blue \
             -channel RGB +level-colors white +channel \) \
          -composite   opaque_blue_inv.png

[Saída IM]
Ou este método que limita todas as modificações apenas ao 'canal alfa', de modo que todas as cores originais sejam deixadas como estão. Ou seja, você cria uma máscara negada a partir da seleção de cor, de modo a tornar todas as cores não selecionadas totalmente transparentes. Elas permanecem presentes, apenas transparentes! | 

  magick colorwheel.png -fuzz 30000 -transparent blue \
          -channel A -negate +channel   opaque_blue_inv_alpha.png

[Saída IM]
Uma vantagem desses métodos alternativos é que você pode expandi-los para gerar uma técnica de 'não-múltiplas cores '. Tudo o que você precisa fazer é adicionar mais cores à lista que está sendo tornada transparente, antes de negar a máscara e, possivelmente, remover a transparência negada. | 

  magick colorwheel.png \
          -fuzz 25000 -transparent blue -transparent red -transparent lime \
          -channel A -negate +channel \
          -background white -alpha remove   opaque_multi_inv.png

[Saída IM]

| _Como curiosidade, em um IM com configuração de compilação Q8, um fator "[-fuzz](https://imagemagick.org/command-line-options/#fuzz)" de 256 (28) tornará as cores 'black' e 'blue' equivalentes. Para um IM com configuração Q16, esse número é 65536 (216).

Para fazer as cores 'blue' e 'red' corresponderem, esse número deve ser multiplicado pela raiz quadrada de 2, ou 362 para IM Q8, e 92682 para IM Q16.

Para fazer todas as cores corresponderem (por exemplo, as cores 'black' e 'white') você precisará multiplicar pela raiz quadrada de 3. Em outras palavras, uma configuração de fator fuzz de 444 para IM Q8 e 113512 para IM Q16.
---|---
| _É provável que distâncias de cor melhores e mais realistas possam ser definidas usando um espaço de cor 'perceptual', como 'LAB' ou 'LUV'. Basta magick as imagens para esse espaço de cor antes de realizar a correspondência fuzzy de cor. Isso tornará cores como azul puro e preto muito mais próximas, e amarelo e branco mais próximas, do que estão nos espaços de cor 'sRGB' ou 'linear-RGB'.
---|---
Como você pode ver pelas fórmulas acima, distâncias diretas de cor definitivamente não são uma forma agradável de definir o fator fuzz a usar, pois também depende exatamente de qual Configuração de Qualidade de tempo de compilação é usada. Definir o fator "[-fuzz](https://imagemagick.org/command-line-options/#fuzz)" como uma porcentagem torna seu uso muito mais simples. Neste caso, '100%' representa um fator fuzz grande o suficiente para cobrir todas as cores. Ou seja, ele representa a distância de cor de 'black' a 'white', através da diagonal tridimensional do cubo de cor RGB. Aqui substituímos qualquer cor dentro de 90% da distância do branco ao preto por branco. Isso deveria resultar em apenas os últimos 10% das cores perto de 'black' permanecendo na imagem, pois o preto está no lado oposto do cubo de cor RGB. | 

  magick colorwheel.png -fuzz 90% -fill white -opaque white  opaque_w90.jpg

[Saída IM]
Note que esses 90% representam uma esfera de cores ao redor do 'branco' no cubo de cor RGB. No entanto, isso não é o mesmo que substituir as cores que não estão dentro de uma esfera de 10% do preto. | 

  magick colorwheel.png -fuzz 10% -fill white +opaque black  opaque_k10.jpg

Como você pode ver, a esfera de 10% de cores perto do preto é muito mais uniforme do que selecionar uma esfera de 90% das cores ao redor do branco. Pense em como uma grande esfera centrada no canto branco de um cubo preenche esse cubo. Depois pense em uma pequena esfera centrada no canto preto, e você conseguirá entender a diferença entre as duas imagens. [Saída IM]
| _Um fator "[-fuzz](https://imagemagick.org/command-line-options/#fuzz)" de 100% equivale à distância do cubo de cor RGB de 'black' a 'white'. A partir disso podemos calcular que uma porcentagem de cerca de 57.7% é a distância entre 'black' e 'blue', e 81.6% é a distância de 'blue' a 'red' ou de qualquer uma dessas cores até 'white'.

Em resumo, qualquer coisa maior que cerca de 25% (pouco menos que a distância RGB de 'blue' a 'navy blue') representa uma mudança de cor muito grande._
---|---
Para demonstrar melhor as distâncias de cor, vamos usar uma porcentagem de fator fuzz progressivamente maior ao redor das cores azuis... 

  magick colorwheel.png -fuzz 10% -fill white -opaque blue opaque_b10.jpg
  magick colorwheel.png -fuzz 25% -fill white -opaque blue opaque_b25.jpg
  magick colorwheel.png -fuzz 57% -fill white -opaque blue opaque_b57.jpg
  magick colorwheel.png -fuzz 81% -fill white -opaque blue opaque_b81.jpg
  magick colorwheel.png -fuzz 95% -fill white -opaque blue opaque_b95.jpg

[Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM]

A partir disso você pode ver claramente que não é o 'black' nem o 'white' a cor mais distante de 'blue', mas que na verdade é o 'yellow' que é o mais distante dentro do espaço de cor RGB. Note também que uma diferença de cor de 81% deixará de corresponder a um 'red' puro por pouco; no entanto, embora o vermelho puro não corresponda a outros vermelhos (excluindo cores laranja-avermelhadas), estes correspondem. Ou seja, novamente devido à natureza 'esférica' da correspondência de cor. A moral é que você provavelmente está melhor usando múltiplas correspondências de "[-fuzz](https://imagemagick.org/command-line-options/#fuzz)" com fatores pequenos ou uma 'correspondência invertida' menor, do que um único valor grande. Aqui comparamos as cores na imagem com outra cor, a cor 'cinza quase perfeita', mudando cores semelhantes para essa mesma cor cinza, à medida que o 'fator fuzz' aumenta. 

  magick colorwheel.png -fuzz 25% -fill gray50 -opaque gray50 opaque_g25.jpg
  magick colorwheel.png -fuzz 30% -fill gray50 -opaque gray50 opaque_g30.jpg
  magick colorwheel.png -fuzz 35% -fill gray50 -opaque gray50 opaque_g35.jpg
  magick colorwheel.png -fuzz 45% -fill gray50 -opaque gray50 opaque_g45.jpg
  magick colorwheel.png -fuzz 51% -fill gray50 -opaque gray50 opaque_g51.jpg

[Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM]

Como você pode ver, as cores na imagem da roda de cores só começam a corresponder em um fator fuzz pouco antes de 30%, e aumentam lentamente até que, em 45%, todas, exceto as cores mais extremas, tenham desaparecido. Em 51% todas as cores na imagem corresponderam ao cinza quase perfeito. O que você está vendo é o resultado da forma como as cores RGB são organizadas em um cubo no espaço tridimensional. A imagem da 'roda de cores', no entanto, contém apenas 'cores totalmente saturadas', o que basicamente significa todas as cores extremas que estão localizadas nas faces externas do cubo de cor RGB. Um cinza perfeito está, no entanto, localizado no centro do cubo, bastante distante de todas as 'cores saturadas'. Por isso, só ao atingir um grande fator fuzz de 28% é que a cor no meio das faces do cubo começa a corresponder. À medida que o fator fuzz fica maior, mais e mais cores corresponderão até que apenas as cores nos cantos extremos do cubo de cor permaneçam. Em torno de 50% as cores dos cantos também começarão a corresponder, e assim, em 51%, todas as cores RGB opacas terão correspondido.

Fator Fuzz e Cores Transparentes

Usar um fator "[-fuzz](https://imagemagick.org/command-line-options/#fuzz)" torna-se mais complicado quando a correspondência envolve cores transparentes e semitransparentes. Por exemplo, aqui crio um gradiente entre preto e branco, ao longo da imagem, mas depois adiciono um gradiente transparente verticalmente. Em seguida, faço uma correspondência fuzzy de cor para uma cor cinza perfeita (que é 50% cinza). Em imagens posteriores torno a cor sendo correspondida mais transparente até que esteja totalmente transparente, no entanto o Fator Fuzz permanece constante em 20%. 

  magick -size 100x100 gradient: \( +clone -rotate 90 \) +swap \
          -compose CopyOpacity -composite  trans_gradient.png
  magick trans_gradient.png -channel RGBA \
          -fuzz 20% -fill Gray50 -opaque 'GrayA(50%,1.0)' fuzz_trans_100.png
  magick trans_gradient.png -channel RGBA \
          -fuzz 20% -fill Gray50 -opaque 'GrayA(50%,.75)' fuzz_trans_75.png
  magick trans_gradient.png -channel RGBA \
          -fuzz 20% -fill Gray50 -opaque 'GrayA(50%,.40)' fuzz_trans_40.png
  magick trans_gradient.png -channel RGBA \
          -fuzz 20% -fill Gray50 -opaque 'GrayA(50%,0.0)' fuzz_trans_00.png

[Saída IM] [Saída IM] [Saída IM] [Saída IM] [Saída IM]

Note que o uso de "-channel RGBA" acima não é para correspondência de cor, mas para especificar os canais de cor a serem 'preenchidos'. Ou seja, sem isso, o exemplo acima ainda corresponderá às mesmas cores, mas o 'preenchimento' cinza permanecerá semitransparente, e não será definido como uma cor cinza opaca. Se você quiser corresponder todas as cores independentemente de sua transparência, então precisará Desligar o Canal Transparente da imagem, ao menos temporariamente. Você pode ligá-lo novamente depois, embora sua cor de preenchimento tenha novamente a mesma transparência da cor original. Na primeira imagem, correspondendo a uma cor cinza totalmente opaca (alfa='1.0'), você obtém uma correspondência muito esférica de todas as cores cinza quase opacas. No entanto, à medida que a cor sendo correspondida fica mais semitransparente, o número de cores semitransparentes correspondentes parecerá ficar maior, até que um cinza totalmente transparente corresponderá a qualquer cor quase transparente. O que está acontecendo é que, à medida que a transparência aumenta, a distância entre as cores semitransparentes diminui. Quanto mais transparentes forem duas cores, mais próximas as cores ficarão, em comparação com suas contrapartes opacas. Quando ambas as cores são totalmente transparentes, as duas cores serão consideradas uma correspondência perfeita, ou de distância '0'. A outra coisa a notar é que (a partir do IM v6.6.6-4) a distância de uma cor totalmente transparente (cinza ou outra) é puramente uma função da transparência das cores (valor alfa). A última imagem acima correspondeu a todos os pixels que estavam dentro de 20% de serem totalmente transparentes, independentemente da cor real. Isso também significa que um grande Fator Fuzz com uma cor totalmente transparente (como 'none') pode ser usado para corresponder a todas, ou quase todas, as cores semitransparentes. Por exemplo... | 

  magick trans_gradient.png -channel RGBA \
          -fuzz 95% -fill Gray50 -opaque None \
          -alpha off  fuzz_trans.jpg

[Saída IM]
Note que apenas os 5% superiores das cores quase opacas acima não corresponderam, enquanto todas as outras cores semitransparentes foram tornadas cinza. O "[-alpha](https://imagemagick.org/command-line-options/#alpha) off" final remove o último resquício de semitransparência da imagem. Por causa disso, a configuração "[-channel](https://imagemagick.org/command-line-options/#channel) RGBA" não é, na verdade, necessária, mas é recomendada por completude. Este exemplo é essencialmente equivalente a um threshold do canal alfa, antes de adicionar uma camada de cor cinza por baixo (para tornar as cores transparentes cinza) | Antes do IM v6.6.6-4, a correspondência fuzzy de cor não correspondia cores totalmente transparentes com cores opacas de forma igual. Na verdade, o Preto era uma correspondência muito mais próxima que o Branco. Por isso, o último exemplo falhará. VejaBug de Distância Fuzz e Cores Transparentes para mais detalhes.
---|---
| Pior ainda, antes do IM v6.2.6-2 a correspondência fuzzy de cor não considerava todas as cores totalmente transparentes como sendo a mesma cor. Ou seja, preto totalmente transparente (também conhecido como 'None') não era o mesmo que branco totalmente transparente (ou a cor '#FFF0'), embora ambos sejam totalmente transparentes.
---|---

Em Construção

Matemática de cores (obter a média de duas ou mais cores)....

  Exemplo, fazendo a média de duas cores... Digamos '#000000'  e  '#DDDDDD'

  Geralmente as cores são adicionadas a imagens, e o resultado é gerado como uma
  imagem 'txt:-' de um único pixel, da qual a cor pode ser extraída.

  * use -resize para mesclar as cores

      magick -size 2x1 xc:'#000000' -fill '#DDDDDD' \
              -draw 'point 0,0'  -resize 1x1  txt:-

  * Use -evaluate-sequence mean nelas!

      magick -size 1x1 xc:'#000000' xc:'#DDDDDD' \
              -evaluate-sequence mean  txt:-

    Ou, para muitas cores, você pode usar o filtro de resize 'Box'
      magick rose: -filter Box -resize 1x1\! txt:
      # ImageMagick pixel enumeration: 1,1,255,RGB
      0,0: (145, 89, 80) #915950

  * Use -fx para aplicar qualquer fórmula que você quiser

      magick -size 1x1 xc:'#000000' xc:'#DDDDDD' \
              -fx '(u+v)/2'  txt:-

  Com uma API do ImageMagick os resultados podem ser recuperados mais diretamente da
  imagem.

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