Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Nella grafica del computer esistono due modi diversi per rappresentare l'opacità di un valore di colore. Win2D usa entrambi i metodi. Questo articolo spiega la differenza e dove si usa ciascuno dei due.
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 far dissolvere un oggetto, si dovrebbe ridurre gradualmente il suo valore alfa lasciando invariati i valori RGB.
Per eseguire una fusione source-over tra due colori in formato alfa non premoltiplicato:
result = (source.RGB * source.A) + (dest.RGB * (1 - source.A))
Valori alfa premoltiplicati
Quando si utilizza l'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 source-over tra due colori che utilizzano il formato con 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 dei pixel archiviati in una bitmap o in un render target, e le operazioni di disegno o composizione che agiscono su queste superfici, usano l'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 sempre che i dati di input dell'effetto siano premoltiplicati; quindi, quando un effetto deve operare con alfa non premoltiplicato, applicherà prima una trasformazione di depremoltiplicazione, calcolerà l'effetto e quindi premoltiplicherà nuovamente 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.Transparent) -
Colors.Transparentè 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
GetPixelColorsper leggere il contenuto del target di rendering - Si noti che è in formato premoltiplicato RGB = 0, non RGB = 255 come nel valore alfa lineare originale
Colors.Transparent
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.