Alfa pré-multiplicado
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
GetPixelColorspara 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.Tranparentdireto 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.
Windows developer