Condividi tramite

Valori alfa premoltiplicati

  • Articolo

Nella grafica del computer esistono due modi diversi per rappresentare l'opacità di un valore di colore. Win2D usa entrambi i metodi. Questo articolo illustra la differenza e viene usato dove.

Alfa dritto

Quando si usa un valore lineare, noto anche come lineare, alfa:

  • I valori RGB specificano il colore della cosa da disegnare
  • Il valore alfa specifica il modo in cui è solido

In questo mondo, RGB e alfa sono indipendenti. È possibile modificarne una senza influire sull'altra. Per ridurre la dissolvenza di un oggetto, si ridurrà gradualmente il valore alfa lasciando RGB invariato.

Per eseguire una fusione di origine tra due colori che usano il formato alfa dritto:

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

Valori alfa premoltiplicati

Quando si usa alfa premoltiplicato:

  • RGB specifica la quantità di colore che l'elemento disegnato contribuisce all'output
  • Il valore alfa specifica quanto nasconde ciò che è dietro di esso

In questo mondo, RGB e alfa sono collegati. Per rendere trasparente un oggetto è necessario ridurre sia il suo RGB (per contribuire meno colore) che anche il suo alfa (per nascondere meno di qualsiasi cosa sia dietro di esso). Gli oggetti completamente trasparenti non hanno più alcun colore, quindi esiste un solo valore che rappresenta la trasparenza del 100%: RGB e alfa tutti zero.

Per eseguire una fusione di origine tra due colori che usano il formato alfa premoltiplicato:

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

L'alfa premoltiplicato viene usato nel rendering grafico perché offre risultati migliori rispetto all'alfa retto quando si filtrano immagini o si compongono livelli diversi. Per altre informazioni, vedere questi post di blog:

Alfa in Win2D

Win2D usa alfa dritto nella superficie DELL'API, ma alfa premoltiplicato per le operazioni di rendering interne.

Windows.UI.Color i valori usano alfa dritto. Ogni volta che passi un colore a un metodo Draw* o Fill* imposta il colore di un pennello o cancella su un valore di colore, questo colore viene specificato utilizzando alfa dritto.

I valori pixel archiviati in una bitmap o in un oggetto rendertarget e le operazioni di disegno o fusione che operano su queste superfici, usano alfa premoltiplicato. Quando le bitmap vengono caricate da un file, il loro contenuto viene convertito automaticamente in formato premoltiplicato. Quando chiami un metodo di disegno Win2D, il relativo parametro di colore viene convertito da direttamente a premoltiplicato prima che venga eseguito il disegno effettivo.

Gli effetti dell'immagine Win2D usano una combinazione di alfa dritto e premoltiplicato. Alcuni effetti operano su un formato, altri sull'altro e alcuni forniscono una proprietà da scegliere. La documentazione per ogni tipo di effetto descrive la modalità alfa usata. Si presuppone che i dati di input dell'effetto siano sempre premoltiplicati, quindi quando un effetto deve funzionare con alfa dritto, applicherà prima una trasformazione non premoltiplicata, calcola l'effetto e quindi premoltiplica l'output.

Le API bitmap GetPixelBytes, SetPixelBytes, GetPixelColorse SetPixelColorsnon eseguono conversioni di formato alfa. Trasferiscono direttamente i valori di bit da o verso la trama GPU sottostante. In questo modo è possibile osservare il formato alfa usato da Win2D internamente:

  • Creare una sessione di disegno in un oggetto rendertarget
  • Chiamare drawingSession.Clear(Colors.Tranparent)
  • Colors.Tranparent è definito come R = 255, G = 255, B = 255, A = 0
  • Win2D convertirà questo valore in formato premoltiplicato, producendo R = 0, G = 0, B = 0, A = 0
  • Usare GetPixelColors per leggere il contenuto del renderingtarget
  • Osservare che contiene il formato premoltiplicato RGB = 0, non RGB = 255 come il valore alfa Colors.Tranparent retto originale

Conversione tra formati alfa

Per convertire un valore di colore alfa retto in formato premoltiplicato, moltiplicare i valori R, G e B per A. Per convertire premultiplied in dritto, dividere R, G e B per A.

Si noti che le informazioni sul colore sono spesso rappresentate come valori di byte compresi tra 0 e 255 (ad esempio la Windows.UI.Color struttura è costituita da 4 byte). Questa rappresentazione viene ridimensionata di un fattore pari a 255, quindi un valore di byte pari a 255 significa effettivamente 1, mentre 128 è metà intensità. Tale fattore di ridimensionamento deve essere preso in considerazione durante le conversioni di formato, in modo da convertire un oggetto Windows.UI.Color da semplice a premoltiplicato:

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 sono presenti dati immagine che usano il formato alfa errato PremultiplyEffect o UnPremultiplyEffect possono essere usati per convertirli.