Share via

Alfa premultiplicado

  • Artículo

En los gráficos informáticos 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 dónde se usa.

Alfa recto

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

  • Los valores RGB especifican el color de lo que se dibuja
  • El valor alfa especifica cómo es sólido.

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 mientras deja RGB sin cambios.

Para realizar una combinación de origen por encima entre dos colores que usan el formato alfa recto:

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

Alfa premultiplicado

Al usar alfa premultiplicado:

  • RGB especifica cuánto color contribuye el elemento que se dibuja 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, por lo que solo hay un valor que representa una transparencia del 100 %: RGB y alfa todo cero.

Para realizar una combinación de origen por encima entre dos colores que usan formato alfa premultipado:

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

El alfa premultiplicado se usa en la representación de gráficos porque proporciona mejores resultados que alfa rectos al filtrar imágenes o componer diferentes capas. Para obtener más información, consulte los artículos:

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 el 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 premultiplido. 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 tenga lugar 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. En la documentación de cada tipo de efecto se 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 premultiplicada, calcule el efecto y, a continuación, vuelva a premultiplicar 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 premultiplido, lo que producirá R = 0, G = 0, B = 0, A = 0
  • Use GetPixelColors para leer el contenido del rendertarget.
  • Observe que contiene formato premultiplicado 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 al formato premultipado, multiplique sus valores R, G y B por A. Para convertir premultiplido en recto, divida R, G y B por A.

Tenga en cuenta que la información de color se representa a menudo 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 mediante 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 para 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 PremultiplyEffectUnPremultiplyEffect se puede usar para convertirlos.