ImageMagick Documentation (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://imagemagick.org/porting/).

ImageMagick Versão 7 • Imagens de Alta Faixa Dinâmica (HDRI) • Canais de Pixel • Alfa • Escala de Cinza • Máscaras • API MagickCore • Arquivos de Cabeçalho • Recursos Obsoletos Removidos • Interface de Linha de Comando • Melhorias de Desempenho • Resumo das Mudanças da Versão 7

O design do ImageMagick é um processo evolutivo, no qual os esforços de design e implementação servem para influenciar e orientar o progresso um do outro. Com o ImageMagick versão 7, aprimoramos o design com base nas lições aprendidas com a implementação da versão 6. O ImageMagick foi originalmente projetado para exibir imagens RGB em um servidor X Windows. Com o tempo, estendemos o suporte para imagens RGBA e, em seguida, para os formatos de imagem CMYK e CMYKA. Com o ImageMagick versão 7, estendemos o suporte a espaços de cor arbitrários com um número arbitrário de canais de pixel. Além disso, o ImageMagick 7 armazena os canais de pixel como floats, permitindo valores fora da faixa (por exemplo, negativos) e reduzindo o erro de arredondamento. Há inúmeros outros aprimoramentos de design descritos a seguir.

Para dar suporte a canais de pixel variáveis na API MagickCore, o tratamento de pixels mudou ao obter ou definir os canais de pixel. Você pode acessar os canais como um array, pixel[i], ou usar um método acessador como GetPixelRed() ou SetPixelRed(). Há algumas mudanças modestas nas APIs MagickCore e MagickWand. As APIs Magick++ e PerlMagick não mudaram e correspondem às do ImageMagick versão 6.

A API de shell (linha de comando) do ImageMagick versão 7 passou por uma grande reformulação, com ênfase específica na capacidade de ler 'opções' não apenas a partir da linha de comando, mas também a partir de scripts e fluxos de arquivo. Isso permite o uso de técnicas de programação de 'coprocessamento' ou a realização de tratamento de imagens usando 'backends de daemon/servidor' e até mesmo processamento distribuído em várias máquinas.

Com a reformulação da API de shell, outras melhorias foram feitas, incluindo: melhor relatório sobre qual opção falhou, a consolidação e a obsolescência de opções, e o uso mais global de 'propriedades de imagem' (mais comumente conhecidas como 'escapes de porcentagem') nos argumentos das opções.

O ImageMagick versão 7 está disponível agora como uma versão de produção.

Agora que o ImageMagick versão 7 foi lançado, continuamos a dar suporte à versão 6 por no mínimo 10 anos. O suporte à versão 6 limita-se principalmente a correções de bugs e patches de segurança, com poucos aprimoramentos.

Imagens de Alta Faixa Dinâmica (HDRI)

O ImageMagick versão 7 habilita por padrão imagens de alta faixa dinâmica (HDRI). O HDRI representa com precisão a ampla faixa de níveis de intensidade encontrados em cenas reais, indo da luz solar direta mais brilhante às sombras mais escuras e profundas. Além disso, os resultados do processamento de imagens são mais precisos. A desvantagem é que ele requer mais memória e pode resultar em tempos de processamento mais lentos. Se você notar diferenças nos resultados de sua linha de comando da versão 6 com a versão 7, isso provavelmente se deve ao HDRI. Talvez seja necessário adicionar -clamp à sua linha de comando para restringir os pixels à faixa de 0 a QuantumRange, ou desabilitar o HDRI ao compilar o ImageMagick versão 7. Para desabilitar o HDRI (recomendado para compilações em smartphones, como iOS, ou em sites de produção em que o desempenho é prioritário), basta adicionar --disable-hdri à linha de comando do script configure ao compilar o ImageMagick.

Canais de Pixel

Um pixel é composto por um ou mais valores de cor, ou canais (por exemplo, o canal de pixel vermelho).

Versões anteriores do ImageMagick (4-6) dão suporte a 4 ou 5 canais de pixel (RGBA ou CMYKA). Os primeiros 4 canais são acessados com a estrutura de dados PixelPacket. A estrutura inclui 4 membros do tipo Quantum (tipicamente 16 bits): vermelho, verde, azul e opacidade. O canal preto ou os índices de mapa de cores são suportados por um método e uma estrutura separados, IndexPacket. Como exemplo, eis um trecho de código do ImageMagick versão 6 que nega os componentes de cor (mas não o componente alfa) dos pixels da imagem:

for (y=0; y < (ssize_t) image->rows; y++)
{
  IndexPacket
    *indexes;

  PixelPacket
    *q;

  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
  if (q == (PixelPacket *) NULL)
    {
      status=MagickFalse;
      continue;
    }
  indexes=GetCacheViewAuthenticIndexQueue(image_view);
  for (x=0; x < (ssize_t) image->columns; x++)
  {
    if ((channel & RedChannel) != 0)
      q->red=(Quantum) QuantumRange-q->red;
    if ((channel & GreenChannel) != 0)
      q->green=(Quantum) QuantumRange-q->green;
    if ((channel & BlueChannel) != 0)
      q->blue=(Quantum) QuantumRange-q->blue;
    if (((channel & IndexChannel) != 0) &&
        (image->colorspace == CMYKColorspace))
      indexes[x]=(IndexPacket) QuantumRange-indexes[x];
    q++;
  }
  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
    status=MagickFalse;
}

O ImageMagick versão 7 dá suporte a qualquer número de canais, de 1 a 64 (e além), e simplifica o acesso com um único método que retorna um array de canais de pixel do tipo Quantum. O código-fonte que compila com versões anteriores do ImageMagick requer refatoração para funcionar com o ImageMagick versão 7. Ilustramos com um exemplo. Vamos refatorar ingenuamente o trecho de código da versão 6 acima para que funcione com a API do ImageMagick versão 7:

for (y=0; y < (ssize_t) image->rows; y++)
{
  Quantum
    *q;

  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
  if (q == (Quantum *) NULL)
    {
      status=MagickFalse;
      continue;
    }
  for (x=0; x < (ssize_t) image->columns; x++)
  {
    if ((GetPixelRedTraits(image) & UpdatePixelTrait) != 0)
      SetPixelRed(image,QuantumRange-GetPixelRed(image,q),q);
    if ((GetPixelGreenTraits(image) & UpdatePixelTrait) != 0)
      SetPixelGreen(image,QuantumRange-GetPixelGreen(image,q),q);
    if ((GetPixelBlueTraits(image) & UpdatePixelTrait) != 0)
      SetPixelBlue(image,QuantumRange-GetPixelBlue(image,q),q);
    if ((GetPixelBlackTraits(image) & UpdatePixelTrait) != 0)
      SetPixelBlack(image,QuantumRange-GetPixelBlack(image,q),q);
    if ((GetPixelAlphaTraits(image) & UpdatePixelTrait) != 0)
      SetPixelAlpha(image,QuantumRange-GetPixelAlpha(image,q),q);
    q+=GetPixelChannels(image);
  }
  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
    status=MagickFalse;
}

Vamos fazer isso novamente, mas aproveitando totalmente o novo suporte a canais de pixel variáveis:

for (y=0; y < (ssize_t) image->rows; y++)
{
  Quantum
    *q;

  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);
  if (q == (Quantum *) NULL)
    {
      status=MagickFalse;
      continue;
    }
  for (x = 0; x < (ssize_t) image->columns; x++)
  {
    ssize_t
      i;

    if (GetPixelWriteMask(image,q) <= (QuantumRange/2))
      {
        q+=GetPixelChannels(image);
        continue;
      }
    for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
    {
      PixelChannel channel = GetPixelChannelChannel(image,i);
      PixelTrait traits = GetPixelChannelTraits(image,channel);
      if ((traits & UpdatePixelTrait) == 0)
        continue;
      q[i]=QuantumRange-q[i];
    }
    q+=GetPixelChannels(image);
  }
  if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
    status=MagickFalse;
}

Observe como usamos GetPixelChannels() para avançar para o próximo conjunto de canais de pixel.

Os índices de mapa de cores e o canal de pixel preto (para o espaço de cor CMYK) não são mais armazenados no canal de índice, anteriormente acessado com GetAuthenticIndexQueue() e GetCacheViewAuthenticIndexQueue(). Em vez disso, eles agora são canais de pixel de primeira classe e são acessados como membros do array de pixels (por exemplo, pixel[4]) ou com os métodos acessadores de pixel de conveniência GetPixelIndex(), SetPixelIndex(), GetPixelBlack() e SetPixelBlack().

Como consequência do uso de uma estrutura de array para canais de pixel variáveis, os compiladores de autovetorização têm oportunidades adicionais de acelerar os laços de pixel.

O canal sync no IMv6 era na verdade um sinalizador, e não um canal. No IMv7, usamos em vez disso um sinalizador: -define compose:sync=false.

Acessadores de Pixel

Você pode acessar o canal de pixel como elementos de array (por exemplo, pixel[1]) ou usar acessadores de conveniência para obter ou definir canais de pixel:

GetPixela()                  SetPixela()
GetPixelAlpha()              SetPixelAlpha()
GetPixelb()                  SetPixelb()
GetPixelBlack()              SetPixelBlack()
GetPixelBlue()               SetPixelBlue()
GetPixelCb()                 SetPixelCb()
GetPixelCr()                 SetPixelCr()
GetPixelCyan()               SetPixelCyan()
GetPixelGray()               SetPixelGray()
GetPixelGreen()              SetPixelGreen()
GetPixelIndex()              SetPixelIndex()
GetPixelL()                  SetPixelL()
GetPixelMagenta()            SetPixelMagenta()
GetPixelReadMask()           SetPixelReadMask()
GetPixelWriteMask()          SetPixelWriteMask()
GetPixelMetacontentExtent()  SetPixelMetacontentExtent()
GetPixelOpacity()            SetPixelOpacity()
GetPixelRed()                SetPixelRed()
GetPixelYellow()             SetPixelYellow()
GetPixelY()                  SetPixelY()

Você encontra esses acessadores definidos no arquivo de cabeçalho MagickCore/pixel-accessor.h

Traits de Pixel

Cada canal de pixel inclui um ou mais destes traits:

Undefined
nenhum trait associado a este canal de pixel
Copy
não atualizar este canal de pixel, apenas copiá-lo
Update
atualizar este canal de pixel
Blend
mesclar este canal de pixel com a máscara alfa, se ela estiver habilitada

Fornecemos estes métodos para definir e obter os traits de pixel:

GetPixelAlphaTraits()    SetPixelAlphaTraits()
GetPixelBlackTraits()    SetPixelBlackTraits()
GetPixelBlueTraits()     SetPixelBlueTraits()
GetPixelCbTraits()       SetPixelCbTraits()
GetPixelChannelTraits()  SetPixelChannelTraits()
GetPixelCrTraits()       SetPixelCrTraits()
GetPixelGrayTraits()     SetPixelGrayTraits()
GetPixelGreenTraits()    SetPixelGreenTraits()
GetPixelIndexTraits()    SetPixelIndexTraits()
GetPixelMagentaTraits()  SetPixelMagentaTraits()
GetPixelRedTraits()      SetPixelRedTraits()
GetPixelYellowTraits()   SetPixelYellowTraits()
GetPixelYTraits()        SetPixelYTraits()

Por conveniência, você pode definir o trait ativo para um conjunto de canais de pixel com uma máscara de canal e este método:

SetImageChannelMask()

Anteriormente, os métodos do MagickCore tinham análogos por canal, por exemplo, NegateImage() e NegateImageChannels(). Os métodos análogos por canal não são mais necessários porque os traits do canal de pixel especificam se a operação deve atuar sobre um canal de pixel específico ou se deve mesclar com a máscara alfa. Por exemplo, em vez de

NegateImageChannel(image,channel);

usamos:

channel_mask=SetImageChannelMask(image,channel);
NegateImage(image,exception);
(void) SetImageChannelMask(image,channel_mask);

Canais de Usuário de Pixel

Na versão 7, introduzimos os canais de usuário de pixel. Tradicionalmente, utilizamos 4 canais: vermelho, verde, azul e alfa. Para CMYK, também temos um canal preto. Os canais de usuário são projetados para conter qualquer informação de canal adicional que faça sentido para sua aplicação. Alguns exemplos incluem canais extras em imagens TIFF ou PSD, ou talvez você precise de um canal com informação de infravermelho para o pixel. Você pode associar traits aos canais de usuário de modo que, quando forem processados por um algoritmo de processamento de imagem (por exemplo, desfoque), os pixels sejam copiados, processados pelo algoritmo ou até mesmo mesclados com o canal alfa, se isso fizer sentido.

Metaconteúdo de Pixel

Na versão 7, introduzimos o metaconteúdo de pixel. Metaconteúdo é conteúdo sobre conteúdo. Portanto, em vez de ser o conteúdo em si, é algo que descreve ou está associado ao conteúdo. Aqui, o conteúdo é um pixel. O metaconteúdo de pixel é de seu uso exclusivo (internamente, os dados são apenas copiados, não modificados) e é acessado com estes métodos da API MagickCore:

SetImageMetacontentExtent()
GetImageMetacontentExtent()
GetVirtualMetacontent()
GetAuthenticMetacontent()
GetCacheViewAuthenticMetacontent()
GetCacheViewVirtualMetacontent()

Alfa

Agora damos suporte ao alfa, anteriormente opacidade. Com o alfa, um valor de 0 significa que o pixel não tem nenhuma informação de cobertura e é transparente; ou seja, não houve contribuição de cor de nenhuma geometria porque a geometria não se sobrepôs a este pixel. Um valor de QuantumRange significa que o pixel é opaco porque a geometria se sobrepôs completamente ao pixel. Como consequência, na versão 7, o membro alpha da estrutura PixelInfo substituiu o membro opacity anterior. Outra consequência é que a parte alfa de um valor sRGB em notação hexadecimal agora está invertida (por exemplo, #0000 é totalmente transparente).

Espaço de Cor

Os espaços de cor Rec601Luma e Rec709Luma não são mais suportados. Em vez disso, especifique o espaço de cor gray e escolha entre estas opções de intensidade:

Rec601Luma
Rec601Luminance
Rec709Luma
Rec709Luminance

Por exemplo,

magick myImage.png -intensity Rec709Luminance -colorspace gray myImage.jpg

Escala de Cinza

Anteriormente, as imagens em escala de cinza eram Rec601Luminance e consumiam 4 canais: vermelho, verde, azul e alfa. Com a versão 7, a escala de cinza consome apenas 1 canal, exigindo muito menos recursos como resultado.

Máscaras

A versão 7 dá suporte a máscaras na maioria dos operadores de imagem. Pixels brancos em uma máscara de leitura fazem com que o pixel correspondente na imagem seja ignorado, enquanto pixels brancos em uma máscara de escrita protegem o pixel correspondente na imagem. A partir da linha de comando, você pode associar uma máscara a uma imagem com as opções -read-mask e -write-mask. Essa polaridade corresponde à das máscaras na versão 6 do ImageMagick para facilitar a portabilidade do seu fluxo de trabalho. Por conveniência, continuamos a dar suporte à opção -mask na versão 7 para corresponder ao comportamento da versão 6.

Neste exemplo, calculamos a distorção de uma imagem reconstruída com máscara:

compare -metric rmse -read-mask hat_mask.png hat.png wizard.png difference.png

Aqui protegemos certos pixels de alterações:

magick rose: -write-mask rose_bg_mask.png -modulate 110,100,33.3  +write-mask rose_blue.png

Uma máscara associada a uma imagem persiste até ser modificada ou removida. Isso pode produzir resultados inesperados em linhas de comando complexas. Aqui queremos recortar apenas ao aplicar a opção alpha, não no redimensionamento:

magick -density 300 -colorspace srgb image.eps -alpha transparent -clip -alpha opaque +clip -resize 1000x1000 -strip image.png

API MagickCore

Eis uma lista das mudanças na API MagickCore:

  • Quase todos os algoritmos de processamento de imagem agora reconhecem canais.
  • A API MagickCore adiciona um argumento ExceptionInfo aos métodos que não o tinham na versão 6, por exemplo, NegateImage(image,MagickTrue,exception)
  • Todos os métodos análogos por canal foram removidos (por exemplo, BlurImageChannel()); eles não são mais necessários, use traits de pixel em vez disso.
  • As chamadas de API públicas e privadas agora são declaradas com o atributo de visibility do GCC. As bibliotecas dinâmicas MagickCore e MagickWand agora exportam apenas declarações públicas de struct e função.
  • O enum InterpolatePixelMethod agora é PixelInterpolateMethod.
  • O tipo de armazenamento IntegerPixel foi removido (use LongPixel em vez dele) e LongLongPixel foi adicionado.
  • As assinaturas de imagem mudaram para contemplar os canais de pixel variáveis.
  • Todas as estruturas de pacote de cor, PixelPacket, LongPacket e DoublePacket, foram consolidadas em uma única estrutura de cor, PixelInfo.
  • O membro I da estrutura ChannelMoments agora é invariante. I entra em conflito com o cabeçalho complex.h.
  • Adicionamos um parâmetro length a FormatMagickSize() para permitir buffers de comprimento variável.

API MagickWand

Eis uma lista das mudanças na API MagickWand:

  • Quase todos os algoritmos de processamento de imagem agora reconhecem canais.
  • O método DrawMatte() agora se chama DrawAlpha().
  • Os métodos MagickSetImageBias() e MagickSetImageClipMask() não são mais suportados.

API Magick++

Eis uma lista das mudanças na API Magick++:

  • Quase todos os algoritmos de processamento de imagem agora reconhecem canais.
  • Use esta construção, por exemplo, para evitar operar sobre o canal alfa: 
    image.negateChannel(Magick::ChannelType(Magick::CompositeChannels ^ Magick::AlphaChannel));

Arquivos de Cabeçalho

Versões anteriores do ImageMagick (4-6) referenciam os arquivos de cabeçalho do ImageMagick como magick/ e wand/. O ImageMagick 7 usa, em vez disso, MagickCore/ e MagickWand/, respectivamente. Por exemplo,

#include <MagickCore/MagickCore.h>
#include <MagickWand/MagickWand.h>

Recursos Obsoletos Removidos

Todos os recursos obsoletos do ImageMagick versão 6 foram removidos na versão 7. Estes incluem os utilitários de configuração Magick-config e Wand-config. Em vez disso, use:

MagickCore-config
MagickWand-config

O método FilterImage() foi removido. Use ConvolveImage() em vez dele.

Além disso, todos os métodos obsoletos do MagickCore e do MagickWand não estão mais disponíveis na versão 7.

O filtro Bessel foi removido, pois é um alias para Jinc. Use -filter Jinc em vez dele.

API de Shell ou Interface de Linha de Comando

Como mencionado, o foco principal das mudanças na API de Shell ou Interface de Linha de Comando é a abstração, de modo que as opções possam ser lidas não apenas a partir dos argumentos da linha de comando, mas também a partir de um arquivo (script) ou de um fluxo de arquivo (comandos interativos ou coprocessamento).

Para fazer isso, o analisador da CLI precisou ser reescrito de modo a sempre executar todas as opções em uma ordem estrita, do tipo "faça conforme você vê". Anteriormente, no IMv6, as opções eram executadas em grupos (conhecidos como 'FireOptions'); essa inconveniência agora desapareceu. No entanto, a ordem estrita significa que você não pode mais fornecer operações antes de fornecer uma imagem sobre a qual as operações devem atuar. Fazer isso agora produzirá um erro.

O relatório de erros agora informa exatamente qual opção (pela contagem de argumentos na linha de comando, ou pela linha,coluna em scripts) causou a 'exceção'. Isso ainda não está completo, mas está melhorando. Também não está completo o tratamento de 'regard-warnings' ou sua substituição, que permitirá ignorar os erros relatados e continuar o processamento (conforme apropriado em razão do erro) em coprocessos ou no uso interativo.

Com o analisador do IMv7, ativado pelo utilitário magick, as configurações são aplicadas a cada imagem na memória, por sua vez (se houver). Enquanto uma option: só precisa ser aplicada uma vez, globalmente. Usar os outros utilitários diretamente, ou como argumento da CLI magick (por exemplo, magick), utiliza o analisador legado.

As opções de parênteses, usadas para 'empurrar' (push) a lista de imagens atual e as configurações de imagem (por exemplo, '(' e ')') para uma pilha, agora têm uma pilha de configurações de imagem completamente separada. Ou seja, os parênteses 'empurram/puxam' (push/pull) listas de imagens, e as chaves (por exemplo, '{' e '}') 'empurram/puxam' configurações de imagem.

É claro que, devido às mudanças no tratamento subjacente de canais relatadas anteriormente, haverá muitos efeitos colaterais em quase todas as opções. Eis alguns específicos

A maioria dos algoritmos atualiza os canais vermelho, verde, azul, preto (para CMYK) e alfa. A maioria dos operadores mescla o alfa com os demais canais de cor, mas outros operadores (e situações) podem exigir que essa mesclagem seja desabilitada, o que atualmente é feito removendo o alfa dos canais ativos por meio da opção -channel (por exemplo, magick castle.gif -channel RGB -negate castle.png).

Ler imagens em escala de cinza gera uma imagem com apenas um canal. Se essa imagem precisar então aceitar cor, a configuração -colorspace deve ser aplicada para expandir o único canal em canais RGB (ou outros) separados.

Anteriormente, os argumentos da linha de comando eram limitados a 4096 caracteres; com o ImageMagick versão 7, o limite aumentou para 131072 caracteres.

Mudanças nos Comandos

Eis uma lista das mudanças nos comandos do ImageMagick:

magick
IMPORTANTE: O comando " magick" é o novo comando primário da API de Shell, substituindo o antigo comando "convert". Isso permite criar um 'script magick' na forma "#!/path/to/command/magick -script" ou canalizar opções para um comando "magick -script -", como um processo em segundo plano.
magick-script
É o mesmo que "magick" (apenas o nome do comando é diferente), mas que tem uma opção "-script" implícita. Isso permite usá-lo em uma forma de script no estilo "env". Ou seja, um script magick começa com a linha 'she-bang' "#!/usr/bin/env magick-script", permitindo que o interpretador de scripts seja encontrado em qualquer lugar do "PATH" de comandos do usuário. Isso é necessário para contornar um "bug da she-bang de um argumento" comum na maioria dos sistemas UNIX (incluindo Linux, mas não MacOSX).
animate, compare, composite, conjure, convert, display, identify, import, mogrify, montage, stream
Para reduzir a pegada dos utilitários de linha de comando, esses utilitários são links simbólicos para o utilitário magick. No Windows, esses utilitários são instalados como executáveis separados, e o executável legado convert não é mais incluído. Você também pode invocá-los a partir do utilitário magick; por exemplo, use magick logo: logo.png para invocar o utilitário magick. (Em outras palavras, chame esses utilitários precedendo-os com magick, como magick compare, magick identify, magick mogrify, magick montage, etc. Não use magick convert. Isso é simplesmente magick)

Mudanças de Comportamento

As configurações de imagem são aplicadas a cada imagem na linha de comando. Para associar uma configuração a uma imagem específica, use parênteses para remover a ambiguidade. Neste exemplo, atribuímos um deslocamento de página único a cada imagem:

magick \( -page +10+20 first.png \) \( -page +100+200 second.png \) ...

Por padrão, operações de imagem como a convolução mesclam o alfa com cada canal. Para convolver cada canal de forma independente, desative o canal alfa da seguinte maneira:

magick ... -alpha discrete -blur 0x1 ...

Para remover os valores alfa da sua imagem, use -alpha off. Se, em vez disso, você quiser manter o canal alfa, mas não mesclar os pixels alfa em determinadas operações de processamento de imagem, use -alpha deactivate.

Algumas opções mudaram no ImageMagick versão 7. Estas incluem:

-channel
o padrão é atualizar os canais RGBA; anteriormente, no IMv6, o padrão era RGB. Se você obtiver resultados diferentes do IMv6, talvez seja necessário especificar -channel RGB na sua linha de comando (por exemplo, -channel RGB -negate).
+combine
Esta opção agora requer um argumento, o espaço de cor da imagem (por exemplo, +combine sRGB).
-format
A propriedade de imagem %Z não é mais suportada.
-gamma
Múltiplos argumentos de gama (por exemplo, -gamma 1,2,3) não são mais suportados; em vez disso, use -channel (por exemplo, -channel blue -gamma 2).
-region
Esta opção define uma máscara de escrita para a região que você definir. No IMv6, em vez disso, uma imagem separada era clonada, processada, e os resultados eram compostos sobre a imagem de origem. Além disso, as transformações de draw são relativas ao canto superior esquerdo da imagem; anteriormente, no IMv6, elas eram relativas à região.

Use -define morphology:showKernel=1 para exibir o núcleo de morfologia ou convolução. Anteriormente era -define showKernel=1.

Novas Opções

O ImageMagick versão 7 dá suporte a estas novas opções, embora a maioria esteja limitada ao comando "magick" ou ao uso em scripts "magick".

{ ... }
Salva (e restaura) as configurações de imagem atuais (internamente conhecidas como estrutura "image_info"). Isso é feito automaticamente com parênteses (por exemplo, '(' e ')') se "-regard-parenthesis" tiver sido definido, assim como no IMv6. Recomenda-se cautela para evitar erros de chaves desbalanceadas.
--
Fim das opções, a ser usado no comando "mogrify" do IMv7 para separar explicitamente as operações a serem aplicadas das imagens que devem ser processadas 'no lugar' (in-place). (ainda não implementado). No entanto, se não for fornecido, "-read" ainda pode ser usado para diferenciar leituras de imagens secundárias (para uso em coisas como composição alfa) da imagem 'no lugar' que está sendo processada. Em outros comandos (como "magick"), é equivalente a um "-read" explícito (veja abaixo) da próxima opção como uma imagem (como era no IMv6).
-alpha activate/deactivate
habilita e desabilita o canal alfa, respectivamente, com persistência. Isso é como o on/off no ImageMagick 6. No ImageMagick 7, -alpha off removerá o canal alfa permanentemente, de modo que -alpha on não o reabilitará.
-alpha discrete
trata o canal alfa de forma independente (não mescla).

-channel-fx expression

troca, extrai ou copia um ou mais canais de imagem.

A expressão consiste em um ou mais canais, mnemônicos ou numéricos (por exemplo, red ou 0, green ou 1, etc.), separados por certos símbolos de operação, da seguinte forma:

<=>  troca dois canais (e.g. red<=>blue)
=>   copia um canal para outro canal (e.g. red=>green)
=    atribui um valor constante a um canal (e.g. red=50%)
,    escreve uma nova imagem com os canais na ordem especificada (e.g. red, green)
;    adiciona uma nova imagem de saída para o próximo conjunto de operações de canal (e.g. red; green; blue)
|    move para a próxima imagem de entrada como fonte dos dados de canal (e.g. | gray=>alpha)

Por exemplo, para criar 3 imagens em escala de cinza a partir dos canais vermelho, verde e azul de uma imagem, use:

-channel-fx "red; green; blue"

Um canal sem um símbolo de operação implica separar (ou seja, ponto e vírgula).

Aqui pegamos uma imagem sRGB e uma imagem em escala de cinza e injetamos a imagem em escala de cinza no canal alfa:

magick wizard.png mask.pgm -channel-fx '| gray=>alpha' wizard-alpha.png

Use um comando semelhante para definir uma máscara de leitura:

magick wizard.png mask.pgm -channel-fx '| gray=>read-mask' wizard-mask.png

Adicione -debug pixel antes da opção -channel-fx para rastrear a morfologia de canal.

-exit
Interrompe o processamento neste ponto. Nenhuma opção adicional será processada após esta opção. Pode ser usada em um script para forçar o comando "magick" a sair, sem realmente fechar o pipeline do qual ele está processando as opções. Também pode ser usada como uma opção 'final' na linha de comando "magick", em vez de uma imagem de saída implícita, para impedir completamente qualquer escrita de imagem. NOTA: até mesmo o codificador "NULL:" requer pelo menos uma imagem para 'não escrever'! Esta opção não requer nenhuma imagem.
-read
Leitura explícita de uma imagem, em vez de uma leitura implícita. Isso permite ler a partir de nomes de arquivo que começam com um caractere de 'opção' e que, de outra forma, poderiam ser confundidos com uma opção (conhecida ou não). Isso será eventualmente usado no "mogrify" para permitir a leitura de imagens secundárias e permitir o uso de operações de lista de imagens dentro desse comando.
-read-mask
impede atualizações nos pixels da imagem especificados pela máscara
-region
suportada no ImageMagick 7.0.2-6 e superior
-script
No "magick", interrompe o processamento dos argumentos da linha de comando como operações de imagem e lê todas as opções subsequentes a partir do arquivo ou pipeline fornecido.
-write-mask
impede que os pixels sejam escritos.

Opções Modificadas

Sabe-se que estas opções mudaram de alguma forma.

-bias
A opção não é mais reconhecida. Use -define convolve:bias=value em vez dela.
-draw
A primitiva matte agora é alpha (por exemplo, -draw 'alpha 0,0 floodfill').
-negate
atualmente nega todos os canais, incluindo o alfa, se presente. Por isso, talvez seja necessário usar a opção -channel para evitar a negação do alfa (por exemplo, -channel RGB -negate).
-preview
esta opção agora é um operador de imagem. O formato de imagem PREVIEW foi removido.

Aviso de obsolescência exibido, mas que funciona (por enquanto)

-affine
Substituída por -draw "affine ...". (veja transform)
-average
Substituída por -evaluate-sequence Mean.
-box
Substituída por -undercolor.
-deconstruct
Substituída por -layers CompareAny.
-gaussian
Substituída por -gaussian-blur.
-/+map
Substituída por -/+remap.
-/+mask
Substituída por -/+read-mask, -/+write-mask.
-/+matte
Substituída por -alpha Set/Off.
-transform
Substituída por -distort Affine "...".

Aviso de obsolescência exibido, e ignorado (por enquanto)

Quase toda opção 'plus' (+) que não fazia nada foi marcada como obsoleta e não faz nada. Ela nem sequer tem código associado. Por exemplo, "+annotate", "+resize", "+clut" e "+draw".

-affinity
Substituída por -remap.
-maximum
Substituída por -evaluate-sequence Max.
-median
Substituída por -evaluate-sequence Median.
-minimum
Substituída por -evaluate-sequence Min.
-recolor
Substituída por -color-matrix.

Opções Removidas / Substituídas (erro "no such option" e abortagem)

-interpolate filter
remove um método de interpolação lento e inútil
-origin
opção antiga, significado desconhecido.
-pen
Substituída por -fill.
-passphrase
opção antiga, significado desconhecido

Melhorias de Desempenho

A operação sobre imagens em escala de cinza foi significativamente melhorada, pois apenas um canal é necessário. Anteriormente, a escala de cinza exigia três canais.

O desempenho da opção -fx aumentou em uma a duas ordens de magnitude.

Resumo das Mudanças da Versão 7

As mudanças do ImageMagick versão 6 para a versão 7 estão resumidas aqui:

Imagens de Alta Faixa Dinâmica (HDRI)

  • O ImageMagick versão 7 habilita o HDRI por padrão. Espere resultados de processamento de imagem mais precisos, com maiores requisitos de memória e possíveis tempos de processamento mais lentos. Você pode desabilitar esse recurso em sistemas com recursos limitados, como um celular, com uma leve perda de precisão em certos algoritmos (por exemplo, redimensionamento).

Pixels

  • Os pixels não são mais endereçados por meio dos membros da estrutura PixelPacket (por exemplo, red, green, blue, opacity), mas como um array de canais (por exemplo, pixel[PixelRedChannel]).
  • Use macros de conveniência para acessar os canais de pixel (por exemplo, GetPixelRed(), SetPixelRed()).
  • O canal preto do espaço de cor CMYK não é mais armazenado no canal de índice, anteriormente acessado com GetAuthenticIndexQueue() e GetCacheViewAuthenticIndexQueue(). Em vez disso, ele agora é um canal de pixel e é acessado com as macros de pixel de conveniência GetPixelBlack() e SetPixelBlack().
  • O canal de índice para imagens com mapa de cores não é mais armazenado no canal de índice, anteriormente acessado com GetAuthenticIndexQueue() e GetCacheViewAuthenticIndexQueue(). Em vez disso, ele agora é um canal de pixel e é acessado com as macros de pixel de conveniência GetPixelIndex() e SetPixelIndex().
  • Use GetPixelChannels() para avançar para o próximo conjunto de canais de pixel.
  • Use o canal de metaconteúdo para associar metaconteúdo a cada pixel.
  • Todas as estruturas de pacote de cor, PixelPacket, LongPacket e DoublePacket, foram consolidadas em uma única estrutura de cor, PixelInfo.

Alfa

  • Damos suporte ao alfa em vez de opacidade (0 transparente; QuantumRange opaco).
  • Use GetPixelAlpha() ou SetPixelAlpha() para obter ou definir o valor do canal de pixel alfa.

Escala de Cinza

  • As imagens em escala de cinza consomem um canal de pixel no ImageMagick versão 7. Para processar RGB, defina o espaço de cor como RGB (por exemplo, -colorspace sRGB).

Máscaras

  • O ImageMagick versão 6 dá suporte à máscara de leitura apenas em circunstâncias limitadas. A versão 7 dá suporte a uma máscara de leitura e a uma máscara de escrita. A máscara de leitura é respeitada pela maioria dos algoritmos de processamento de imagem.

API MagickCore

  • Quase todos os algoritmos de processamento de imagem agora reconhecem canais.
  • O MagickCore, versão 7, adiciona um argumento ExceptionInfo aos métodos que não o tinham na versão 6, por exemplo, NegateImage(image,MagickTrue,exception);
  • Todos os métodos análogos por canal foram removidos (por exemplo, BlurImageChannel()); eles não são mais necessários, use traits de pixel em vez disso.
  • As chamadas de API públicas e privadas agora são declaradas com o atributo de visibility do GCC. As bibliotecas dinâmicas MagickCore e MagickWand agora exportam apenas declarações públicas de struct e função.
  • O enum InterpolatePixelMethod agora é PixelInterpolateMethod.
  • Para contemplar os canais de pixel variáveis, as imagens agora podem retornar uma assinatura diferente.

Métodos Obsoletos

  • Todos os métodos obsoletos do MagickCore e do MagickWand do ImageMagick versão 6 foram removidos e não estão mais disponíveis no ImageMagick versão 7.
  • Todos os métodos análogos por canal do MagickCore foram removidos (por exemplo, NegateImageChannels()). Para a versão 7, use traits de pixel em vez disso.
  • O método FilterImage() foi removido. Use ConvolveImage() em vez dele.

Original: https://imagemagick.org/porting/