Ler em inglês

Compartilhar via

Alfa pré-multiplicado

  • Artigo

Em computação gráfica, existem duas maneiras diferentes de representar a opacidade de um valor de cor. O Win2D usa os dois métodos. Este artigo explica a diferença e qual é usado onde.

Alfa direto

Ao usar alfa reto, também conhecido como linear:

  • 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 um objeto desaparecer, você reduziria gradualmente seu valor alfa, deixando o RGB inalterado.

Para executar uma mesclagem de origem entre duas cores que usam o formato alfa direto:

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 ligados. Para tornar um objeto transparente, você deve reduzir seu RGB (para contribuir com menos cor) e também seu alfa (para obscurecer menos o 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 mesclagem de origem entre duas cores que usam o formato alfa pré-multiplicado:

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

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

Alfa em Win2D

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

Windows.UI.Color Os valores usam alfa direto. Sempre que você passa uma cor para um Draw* método or Fill* , define a cor de um pincel ou limpa para um valor de cor, essa cor é especificada usando alfa direto.

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 os 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 direto para pré-multiplicado antes que o desenho real ocorra.

Os efeitos de imagem Win2D usam uma mistura de alfa direto e pré-multiplicado. Alguns efeitos operam em um formato, outros no outro, e alguns fornecem uma propriedade para escolher. A documentação de cada tipo de efeito descreve qual modo alfa ele usa. Os dados de entrada do efeito são sempre considerados pré-multiplicados, portanto, quando um efeito precisa funcionar com alfa direto, ele primeiro aplica uma transformação não pré-multiplicada, calcula o efeito e, em seguida, re-pré-multiplica a saída.

As APIs GetPixelBytesde bitmap , SetPixelBytes, GetPixelColorse SetPixelColors, não executam nenhuma conversão de formato alfa. Eles apenas transferem valores de bits diretamente de ou para a textura subjacente da GPU. Isso permite que você observe qual formato alfa 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 para o formato pré-multiplicado, gerando R = 0, G = 0, B = 0, A = 0
  • Use GetPixelColors para ler 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 direto original

Conversão entre formatos alfa

Para converter um valor de cor alfa direto para o formato pré-multiplicado, multiplique seus valores R, G e B por A. Para converter pré-multiplicado em reto, 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 é ampliada por um fator de 255, portanto, um valor de byte de 255 na verdade significa 1, enquanto 128 é metade da intensidade. Esse fator de escala deve ser levado em consideração 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 estão usando o formato PremultiplyEffect alfa errado ou UnPremultiplyEffect podem ser usados para convertê-los.