PixelBlend

Destiny unterstützt die Nutzung von PixelBlend.dll zum Zeichnen von Pixeln mit insgesamt 58 verschiedenen Formeln für eine Vielzahl an Blendmodi, sofern die Bibliothek in den Darstellungsprozess von RPG_RT eingebunden ist (dies ist bei RPG2000 1.62EX der Fall).

Verfügbare Blendmodi

Die nachfolgend aufgelisteten Modi, unterteilt in mehrere Kategorien, sind verfügbar.

Set/Mix⁰, Add/LinearDodge¹, Sub/Subtract², Mul/Multiply³, Div/Divide⁴, Mod/Rem/Remainder⁵

Difference⁶, DifferenceFill⁷, Exclude/Exclusion⁸, Negate/Negation⁹, Phoenix¹⁰

Darken¹¹, Lighten¹²

DarkerColor (HSI¹³, HSL¹⁴, HSV¹⁵, HSY (SDTV¹⁶, HDTV¹⁷, Adobe¹⁸, HDR¹⁹))

LighterColor (HSI²⁰, HSL²¹, HSV²², HSY (SDTV²³, HDTV²⁴, Adobe²⁵, HDR²⁶))

DodgeScreen²⁷, ColorDodge²⁸, SoftDodge²⁹, ColorBurn³⁰, LinearBurn³¹, LinearBurnFill³², SoftBurn³³

GeometricMean³⁴

Overlay³⁵, SoftLight³⁶, HardLight³⁷, VividLight³⁸

LinearLight³⁹, LinearLightFill⁴⁰, LinearInvert⁴¹, LinearInvertFill⁴²

PinLight⁴³, StampDodge⁴⁴, StampBurn⁴⁵, HardMix⁴⁶

QuadraticReflect⁴⁷, QuadraticGlow⁴⁸, QuadraticFreeze⁴⁹, QuadraticHeat⁵⁰

Conjunction/AND⁵¹, Disjunction/OR⁵², ExclusiveDisjunction/XOR⁵³

NegatedConjunction/NAND⁵⁴, NegatedDisjunction/NOR⁵⁵, Equivalence/XNOR⁵⁶

Interpolate⁵⁷

Ausführliche Beschreibung

Alle Darstellungen basieren darauf, dass zwei Farbverläufe von Schwarz zu Weiß aufeinandergeblendet werden.

Der Verlauf auf dem Hintergrund zieht sich von links nach rechts, der der Blend-Ebene von unten nach oben.

Einige Modi, jene mit der Kennzeichnung "(Fill)", entfalten eine andere Wirkung, wenn die Sichtbarkeit der zu blendenden Grafik heruntergeregelt wird.

Die angegebenen Formeln bezeichnen den Vordergrund als "I", den Hintergrund als "S" und die Sichtbarkeit des Vordergrunds als "F", Zwischenergebnisse "X" können vorkommen, das Endergebnis wird in "C" gespeichert.

Viele Modi enthalten die Basisformel und zusätzlich eine ausführliche Rechnung, bei der die Sichtbarkeit des Vordergrunds zum Schluss mit angewendet wird (entfällt, wenn sie bereits in der Basisformel vorkommt).

DarkerColor und LighterColor sind in jeweils sieben Variationen vorhanden, die unterschiedliche Verfahren zum Ermitteln der Helligkeit nutzen oder den individuellen RGB-Kanälen verschiedene Gewichtungen zuordnen.

Überragt die Sichtbarkeit den Maximalwert von 255, entstehen bei vielen aber nicht allen Modi verglitchte Farben im Ergebnisbild, das Unterschreiten von 0 wird hingegen als 0 gewertet.

#0	Set / Mix
	Die Standardmethode, mit der Pixel normalerweise aufeinander gezeichnet werden, bei voller Sichtbarkeit verschwindet der Bildpunkt des Hintergrundes vollständig. C = I C = ((I * F) + (S * (F - 255))) / 255
#1	Add / LinearDodge
	Die RGB-Werte des Hintergrunds und Vordergrunds werden addiert, was zu intensiv leuchtenden Ergebnissen führen kann. Überschreitet die Vordergrundsichtbarkeit das Maximum von 255, verstärkt sich dieser Effekt, ohne zu verglitchen. C = [S + I, 255].min C = [S + (((I * F) + (S * (255 - F))) / 255), 255].min
#2	Sub / Subtract
	Die RGB-Werte des Hintergrunds und Vordergrunds werden voneinander subtrahiert, was zu sehr finster aussehenden Ergebnissen führen kann, je heller die Vordergrundpixel ausfallen. Überschreitet die Vordergrundsichtbarkeit das Maximum von 255, verstärkt sich dieser Effekt, ohne zu verglitchen. C = [S - I, 0].max C = [S - (((I * F) + (S * (255 - F))) / 255), 0].max
#3	Mul / Multiply
	Die RGB-Werte des Hintergrunds und Vordergrunds werden miteinander multipliziert und dabei wie Kommazahlen zwischen 0 und 1 behandelt (dies entspricht einer anschließenden Division durch 255). Dadurch entstehen Verdunkelungen abhängig davon, wie dunkel der Vordergrund ausfällt, während ein weißer Pixel nichts am Hintergrund verändert. C = (I * S) / 255 C = ((((I * S) * F) / 255) + (S * (255 - F))) / 255
#4	Div / Divide
	Die RGB-Werte des Hintergrunds werden durch die des Vordergrunds geteilt und dabei wie Kommazahlen zwischen 0 und 1 behandelt (dies entspricht einer vorausgehenden Multiplikation mit 255 für den Hintergrund, bevor die eigentliche Formel angewendet wird). Sollte der Vordergrund 0 betragen, durch den man nicht teilen kann, beträgt das Ergebnis automatisch 255. C = [(S << 8) / (I + 1), 255].min C = [((((S << 8) / (I + 1)) * F) / 255) + ((S * (255 - F)) / 255), 255].min
#5	Mod / Rem / Remainder
	Führt den gleichen Prozess wie bei "Div / Divide" (#4) durch, verwendet allerdings den bei der Division entstandenen Restbetrag als Wert, der als neuer Pixel gespeichert wird, was sehr bizarre Muster und kaputt wirkende Ergebnisse hervorbringen kann. C = (S << 8) % (I + 1) C = ((((S << 8) % (I + 1)) * F) / 255) + ((S * (255 - F)) / 255)
#6	Difference
	Errechnet die jeweiligen Differenzen zwischen den RGB-Werten des Hintergrunds und Vordergrunds, ein negatives Ergebnis wird automatisch in das positive Gegenstück umgewandelt. C = (I - S).abs C = (((I - S).abs * F) + (S * (255 - F))) / 255
#7	Difference (Fill)
	Führt den gleichen Prozess wie bei "Difference" (#6) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds. C = (((I * F) / 255) - S).abs
#8	Exclude / Exclusion
	Multipliziert die RGB-Werte des Hintergrunds mit denen des Vordergrunds sowie 255 und halbiert das Resultat anschließend. Der dabei entstehende Wert wird von einer Addition aus Hintergrund und Vordergrund abgezogen und schlussendlich auf den gültigen Wertebereich beschränkt. C = [[(I + S) - ((I * S) / 128), 255].min, 0].max C = (([[(I + S) - ((I * S) / 128), 255].min, 0].max * F) + (S * (255 - F))) / 255
#9	Negate / Negation
	Zieht die RGB-Werte des Hintergrunds sowie Vordergrunds zusammen von 255 ab und wandelt das Ergebnis in einen positiven Betrag um, der wiederum von 255 abgezogen wird. C = 255 - (255 - ((I * F) / 255) - S).abs
#10	Phoenix
	Zieht die RGB-Werte des Hintergrunds von denen des Vordergrunds ab und wandelt ein positives Ergebnis automatisch in sein negatives Pendant um, auf das anschließend von 255 draufgerechnet werden. C = [-((I - S).abs) + 255, 255].min C = [(((-((I - S).abs) + 255) * F) + (S * (255 - F))) / 255, 255].min
#11	Darken
	Wendet die individuellen RGB-Werte des Vordergrunds nur dann an, wenn sie niedriger als die des Hintergrunds ausfallen. C = I < S ? I : S C = I < S ? ((I * F) + (S * (255 - F))) : S
#12	Lighten
	Wendet die individuellen RGB-Werte des Vordergrunds nur dann an, wenn sie höher als die des Hintergrunds ausfallen. C = I > S ? I : S C = I > S ? (I * F) + (S * (255 - F)) : S
#13	DarkerColor (HSI)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSI-Farbsystem als dunkler gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Gesamtsummen beider RGB-Farbkanalgruppen. C = (IR + IG + IB) < (SR + SG + SB) ? I : S C = (IR + IG + IB) < (SR + SG + SB) ? ((I * F) + (S * (255 - F))) / 255 : S
#14	DarkerColor (HSL)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSL-Farbsystem als dunkler gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Summen aus dem jeweils höchsten und niedrigsten Farbkanalwert. C = (IMAX + IMIN) < (SMAX + SMIN) ? I : S C = (IMAX + IMIN) < (SMAX + SMIN) ? ((I * F) + (S * (255 - F))) / 255 : S
#15	DarkerColor (HSV)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSV-Farbsystem als dunkler gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der höchsten Werte beider RGB-Farbkanalgruppen. C = IMAX < SMAX ? I : S C = IMAX < SMAX ? ((I * F) + (S * (255 - F))) / 255 : S
#16	DarkerColor (HSY: SDTV)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2990, 5870, 1140] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen. C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
#17	DarkerColor (HSY: HDTV)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2120, 7010, 870] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen. C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
#18	DarkerColor (HSY: Adobe)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2126, 7152, 722] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen. C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
#19	DarkerColor (HSY: HDR)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2627, 6780, 593] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen. C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
#20	LighterColor (HSI)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSI-Farbsystem als heller gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Gesamtsummen beider RGB-Farbkanalgruppen. C = (IR + IG + IB) > (SR + SG + SB) ? I : S C = (IR + IG + IB) > (SR + SG + SB) ? ((I * F) + (S * (255 - F))) / 255 : S
#21	LighterColor (HSL)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSL-Farbsystem als heller gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Summen aus dem jeweils höchsten und niedrigsten Farbkanalwert. C = (IMAX + IMIN) > (SMAX + SMIN) ? I : S C = (IMAX + IMIN) > (SMAX + SMIN) ? ((I * F) + (S * (255 - F))) / 255 : S
#22	LighterColor (HSV)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSV-Farbsystem als heller gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der höchsten Werte beider RGB-Farbkanalgruppen. C = IMAX > SMAX ? I : S C = IMAX > SMAX ? ((I * F) + (S * (255 - F))) / 255 : S
#23	LighterColor (HSY: SDTV)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2990, 5870, 1140] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen. C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
#24	LighterColor (HSY: HDTV)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2120, 7010, 870] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen. C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
#25	LighterColor (HSY: Adobe)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2126, 7152, 722] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen. C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
#26	LighterColor (HSY: HDR)
	Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2627, 6780, 593] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen. C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S
#27	DodgeScreen
	Multipliziert die RGB-Werte des Hintergrunds und Vordergrunds miteinander, nachdem sie jeweils von 255 abgezogen wurden. Das Ergebnis wird erneut von 255 abgezogen. C = 255 - (((255 - I) * (255 - S)) / 255) C = (255 - (((255 - I) * (255 - S)) / 255) * F) + (S * (255 - F)) / 255
#28	ColorDodge
	Dividiert die RGB-Werte des Hintergrunds durch die des Vordergrunds, nachdem letztere von 255 abgezogen wurden (das Ergebnis ist automatisch 255, wenn der Vordergrundwert 255 beträgt). C = 0 if S == 0 X = 255 - I C = 255 if S >= X C = (S * 255) / X C = 0 if S == 0 X = 255 - ((I * F) / 255) C = 255 if S >= X C = (S * 255) / X
#29	SoftDodge
	Falls der jeweilige RGB-Wert des Hindergrunds addiert mit dem des Vordergrunds 255 nicht übersteigt, wird die Hälfte des Hintergrundwertes durch den Vordergrundwert dividiert, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Vordergrundwert 255 beträgt). Andernfalls wird die Hälfte vom Vordergrundwert, nachdem er von 255 abgezogen wurde, durch den Hintergrundwert geteilt und anschließend von 255 abgezogen (das Endergebnis ist automatisch 0, wenn der Hintergrundwert 0 beträgt). C = I if S + I < 256 && I == 255 C = [(S * 128) / (255 - I), 255].min if S + I < 256 C = S == 0 ? S : [255 - (((255 - I) * 128) / S), 0].max X = I if S + I < 256 && I == 255 X = [(S * 128) / (255 - I), 255].min if S + I < 256 X = S == 0 ? S : [255 - (((255 - I) * 128) / S), 0].max C = ((X * F) + (S * (255 - F))) / 255
#30	ColorBurn
	Dividiert die RGB-Werte des Hintergrunds, nachdem diese von 255 abgezogen wurden, durch die des Vordergrunds. Das Ergebnis wird anschließend von 255 abgezogen. Das Ergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt. C = 255 if S == 255 X = ((I * F) / 255) + (255 - F) C = 0 if (255 - S) >= X C = 255 - (((255 - S) * 255) / X)
#31	LinearBurn
	Addiert die RGB-Werte des Hintergrunds und Vordergrunds, um anschließend 255 vom Ergebnis abzuziehen. C = [S + I - 255, 0].max C = [(((S + I - 255) * F) + (S * (255 - F))) / 255, 0].max
#32	LinearBurn (Fill)
	Führt den gleichen Prozess durch wie bei LinearBurn (#31) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds. C = [S + (((I - 255) * F) / 255), 0].max
#33	SoftBurn
	Falls der jeweilige RGB-Wert des Hindergrunds addiert mit dem des Vordergrunds 255 nicht übersteigt, wird die Hälfte des Vordergrundwertes durch den Hintergrundwert dividiert, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Hintergrundwert 255 beträgt). Andernfalls wird die Hälfte vom Hintergrundwert, nachdem er von 255 abgezogen wurde, durch den Vordergrundwert geteilt und anschließend von 255 abgezogen (das Endergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt). C = S if S + I < 256 && S == 255 C = [(I * 128) / (255 - S), 255].min if S + I < 256 C = I == 0 ? I : [255 - (((255 - S) * 128) / I), 0].max X = S if S + I < 256 && S == 255 X = [(I * 128) / (255 - S), 255].min if S + I < 256 X = I == 0 ? I : [255 - (((255 - S) * 128) / I), 0].max C = ((X * F) + (S * (255 - F))) / 255
#34	GeometricMean
	Die RGB-Werte des Hintergrunds und Vordergrunds werden miteinander mulitipliziert und aus dem Ergebnis die Quadratwurzel gezogen. C = sqrt(I * S) C = sqrt(((I * S) * F) / 255) + ((S * (255 - F)) / 255)
#35	Overlay
	Falls der Hintergrundwert niedriger als 128 ist, wird er mit dem Vordergrundwert multipliziert und das Ergebnis anschließend verdoppelt (da eine Division durch 255 notwendig ist, wird anstelle zweier Rechenschritte durch 128 geteilt). Andernfalls werden der Hintergrundwert und Vordergrundwert miteinander multipliziert, nachdem sie jeweils von 255 abgezogen wurden, anschließend das Ergebnis (auch hier mit Vereinfachung) verdoppelt und von 255 abgezogen. C = (S * I) >> 7 if S < 128 C = 255 - ((255 - S) * (255 - I) >> 7) C = ((((S * I) >> 7) * F) + (S * (255 - F))) / 255 C = (((255 - (((255 - S) * (255 - I)) >> 7)) * F) + (S * (255 - F))) / 255
#36	SoftLight
	Die RGB-Werte des Hintergrunds und Vordergrunds werden miteinander mulitipliziert und als Zwischenergebnis vermerkt. Der Hintergrundwert und der Vordergrundwert, nachdem sie jeweils von 255 abgezogen wurden, werden multipliziert und von 255 abgezogen. Das vermerkte Zwischenergebnis wird anschließend vom dadurch entstandenen Wert abgezogen, mit dem Hintergrundwert multipliziert und auf das vermerkte Zwischenergebnis nochmal aufaddiert. X = (S * I) / 255 C = X + (S * (255 - (((255 - S) * (255 - I)) / 255) - X) / 255) X = (S * I) / 255 X = X + (S * (255 - (((255 - S) * (255 - I)) / 255) - X) / 255) C = ((X * F) + (S * (255 - F))) / 255
#37	HardLight
	Falls der Vordergrundwert niedriger als 128 ist, wird er mit dem Hintergrundwert multipliziert und das Ergebnis anschließend verdoppelt (da eine Division durch 255 notwendig ist, wird anstelle zweier Rechenschritte durch 128 geteilt). Andernfalls werden der Hintergrundwert und Vordergrundwert miteinander multipliziert, nachdem sie jeweils von 255 abgezogen wurden, das Ergebnis (auch hier mit Vereinfachung) verdoppelt und von 255 abgezogen. C = (I * S) >> 7 if I < 128 C = (255 - (((255 - I) * (255 - S)) >> 7)) C = (((I * S >> 7) * F) + (S * (255 - F))) / 255 if I < 128 C = (((255 - (((255 - I) * (255 - S)) >> 7)) * F) + (S * (255 - F))) / 255
#38	VividLight
	Falls der Vordergrundwert niedriger als 128 ist, wird der Hintergrundwert, nachdem er von 255 abgezogen wurde, durch das Doppelte vom Vordergrundwert geteilt und das Ergebnis anschließend von 255 abgezogen (das Ergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt). Andernfalls wird der Hintergrundwert durch den Vordergrundwert geteilt, nachdem letzterer von 255 abgezogen und anschließend verdoppelt wurde (das Ergebnis ist automatisch 255, falls der Vordergrundwert 255 beträgt). X = ((I * 2 * F) / 255) + (255 - F) C = 0 if I < 128 && X == 0 C = 255 - ((255 - S) * 255) / X if I < 128 C = 255 if (((I * 2) - 255) * F) / 255 == 255 C = (S * 255) / (255 - (((I * 2) - 255) * F) / 255)
#39	LinearLight
	Der Vordergrundwert wird verdoppelt und auf den Hintergrundwert addiert, anschließend wird 255 vom Ergebnis abgezogen. C = S + ((2 * I) - 255) C = ((S + ((2 * I) - 255) * F) + (S * (255 - F))) / 255
#40	LinearLight (Fill)
	Führt den gleichen Prozess durch wie bei LinearLight (#39) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds. C = S + ((((2 * I) - 255) * F) / 255)
#41	LinearInvert
	Der Vordergrundwert wird von 255 abgezogen, verdoppelt und auf den Hintergrundwert addiert, nachdem 255 vom Ergebnis abgezogen wurde. C = S + ((2 * (255 - I)) - 255) C = ((S + ((2 * (255 - I)) - 255) * F) + (S * (255 - F))) / 255
#42	LinearInvert (Fill)
	Führt den gleichen Prozess durch wie bei LinearInvert (#41) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds. C = S + ((((2 * (255 - I)) - 255) * F) / 255)
#43	PinLight
	Falls der Hintergrundwert geringer ausfällt als das Doppelte vom Vordergrundwert, von dem 255 abgezogen wird, wird selbige Formel angewandt. Andernfalls wird der verdoppelte Vordergrundwert als Ergebnis gespeichert (die Anwendung der Formel wird übersprungen, wenn der Hintergrundwert geringer als der verdoppelte Vordergrundwert ausfällt). C = [(I * 2) - 255, 0].max if S < [(I * 2) - 255, 0].max C = S < I * 2 ? S : [I * 2, 255].min X = [(I * 2) - 255, 0].max if S < [(I * 2) - 255, 0].max X = S < I * 2 ? S : [I * 2, 255].min C = ((X * F) + (S * (255 - F))) / 255
#44	StampDodge
	Multipliziert den Hintergrundwert mit 255 und dividiert ihn durch den Vordergrundwert. Wenn der Hintergrundwert niedriger als der Vordergrundwert sein sollte, werden beide zuvor von 255 abgezogen. Das Endergebnis ist automatisch 255, falls je nach Fall der direkte oder von 255 abgezogene Vordergrundwert zu einer Division durch 0 führen würde. C = 255 if I == (S < I ? 0 : 255) C = S < I ? ((S * 255) / I) : (((255 - S) * 255) / (255 - I)) C = ((255 * F) + (S * (255 - F))) / 255 if I == (S < I ? 0 : 255) C = (((S < I ? ((S * 255) / I) : (((255 - S) * 255) / 255 - I)) * F) + (S * (255 - F))) / 255
#45	StampBurn
	Multipliziert den Hintergrundwert mit 255 und dividiert ihn durch den Vordergrundwert. Wenn der Hintergrundwert niedriger als der Vordergrundwert sein sollte, werden beide zuvor von 255 abgezogen. Ebenfalls von 255 abgezogen wird das bei dieser Berechnung entstehende Resultat. Das Endergebnis ist automatisch 0, falls je nach Fall der direkte oder von 255 abgezogene Vordergrundwert zu einer Division durch 0 führen würde. C = 0 if I == (S < I ? 0 : 255) C = 255 - (S < I ? ((S * 255) / I) : (((255 - S) * 255) / (255 - I))) C = ((255 * F) + (S * (255 - F))) / 255 if I == (S < I ? 0 : 255) C = (((255 - (S < I ? ((S * 255) / I) : (((255 - S) * 255) / (255 - I)))) * F) + (S * (255 - F))) / 255
#46	HardMix
	Verringert die Anzahl an möglichen Farbkanalwerten, abhängig von der Sichtbarkeit des Vordergrunds. Bei voller Sichtbarkeit beträgt das Ergebnis immer 0, wenn der Vordergrundwert geringer ist als der Hintergrundwert, nachdem letzterer von 255 abgezogen wurde, andernfalls 255. C = ((255 * (256 - F)) - (65025 - [(S * 255) + (I * F), 65025].min)) / (256 - F)
#47	QuadraticReflect
	Der quadrierte Hintergrundwert wird durch den Vordergrundwert geteilt, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Vordergrundwert 255 beträgt). C = I == 255 ? I : (S * S) / (255 - I) C = ((I == 255 ? I : ((S * S) / (255 - I) * F)) + (S * (255 - F))) / 255
#48	QuadraticGlow
	Der quadrierte Vordergrundwert wird durch den Hintergrundwert geteilt, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Hintergrundwert 255 beträgt). C = S == 255 ? S : (I * I) / (255 - S) C = ((S == 255 ? S : ((I * I) / (255 - S) * F)) + (S * (255 - F))) / 255
#49	QuadraticFreeze
	Der Hintergrundwert wird von 255 abgezogen, anschließend quadriert und durch den Vordergrundwert geteilt. Das Ergebnis wird anschließend von 255 abgezogen (das Ergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt). C = I == 0 ? I : 255 - (((255 - S) * (255 - S)) / I) C = ((I == 0 ? I : 255 - (((255 - S) * (255 - S)) / I)) * F) + (S * (255 - F))) / 255
#50	QuadraticHeat
	Der Vordergrundwert wird von 255 abgezogen, anschließend quadriert und durch den Hintergrundwert geteilt. Das Ergebnis wird anschließend von 255 abgezogen (das Ergebnis ist automatisch 0, wenn der Hintergrundwert 0 beträgt). C = S == 0 ? S : 255 - (((255 - I) * (255 - I)) / S) C = ((S == 0 ? S : 255 - (((255 - I) * (255 - I)) / S)) * F) + (S * (255 - F))) / 255
#51	Conjunction / AND
	Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem AND-Gatter verschaltet. C = S & I C = (((S & I) * F) + (S * (255 - F))) / 255
#52	Disjunction / OR
	Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem OR-Gatter verschaltet. C = S \| I C = (((S \| I) * F) + (S * (255 - F))) / 255
#53	ExclusiveDisjunction / XOR
	Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem XOR-Gatter verschaltet. C = S ^ I C = (((S ^ I) * F) + (S * (255 - F))) / 255
#54	NegatedConjunction / NAND
	Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem AND-Gatter verschaltet, nachdem letzterer von 255 abgezogen wurde. C = S & (255 - I) C = (((S & (255 - I)) * F) + (S * (255 - F))) / 255
#55	NegatedDisjunction / NOR
	Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem OR-Gatter verschaltet, nachdem letzterer von 255 abgezogen wurde. C = S \| (255 - I) C = (((S \| (255 - I)) * F) + (S * (255 - F))) / 255
#56	Equivalence / XNOR
	Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem XOR-Gatter verschaltet, nachdem letzterer von 255 abgezogen wurde. C = S ^ (255 - I) C = (((S ^ (255 - I)) * F) + (S * (255 - F))) / 255
#57	Interpolate
	Die RGB-Werte vom Hintergrund und Vordergrund werden durch Werte aus einer vorberechneten Liste an Kosinuswerten ersetzt und anschließend zusammengezählt. cos = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25, 26, 26, 27, 27, 28, 29, 29, 30, 31, 31, 32, 33, 34, 34, 35, 36, 36, 37, 38, 39, 39, 40, 41, 41, 42, 43, 44, 44, 45, 46, 47, 48, 48, 49, 50, 51, 51, 52, 53, 54, 54, 55, 56, 57, 58, 58, 59, 60, 61, 62, 62, 63, 64, 65, 65, 66, 67, 68, 69, 69, 70, 71, 72, 73, 73, 74, 75, 76, 76, 77, 78, 79, 79, 80, 81, 82, 83, 83, 84, 85, 86, 86, 87, 88, 88, 89, 90, 91, 91, 92, 93, 93, 94, 95, 95, 96, 97, 98, 98, 99, 100, 100, 101, 101, 102, 103, 103, 104, 105, 105, 106, 106, 107, 107, 108, 109, 109, 110, 110, 111, 111, 112, 112, 113, 113, 114, 114, 115, 115, 116, 116, 117, 117, 117, 118, 118, 119, 119, 120, 120, 120, 121, 121, 121, 122, 122, 122, 123, 123, 123, 123, 124, 124, 124, 124, 125, 125, 125, 125, 126, 126, 126, 126, 126, 126, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 128] C = cos(S) + cos(I) C = (((cos(S) + cos(I)) * F) + (S * (255 - F))) / 255

Set / Mix

Die Standardmethode, mit der Pixel normalerweise aufeinander gezeichnet werden, bei voller Sichtbarkeit verschwindet der Bildpunkt des Hintergrundes vollständig.

C = I

C = ((I * F) + (S * (F - 255))) / 255

Add / LinearDodge

Die RGB-Werte des Hintergrunds und Vordergrunds werden addiert, was zu intensiv leuchtenden Ergebnissen führen kann. Überschreitet die Vordergrundsichtbarkeit das Maximum von 255, verstärkt sich dieser Effekt, ohne zu verglitchen.

C = [S + I, 255].min

C = [S + (((I * F) + (S * (255 - F))) / 255), 255].min

Sub / Subtract

Die RGB-Werte des Hintergrunds und Vordergrunds werden voneinander subtrahiert, was zu sehr finster aussehenden Ergebnissen führen kann, je heller die Vordergrundpixel ausfallen. Überschreitet die Vordergrundsichtbarkeit das Maximum von 255, verstärkt sich dieser Effekt, ohne zu verglitchen.

C = [S - I, 0].max

C = [S - (((I * F) + (S * (255 - F))) / 255), 0].max

Mul / Multiply

Die RGB-Werte des Hintergrunds und Vordergrunds werden miteinander multipliziert und dabei wie Kommazahlen zwischen 0 und 1 behandelt (dies entspricht einer anschließenden Division durch 255). Dadurch entstehen Verdunkelungen abhängig davon, wie dunkel der Vordergrund ausfällt, während ein weißer Pixel nichts am Hintergrund verändert.

C = (I * S) / 255

C = ((((I * S) * F) / 255) + (S * (255 - F))) / 255

Div / Divide

Die RGB-Werte des Hintergrunds werden durch die des Vordergrunds geteilt und dabei wie Kommazahlen zwischen 0 und 1 behandelt (dies entspricht einer vorausgehenden Multiplikation mit 255 für den Hintergrund, bevor die eigentliche Formel angewendet wird). Sollte der Vordergrund 0 betragen, durch den man nicht teilen kann, beträgt das Ergebnis automatisch 255.

C = [(S << 8) / (I + 1), 255].min

C = [((((S << 8) / (I + 1)) * F) / 255) + ((S * (255 - F)) / 255), 255].min

Mod / Rem / Remainder

Führt den gleichen Prozess wie bei "Div / Divide" (#4) durch, verwendet allerdings den bei der Division entstandenen Restbetrag als Wert, der als neuer Pixel gespeichert wird, was sehr bizarre Muster und kaputt wirkende Ergebnisse hervorbringen kann.

C = (S << 8) % (I + 1)

C = ((((S << 8) % (I + 1)) * F) / 255) + ((S * (255 - F)) / 255)

Difference

Errechnet die jeweiligen Differenzen zwischen den RGB-Werten des Hintergrunds und Vordergrunds, ein negatives Ergebnis wird automatisch in das positive Gegenstück umgewandelt.

C = (I - S).abs

C = (((I - S).abs * F) + (S * (255 - F))) / 255

Difference (Fill)

Führt den gleichen Prozess wie bei "Difference" (#6) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds.

C = (((I * F) / 255) - S).abs

Exclude / Exclusion

Multipliziert die RGB-Werte des Hintergrunds mit denen des Vordergrunds sowie 255 und halbiert das Resultat anschließend. Der dabei entstehende Wert wird von einer Addition aus Hintergrund und Vordergrund abgezogen und schlussendlich auf den gültigen Wertebereich beschränkt.

C = [[(I + S) - ((I * S) / 128), 255].min, 0].max

C = (([[(I + S) - ((I * S) / 128), 255].min, 0].max * F) + (S * (255 - F))) / 255

Negate / Negation

Zieht die RGB-Werte des Hintergrunds sowie Vordergrunds zusammen von 255 ab und wandelt das Ergebnis in einen positiven Betrag um, der wiederum von 255 abgezogen wird.

C = 255 - (255 - ((I * F) / 255) - S).abs

#10

Phoenix

Zieht die RGB-Werte des Hintergrunds von denen des Vordergrunds ab und wandelt ein positives Ergebnis automatisch in sein negatives Pendant um, auf das anschließend von 255 draufgerechnet werden.

C = [-((I - S).abs) + 255, 255].min

C = [(((-((I - S).abs) + 255) * F) + (S * (255 - F))) / 255, 255].min

#11

Darken

Wendet die individuellen RGB-Werte des Vordergrunds nur dann an, wenn sie niedriger als die des Hintergrunds ausfallen.

C = I < S ? I : S

C = I < S ? ((I * F) + (S * (255 - F))) : S

#12

Lighten

Wendet die individuellen RGB-Werte des Vordergrunds nur dann an, wenn sie höher als die des Hintergrunds ausfallen.

C = I > S ? I : S

C = I > S ? (I * F) + (S * (255 - F)) : S

#13

DarkerColor (HSI)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSI-Farbsystem als dunkler gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Gesamtsummen beider RGB-Farbkanalgruppen.

C = (IR + IG + IB) < (SR + SG + SB) ? I : S

C = (IR + IG + IB) < (SR + SG + SB) ? ((I * F) + (S * (255 - F))) / 255 : S

#14

DarkerColor (HSL)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSL-Farbsystem als dunkler gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Summen aus dem jeweils höchsten und niedrigsten Farbkanalwert.

C = (IMAX + IMIN) < (SMAX + SMIN) ? I : S

C = (IMAX + IMIN) < (SMAX + SMIN) ? ((I * F) + (S * (255 - F))) / 255 : S

#15

DarkerColor (HSV)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSV-Farbsystem als dunkler gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der höchsten Werte beider RGB-Farbkanalgruppen.

C = IMAX < SMAX ? I : S

C = IMAX < SMAX ? ((I * F) + (S * (255 - F))) / 255 : S

#16

DarkerColor (HSY: SDTV)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2990, 5870, 1140] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.

C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S

C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S

#17

DarkerColor (HSY: HDTV)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2120, 7010, 870] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.

C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S

C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S

#18

DarkerColor (HSY: Adobe)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2126, 7152, 722] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.

C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S

C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S

#19

DarkerColor (HSY: HDR)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2627, 6780, 593] als dunkler gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.

C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? I : S

C = (IRr + IGr + IBr) < (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S

#20

LighterColor (HSI)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSI-Farbsystem als heller gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Gesamtsummen beider RGB-Farbkanalgruppen.

C = (IR + IG + IB) > (SR + SG + SB) ? I : S

C = (IR + IG + IB) > (SR + SG + SB) ? ((I * F) + (S * (255 - F))) / 255 : S

#21

LighterColor (HSL)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSL-Farbsystem als heller gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der Summen aus dem jeweils höchsten und niedrigsten Farbkanalwert.

C = (IMAX + IMIN) > (SMAX + SMIN) ? I : S

C = (IMAX + IMIN) > (SMAX + SMIN) ? ((I * F) + (S * (255 - F))) / 255 : S

#22

LighterColor (HSV)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSV-Farbsystem als heller gegenüber dem Hintergrund eingestuft wird. Diese Beurteilung ergibt sich aus einem Vergleich der höchsten Werte beider RGB-Farbkanalgruppen.

C = IMAX > SMAX ? I : S

C = IMAX > SMAX ? ((I * F) + (S * (255 - F))) / 255 : S

#23

LighterColor (HSY: SDTV)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2990, 5870, 1140] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.

C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S

C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S

#24

LighterColor (HSY: HDTV)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2120, 7010, 870] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.

C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S

C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S

#25

LighterColor (HSY: Adobe)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2126, 7152, 722] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.

C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S

C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S

#26

LighterColor (HSY: HDR)

Wendet die Vordergrundfarbe nur dann an, wenn sie vom HSY-Farbsystem mit den RGB-Gewichtungen [2627, 6780, 593] als heller gegenüber dem Hintergrund eingestuft wird. Die RGB-Werte werden mit den Gewichtungen multipliziert, beide Gruppen jeweils zusammengerechnet und die Summen zur Beurteilung wie beim HSI-System verglichen.

C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? I : S

C = (IRr + IGr + IBr) > (SRr + SGr + SBr) ? ((I * F) + (S * (255 - F))) / 255 : S

#27

DodgeScreen

Multipliziert die RGB-Werte des Hintergrunds und Vordergrunds miteinander, nachdem sie jeweils von 255 abgezogen wurden. Das Ergebnis wird erneut von 255 abgezogen.

C = 255 - (((255 - I) * (255 - S)) / 255)

C = (255 - (((255 - I) * (255 - S)) / 255) * F) + (S * (255 - F)) / 255

#28

ColorDodge

Dividiert die RGB-Werte des Hintergrunds durch die des Vordergrunds, nachdem letztere von 255 abgezogen wurden (das Ergebnis ist automatisch 255, wenn der Vordergrundwert 255 beträgt).

C = 0 if S == 0
X = 255 - I
C = 255 if S >= X
C = (S * 255) / X

C = 0 if S == 0
X = 255 - ((I * F) / 255)
C = 255 if S >= X
C = (S * 255) / X

#29

SoftDodge

Falls der jeweilige RGB-Wert des Hindergrunds addiert mit dem des Vordergrunds 255 nicht übersteigt, wird die Hälfte des Hintergrundwertes durch den Vordergrundwert dividiert, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Vordergrundwert 255 beträgt). Andernfalls wird die Hälfte vom Vordergrundwert, nachdem er von 255 abgezogen wurde, durch den Hintergrundwert geteilt und anschließend von 255 abgezogen (das Endergebnis ist automatisch 0, wenn der Hintergrundwert 0 beträgt).

C = I if S + I < 256 && I == 255
C = [(S * 128) / (255 - I), 255].min if S + I < 256
C = S == 0 ? S : [255 - (((255 - I) * 128) / S), 0].max

X = I if S + I < 256 && I == 255
X = [(S * 128) / (255 - I), 255].min if S + I < 256
X = S == 0 ? S : [255 - (((255 - I) * 128) / S), 0].max
C = ((X * F) + (S * (255 - F))) / 255

#30

ColorBurn

Dividiert die RGB-Werte des Hintergrunds, nachdem diese von 255 abgezogen wurden, durch die des Vordergrunds. Das Ergebnis wird anschließend von 255 abgezogen. Das Ergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt.

C = 255 if S == 255
X = ((I * F) / 255) + (255 - F)
C = 0 if (255 - S) >= X
C = 255 - (((255 - S) * 255) / X)

#31

LinearBurn

Addiert die RGB-Werte des Hintergrunds und Vordergrunds, um anschließend 255 vom Ergebnis abzuziehen.

C = [S + I - 255, 0].max

C = [(((S + I - 255) * F) + (S * (255 - F))) / 255, 0].max

#32

LinearBurn (Fill)

Führt den gleichen Prozess durch wie bei LinearBurn (#31) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds.

C = [S + (((I - 255) * F) / 255), 0].max

#33

SoftBurn

Falls der jeweilige RGB-Wert des Hindergrunds addiert mit dem des Vordergrunds 255 nicht übersteigt, wird die Hälfte des Vordergrundwertes durch den Hintergrundwert dividiert, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Hintergrundwert 255 beträgt). Andernfalls wird die Hälfte vom Hintergrundwert, nachdem er von 255 abgezogen wurde, durch den Vordergrundwert geteilt und anschließend von 255 abgezogen (das Endergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt).

C = S if S + I < 256 && S == 255
C = [(I * 128) / (255 - S), 255].min if S + I < 256
C = I == 0 ? I : [255 - (((255 - S) * 128) / I), 0].max

X = S if S + I < 256 && S == 255
X = [(I * 128) / (255 - S), 255].min if S + I < 256
X = I == 0 ? I : [255 - (((255 - S) * 128) / I), 0].max
C = ((X * F) + (S * (255 - F))) / 255

#34

GeometricMean

Die RGB-Werte des Hintergrunds und Vordergrunds werden miteinander mulitipliziert und aus dem Ergebnis die Quadratwurzel gezogen.

C = sqrt(I * S)

C = sqrt(((I * S) * F) / 255) + ((S * (255 - F)) / 255)

#35

Overlay

Falls der Hintergrundwert niedriger als 128 ist, wird er mit dem Vordergrundwert multipliziert und das Ergebnis anschließend verdoppelt (da eine Division durch 255 notwendig ist, wird anstelle zweier Rechenschritte durch 128 geteilt). Andernfalls werden der Hintergrundwert und Vordergrundwert miteinander multipliziert, nachdem sie jeweils von 255 abgezogen wurden, anschließend das Ergebnis (auch hier mit Vereinfachung) verdoppelt und von 255 abgezogen.

C = (S * I) >> 7 if S < 128
C = 255 - ((255 - S) * (255 - I) >> 7)

C = ((((S * I) >> 7) * F) + (S * (255 - F))) / 255
C = (((255 - (((255 - S) * (255 - I)) >> 7)) * F) + (S * (255 - F))) / 255

#36

SoftLight

Die RGB-Werte des Hintergrunds und Vordergrunds werden miteinander mulitipliziert und als Zwischenergebnis vermerkt. Der Hintergrundwert und der Vordergrundwert, nachdem sie jeweils von 255 abgezogen wurden, werden multipliziert und von 255 abgezogen. Das vermerkte Zwischenergebnis wird anschließend vom dadurch entstandenen Wert abgezogen, mit dem Hintergrundwert multipliziert und auf das vermerkte Zwischenergebnis nochmal aufaddiert.

X = (S * I) / 255
C = X + (S * (255 - (((255 - S) * (255 - I)) / 255) - X) / 255)

X = (S * I) / 255
X = X + (S * (255 - (((255 - S) * (255 - I)) / 255) - X) / 255)
C = ((X * F) + (S * (255 - F))) / 255

#37

HardLight

Falls der Vordergrundwert niedriger als 128 ist, wird er mit dem Hintergrundwert multipliziert und das Ergebnis anschließend verdoppelt (da eine Division durch 255 notwendig ist, wird anstelle zweier Rechenschritte durch 128 geteilt). Andernfalls werden der Hintergrundwert und Vordergrundwert miteinander multipliziert, nachdem sie jeweils von 255 abgezogen wurden, das Ergebnis (auch hier mit Vereinfachung) verdoppelt und von 255 abgezogen.

C = (I * S) >> 7 if I < 128
C = (255 - (((255 - I) * (255 - S)) >> 7))

C = (((I * S >> 7) * F) + (S * (255 - F))) / 255 if I < 128
C = (((255 - (((255 - I) * (255 - S)) >> 7)) * F) + (S * (255 - F))) / 255

#38

VividLight

Falls der Vordergrundwert niedriger als 128 ist, wird der Hintergrundwert, nachdem er von 255 abgezogen wurde, durch das Doppelte vom Vordergrundwert geteilt und das Ergebnis anschließend von 255 abgezogen (das Ergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt). Andernfalls wird der Hintergrundwert durch den Vordergrundwert geteilt, nachdem letzterer von 255 abgezogen und anschließend verdoppelt wurde (das Ergebnis ist automatisch 255, falls der Vordergrundwert 255 beträgt).

X = ((I * 2 * F) / 255) + (255 - F) C = 0 if I < 128 && X == 0
C = 255 - ((255 - S) * 255) / X if I < 128
C = 255 if (((I * 2) - 255) * F) / 255 == 255
C = (S * 255) / (255 - (((I * 2) - 255) * F) / 255)

#39

LinearLight

Der Vordergrundwert wird verdoppelt und auf den Hintergrundwert addiert, anschließend wird 255 vom Ergebnis abgezogen.

C = S + ((2 * I) - 255)

C = ((S + ((2 * I) - 255) * F) + (S * (255 - F))) / 255

#40

LinearLight (Fill)

Führt den gleichen Prozess durch wie bei LinearLight (#39) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds.

C = S + ((((2 * I) - 255) * F) / 255)

#41

LinearInvert

Der Vordergrundwert wird von 255 abgezogen, verdoppelt und auf den Hintergrundwert addiert, nachdem 255 vom Ergebnis abgezogen wurde.

C = S + ((2 * (255 - I)) - 255)

C = ((S + ((2 * (255 - I)) - 255) * F) + (S * (255 - F))) / 255

#42

LinearInvert (Fill)

Führt den gleichen Prozess durch wie bei LinearInvert (#41) durch, verrechnet allerdings bereits vor statt nach Anwenden der Formel die Sichtbarkeit mit den RGB-Werten des Vordergrunds.

C = S + ((((2 * (255 - I)) - 255) * F) / 255)

#43

PinLight

Falls der Hintergrundwert geringer ausfällt als das Doppelte vom Vordergrundwert, von dem 255 abgezogen wird, wird selbige Formel angewandt. Andernfalls wird der verdoppelte Vordergrundwert als Ergebnis gespeichert (die Anwendung der Formel wird übersprungen, wenn der Hintergrundwert geringer als der verdoppelte Vordergrundwert ausfällt).

C = [(I * 2) - 255, 0].max if S < [(I * 2) - 255, 0].max
C = S < I * 2 ? S : [I * 2, 255].min

X = [(I * 2) - 255, 0].max if S < [(I * 2) - 255, 0].max
X = S < I * 2 ? S : [I * 2, 255].min
C = ((X * F) + (S * (255 - F))) / 255

#44

StampDodge

Multipliziert den Hintergrundwert mit 255 und dividiert ihn durch den Vordergrundwert. Wenn der Hintergrundwert niedriger als der Vordergrundwert sein sollte, werden beide zuvor von 255 abgezogen. Das Endergebnis ist automatisch 255, falls je nach Fall der direkte oder von 255 abgezogene Vordergrundwert zu einer Division durch 0 führen würde.

C = 255 if I == (S < I ? 0 : 255)
C = S < I ? ((S * 255) / I) : (((255 - S) * 255) / (255 - I))

C = ((255 * F) + (S * (255 - F))) / 255 if I == (S < I ? 0 : 255)
C = (((S < I ? ((S * 255) / I) : (((255 - S) * 255) / 255 - I)) * F) + (S * (255 - F))) / 255

#45

StampBurn

Multipliziert den Hintergrundwert mit 255 und dividiert ihn durch den Vordergrundwert. Wenn der Hintergrundwert niedriger als der Vordergrundwert sein sollte, werden beide zuvor von 255 abgezogen. Ebenfalls von 255 abgezogen wird das bei dieser Berechnung entstehende Resultat. Das Endergebnis ist automatisch 0, falls je nach Fall der direkte oder von 255 abgezogene Vordergrundwert zu einer Division durch 0 führen würde.

C = 0 if I == (S < I ? 0 : 255)
C = 255 - (S < I ? ((S * 255) / I) : (((255 - S) * 255) / (255 - I)))

C = ((255 * F) + (S * (255 - F))) / 255 if I == (S < I ? 0 : 255)
C = (((255 - (S < I ? ((S * 255) / I) : (((255 - S) * 255) / (255 - I)))) * F) + (S * (255 - F))) / 255

#46

HardMix

Verringert die Anzahl an möglichen Farbkanalwerten, abhängig von der Sichtbarkeit des Vordergrunds. Bei voller Sichtbarkeit beträgt das Ergebnis immer 0, wenn der Vordergrundwert geringer ist als der Hintergrundwert, nachdem letzterer von 255 abgezogen wurde, andernfalls 255.

C = ((255 * (256 - F)) - (65025 - [(S * 255) + (I * F), 65025].min)) / (256 - F)

#47

QuadraticReflect

Der quadrierte Hintergrundwert wird durch den Vordergrundwert geteilt, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Vordergrundwert 255 beträgt).

C = I == 255 ? I : (S * S) / (255 - I)

C = ((I == 255 ? I : ((S * S) / (255 - I) * F)) + (S * (255 - F))) / 255

#48

QuadraticGlow

Der quadrierte Vordergrundwert wird durch den Hintergrundwert geteilt, nachdem letzterer von 255 abgezogen wurde (das Ergebnis ist automatisch 255, wenn der Hintergrundwert 255 beträgt).

C = S == 255 ? S : (I * I) / (255 - S)

C = ((S == 255 ? S : ((I * I) / (255 - S) * F)) + (S * (255 - F))) / 255

#49

QuadraticFreeze

Der Hintergrundwert wird von 255 abgezogen, anschließend quadriert und durch den Vordergrundwert geteilt. Das Ergebnis wird anschließend von 255 abgezogen (das Ergebnis ist automatisch 0, wenn der Vordergrundwert 0 beträgt).

C = I == 0 ? I : 255 - (((255 - S) * (255 - S)) / I)

C = ((I == 0 ? I : 255 - (((255 - S) * (255 - S)) / I)) * F) + (S * (255 - F))) / 255

#50

QuadraticHeat

Der Vordergrundwert wird von 255 abgezogen, anschließend quadriert und durch den Hintergrundwert geteilt. Das Ergebnis wird anschließend von 255 abgezogen (das Ergebnis ist automatisch 0, wenn der Hintergrundwert 0 beträgt).

C = S == 0 ? S : 255 - (((255 - I) * (255 - I)) / S)

C = ((S == 0 ? S : 255 - (((255 - I) * (255 - I)) / S)) * F) + (S * (255 - F))) / 255

#51

Conjunction / AND

Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem AND-Gatter verschaltet.

C = S & I

C = (((S & I) * F) + (S * (255 - F))) / 255

#52

Disjunction / OR

Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem OR-Gatter verschaltet.

C = S | I

C = (((S | I) * F) + (S * (255 - F))) / 255

#53

ExclusiveDisjunction / XOR

Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem XOR-Gatter verschaltet.

C = S ^ I

C = (((S ^ I) * F) + (S * (255 - F))) / 255

#54

NegatedConjunction / NAND

Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem AND-Gatter verschaltet, nachdem letzterer von 255 abgezogen wurde.

C = S & (255 - I)

C = (((S & (255 - I)) * F) + (S * (255 - F))) / 255

#55

NegatedDisjunction / NOR

Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem OR-Gatter verschaltet, nachdem letzterer von 255 abgezogen wurde.

C = S | (255 - I)

C = (((S | (255 - I)) * F) + (S * (255 - F))) / 255

#56

Equivalence / XNOR

Die RGB-Werte vom Hintergrund und Vordergrund werden miteinander in einem XOR-Gatter verschaltet, nachdem letzterer von 255 abgezogen wurde.

C = S ^ (255 - I)

C = (((S ^ (255 - I)) * F) + (S * (255 - F))) / 255

#57

Interpolate

Die RGB-Werte vom Hintergrund und Vordergrund werden durch Werte aus einer vorberechneten Liste an Kosinuswerten ersetzt und anschließend zusammengezählt.

cos = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,
       4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18,
       18, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25, 26, 26, 27, 27, 28, 29, 29, 30, 31, 31, 32, 33, 34, 34, 35, 36, 36, 37, 38, 39,
       39, 40, 41, 41, 42, 43, 44, 44, 45, 46, 47, 48, 48, 49, 50, 51, 51, 52, 53, 54, 54, 55, 56, 57, 58, 58, 59, 60, 61, 62, 62, 63,
       64, 65, 65, 66, 67, 68, 69, 69, 70, 71, 72, 73, 73, 74, 75, 76, 76, 77, 78, 79, 79, 80, 81, 82, 83, 83, 84, 85, 86, 86, 87, 88,
       88, 89, 90, 91, 91, 92, 93, 93, 94, 95, 95, 96, 97, 98, 98, 99, 100, 100, 101, 101, 102, 103, 103, 104, 105, 105, 106, 106, 107, 107, 108, 109,
       109, 110, 110, 111, 111, 112, 112, 113, 113, 114, 114, 115, 115, 116, 116, 117, 117, 117, 118, 118, 119, 119, 120, 120, 120, 121, 121, 121, 122, 122, 122, 123,
       123, 123, 123, 124, 124, 124, 124, 125, 125, 125, 125, 126, 126, 126, 126, 126, 126, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 128]

C = cos(S) + cos(I)

C = (((cos(S) + cos(I)) * F) + (S * (255 - F))) / 255