Compartilhar via

Alfa pré-multiplicado

  • Artigo

Em elementos gráficos de computação, há duas maneiras diferentes de representar a opacidade de um valor de cor. O Win2D usa ambos os métodos. Este artigo explica a diferença e qual é usada onde.

Alfa reto

Ao usar linha reta, também conhecida como linear, alfa:

  • Os valores RGB especificam a cor da coisa que está sendo desenhada
  • O valor alfa especifica o quão sólido ele é

Neste mundo, RGB e alfa são independentes. Você pode alterar um sem afetar o outro. Para fazer com que um objeto esmaeça, você reduzirá gradualmente seu valor alfa, deixando o RGB inalterado.

Para executar uma combinação de origem entre duas cores que usam o formato alfa reto:

result = (source.RGB * source.A) + (dest.RGB * (1 - source.A))

Alfa pré-multiplicado

Ao usar alfa pré-multiplicado:

  • RGB especifica quanta cor a coisa que está sendo desenhada contribui para a saída
  • O valor alfa especifica o quanto ele obscurece o que está por trás dele

Neste mundo, RGB e alfa estão vinculados. Para tornar um objeto transparente, você deve reduzir seu RGB (para contribuir com menos cores) e também seu alfa (para obscurecer menos do que está por trás dele). Objetos totalmente transparentes não têm mais nenhuma cor, portanto, há apenas um valor que representa 100% de transparência: RGB e alfa todos zero.

Para executar uma combinação de origem entre duas cores que usam o formato alfa pré-multiplicado:

result = source.RGB + (dest.RGB * (1 - source.A))

Alfa pré-multiplicado é usado na renderização de gráficos porque fornece melhores resultados do que alfa reto ao filtrar imagens ou compor camadas diferentes. Para obter mais informações, consulte os artigos:

Alfa no Win2D

O Win2D usa alfa reto em sua superfície de API, mas alfa pré-multiplicado para operações de renderização internas.

Windows.UI.Color os valores usam alfa reto. Sempre que você passa uma cor para um Draw* método ou Fill* , defina a cor de um pincel ou desmarque como um valor de cor, essa cor é especificada usando alfa reto.

Os valores de pixel armazenados em um bitmap ou rendertarget e as operações de desenho ou mesclagem que operam nessas superfícies usam alfa pré-multiplicado. Quando bitmaps são carregados de um arquivo, seu conteúdo é convertido automaticamente em formato pré-multiplicado. Quando você chama um método de desenho Win2D, seu parâmetro de cor é convertido de reto para pré-multiplicado antes que o desenho real ocorra.

Os efeitos de imagem Win2D usam uma mistura de alfa reto e pré-multiplicado. Alguns efeitos operam em um formato, alguns no outro e outros fornecem uma propriedade a ser escolhida. A documentação de cada tipo de efeito descreve qual modo alfa ele usa. Os dados de entrada de efeito sempre são considerados pré-multiplicados, portanto, quando um efeito precisa funcionar com alfa reto, ele primeiro aplicará uma transformação não adequada, calculará o efeito e, em seguida, pré-multiplicará a saída novamente.

As APIs GetPixelBytesde bitmap , SetPixelBytes, GetPixelColorse SetPixelColorsnão executam nenhuma conversão de formato alfa. Eles apenas transferem diretamente valores de bits para ou da textura de GPU subjacente. Isso permite observar o formato alfa que o Win2D está usando internamente:

  • Criar uma sessão de desenho em um rendertarget
  • Chama drawingSession.Clear(Colors.Tranparent)
  • Colors.Tranparent é definido como R = 255, G = 255, B = 255, A = 0
  • O Win2D converterá esse valor em formato pré-multiplicado, produzindo R = 0, G = 0, B = 0, A = 0
  • Use GetPixelColors para ler novamente o conteúdo do rendertarget
  • Observe que ele contém o formato pré-multiplicado RGB = 0, não RGB = 255 como o valor alfa Colors.Tranparent reto original

Convertendo entre formatos alfa

Para converter um valor de cor alfa reta em formato pré-multiplicado, multiplique seus valores R, G e B por A. Para converter premultiplied em linha reta, divida R, G e B por A.

Observe que as informações de cor geralmente são representadas como valores de bytes que variam de 0 a 255 (por exemplo, a Windows.UI.Color estrutura consiste em 4 bytes). Essa representação é escalada verticalmente por um fator de 255, portanto, um valor de byte de 255 realmente significa 1, enquanto 128 é de meia intensidade. Esse fator de dimensionamento deve ser levado em conta durante as conversões de formato, portanto, para converter um Windows.UI.Color de direto para pré-multiplicado:

premultiplied.R = (byte)(straight.R * straight.A / 255);
premultiplied.G = (byte)(straight.G * straight.A / 255);
premultiplied.B = (byte)(straight.B * straight.A / 255);
premultiplied.A = straight.A;

Se você tiver dados de imagem que estejam usando o formato PremultiplyEffect alfa incorreto ou UnPremultiplyEffect que possam ser usados para convertê-los.