Compartir a través de

Alfa premultiplicado

  • Artículo

En los gráficos de equipo hay dos maneras diferentes de representar la opacidad de un valor de color. Win2D usa ambos métodos. En este artículo se explica la diferencia, y donde se usa.

Alfa recto

Cuando se usa recta, también conocida como lineal, alfa:

  • Los valores RGB especifican el color de la cosa que se está dibujando
  • El valor alfa especifica la solidez que es

En este mundo, RGB y alfa son independientes. Puede cambiar uno sin afectar al otro. Para que un objeto se desvanezca, reduciría gradualmente su valor alfa y dejaría RGB sin cambios.

Para realizar una combinación de origen a través entre dos colores que usan el formato alfa recto:

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

Alfa premultiplicado

Al usar alfa premultipado:

  • RGB especifica la cantidad de color que se va a dibujar contribuye a la salida.
  • El valor alfa especifica cuánto oculta lo que está detrás de él.

En este mundo, RGB y alfa están vinculados. Para que un objeto sea transparente, debe reducir su RGB (para contribuir menos color) y también su alfa (para ocultar menos lo que esté detrás de él). Los objetos totalmente transparentes ya no tienen ningún color en absoluto, por lo que solo hay un valor que representa la transparencia del 100 %: RGB y alfa todos los ceros.

Para realizar una combinación de origen a través entre dos colores que usan el formato alfa premultipado:

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

El alfa premultipado se usa en la representación de gráficos porque proporciona mejores resultados que alfa recto al filtrar imágenes o componer diferentes capas. Para obtener más información, consulte estas entradas de blog:

Alfa en Win2D

Win2D usa alfa recto en su superficie de API, pero alfa premultipado para las operaciones de representación internas.

Windows.UI.Color los valores usan alfa recto. Cada vez que se pasa un color a un Draw* método o Fill* , se establece el color de un pincel o se borra en un valor de color, este color se especifica mediante alfa recto.

Los valores de píxel almacenados en un mapa de bits o rendertarget, y las operaciones de dibujo o mezcla que operan en estas superficies, usan alfa premultiplicado. Cuando los mapas de bits se cargan desde un archivo, su contenido se convierte automáticamente en formato premultiplicado. Cuando se llama a un método de dibujo Win2D, su parámetro de color se convierte de directo a premultiplido antes de que se produzca el dibujo real.

Los efectos de imagen win2D usan una mezcla de alfa recto y premultiplicado. Algunos efectos funcionan en un formato, algunos en el otro, y algunos proporcionan una propiedad para elegir. La documentación de cada tipo de efecto describe el modo alfa que usa. Siempre se supone que los datos de entrada de efecto se premultiplican, por lo que cuando un efecto necesita trabajar con alfa recto, primero aplicará una transformación no premultipada, calcule el efecto y, a continuación, vuelva a generar la salida.

Las API GetPixelBytesde mapa de bits , SetPixelBytes, GetPixelColorsy SetPixelColors, no realizan ninguna conversión de formato alfa. Simplemente transfieren directamente valores de bits a o desde la textura de GPU subyacente. Esto le permite observar qué formato alfa Win2D usa internamente:

  • Creación de una sesión de dibujo en un rendertarget
  • Llame a drawingSession.Clear(Colors.Tranparent)
  • Colors.Tranparent se define como R = 255, G = 255, B = 255, A = 0
  • Win2D convertirá este valor en formato premultipado, lo que producirá R = 0, G = 0, B = 0, A = 0
  • Use GetPixelColors para leer el contenido de rendertarget.
  • Observe que contiene formato premultiplido RGB = 0, no RGB = 255 como el valor alfa Colors.Tranparent recto original

Conversión entre formatos alfa

Para convertir un valor de color alfa recto a formato premultipado, multiplique sus valores R, G y B por A. Para convertir la información premultipada a recta, divida R, G y B por A.

Tenga en cuenta que la información de color se suele representar como valores de bytes comprendidos entre 0 y 255 (por ejemplo, la Windows.UI.Color estructura consta de 4 bytes). Esta representación se escala verticalmente por un factor de 255, por lo que un valor de byte de 255 significa realmente 1, mientras que 128 es la intensidad media. Ese factor de escalado debe tenerse en cuenta durante las conversiones de formato, por lo que se debe convertir un Windows.UI.Color de directo a premultiplicado:

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;

Si tiene datos de imagen que usan el formato alfa incorrecto o PremultiplyEffect UnPremultiplyEffect se puede usar para convertirlo.