gumdrops/Krita
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity
Krita/krita/pykrita/hclsliders/colorconversion.py

989 lines
38 KiB
Python
Raw Permalink Normal View History

.
2025-03-07 08:03:18 +01:00
# SPDX-License-Identifier: GPL-3.0-or-later AND MIT
#
# Color conversion script for python.
# Copyright (C) 2024 Lucifer <krita-artists.org/u/Lucifer>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# This file incorporates work covered by the following copyright and
# permission notice:
#
# Copyright (c) 2021 Björn Ottosson
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of
# this software and associated documentation files (the "Software"), to deal in
# the Software without restriction, including without limitation the rights to
# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
# of the Software, and to permit persons to whom the Software is furnished to do
# so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# Pigment.O is a Krita plugin and it is a Color Picker and Color Mixer.
# Copyright ( C ) 2020 Ricardo Jeremias.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# ( at your option ) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import math, sys
# luma coefficents for ITU-R BT.709
Y709R = 0.2126
Y709G = 0.7152
Y709B = 0.0722
# constants for sRGB transfer
ALPHA = 0.055
GAMMA = 2.4
PHI = 12.92
# toe functions
K1 = 0.206
K2 = 0.03
K3 = (1.0 + K1) / (1.0 + K2)
class Convert:
@staticmethod
def roundZero(n: float, d: int):
s = -1 if n < 0 else 1
if not isinstance(d, int):
raise TypeError("decimal places must be an integer")
elif d < 0:
raise ValueError("decimal places has to be 0 or more")
elif d == 0:
return math.floor(abs(n)) * s
f = 10 ** d
return math.floor(abs(n) * f) / f * s
@staticmethod
def clampF(f: float, u: float=1, l: float=0):
# red may be negative in parts of blue due to color being out of gamut
if f < l:
return l
# round up near 1 and prevent going over 1 from oklab conversion
if (u == 1 and f > 0.999999) or f > u:
return u
return f
@staticmethod
def componentToSRGB(c: float):
# round(CHI / PHI, 7) = 0.0031308
return (1 + ALPHA) * c ** (1 / GAMMA) - ALPHA if c > 0.0031308 else c * PHI
@staticmethod
def componentToLinear(c: float):
# CHI = 0.04045
return ((c + ALPHA) / (1 + ALPHA)) ** GAMMA if c > 0.04045 else c / PHI
@staticmethod
def cartesianToPolar(a: float, b: float):
c = math.hypot(a, b)
hRad = math.atan2(b, a)
if hRad < 0:
hRad += math.pi * 2
h = math.degrees(hRad)
return (c, h)
@staticmethod
def polarToCartesian(c: float, h: float):
hRad = math.radians(h)
a = c * math.cos(hRad)
b = c * math.sin(hRad)
return (a, b)
@staticmethod
def linearToOklab(r: float, g: float, b: float):
# convert to approximate cone responses
l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b
m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b
s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b
# apply non-linearity
l_ = l ** (1 / 3)
m_ = m ** (1 / 3)
s_ = s ** (1 / 3)
# transform to Lab coordinates
okL = 0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_
okA = 1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_
okB = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_
return (okL, okA, okB)
@staticmethod
def oklabToLinear(okL: float, okA: float, okB: float):
# inverse coordinates
l_ = okL + 0.3963377774 * okA + 0.2158037573 * okB
m_ = okL - 0.1055613458 * okA - 0.0638541728 * okB
s_ = okL - 0.0894841775 * okA - 1.2914855480 * okB
# reverse non-linearity
l = l_ * l_ * l_
m = m_ * m_ * m_
s = s_ * s_ * s_
# convert to linear rgb
r = +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s
g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s
b = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s
return(r, g, b)
@staticmethod
# toe function for L_r
def toe(x):
return 0.5 * (K3 * x - K1 + ((K3 * x - K1) * (K3 * x - K1) + 4 * K2 * K3 * x) ** (1 / 2))
@staticmethod
# inverse toe function for L_r
def toeInv(x):
return (x * x + K1 * x) / (K3 * (x + K2))
@staticmethod
# Finds the maximum saturation possible for a given hue that fits in sRGB
# Saturation here is defined as S = C/L
# a and b must be normalized so a^2 + b^2 == 1
def computeMaxSaturation(a: float, b: float):
# Max saturation will be when one of r, g or b goes below zero.
# Select different coefficients depending on which component goes below zero first
# Blue component
k0 = +1.35733652
k1 = -0.00915799
k2 = -1.15130210
k3 = -0.50559606
k4 = +0.00692167
wl = -0.0041960863
wm = -0.7034186147
ws = +1.7076147010
if -1.88170328 * a - 0.80936493 * b > 1:
# Red component
k0 = +1.19086277
k1 = +1.76576728
k2 = +0.59662641
k3 = +0.75515197
k4 = +0.56771245
wl = +4.0767416621
wm = -3.3077115913
ws = +0.2309699292
elif 1.81444104 * a - 1.19445276 * b > 1:
# Green component
k0 = +0.73956515
k1 = -0.45954404
k2 = +0.08285427
k3 = +0.12541070
k4 = +0.14503204
wl = -1.2684380046
wm = +2.6097574011
ws = -0.3413193965
# Approximate max saturation using a polynomial:
maxS = k0 + k1 * a + k2 * b + k3 * a * a + k4 * a * b
# Do one step Halley's method to get closer
# this gives an error less than 10e6,
# except for some blue hues where the dS/dh is close to infinite
# this should be sufficient for most applications, otherwise do two/three steps
k_l = +0.3963377774 * a + 0.2158037573 * b
k_m = -0.1055613458 * a - 0.0638541728 * b
k_s = -0.0894841775 * a - 1.2914855480 * b
l_ = 1.0 + maxS * k_l
m_ = 1.0 + maxS * k_m
s_ = 1.0 + maxS * k_s
l = l_ * l_ * l_
m = m_ * m_ * m_
s = s_ * s_ * s_
l_dS = 3.0 * k_l * l_ * l_
m_dS = 3.0 * k_m * m_ * m_
s_dS = 3.0 * k_s * s_ * s_
l_dS2 = 6.0 * k_l * k_l * l_
m_dS2 = 6.0 * k_m * k_m * m_
s_dS2 = 6.0 * k_s * k_s * s_
f = wl * l + wm * m + ws * s
f1 = wl * l_dS + wm * m_dS + ws * s_dS
f2 = wl * l_dS2 + wm * m_dS2 + ws * s_dS2
maxS = maxS - f * f1 / (f1*f1 - 0.5 * f * f2)
return maxS
@staticmethod
# finds L_cusp and C_cusp for a given hue
# a and b must be normalized so a^2 + b^2 == 1
def findCuspLC(a: float, b: float):
# First, find the maximum saturation (saturation S = C/L)
maxS = Convert.computeMaxSaturation(a, b)
# Convert to linear sRGB to find the first point where at least one of r,g or b >= 1:
maxRgb = Convert.oklabToLinear(1, maxS * a, maxS * b)
cuspL = (1.0 / max(maxRgb[0], maxRgb[1], maxRgb[2])) ** (1 / 3)
cuspC = cuspL * maxS
return (cuspL, cuspC)
@staticmethod
# Finds intersection of the line defined by
# L = L0 * (1 - t) + t * L1
# C = t * C1
# a and b must be normalized so a^2 + b^2 == 1
def findGamutIntersection(a: float, b: float, l1: float, c1: float, l0: float, cuspLC=None):
# Find the cusp of the gamut triangle
if cuspLC is None:
cuspLC = Convert.findCuspLC(a, b)
# Find the intersection for upper and lower half separately
if ((l1 - l0) * cuspLC[1] - (cuspLC[0] - l1) * c1) <= 0.0:
# Lower half
t = cuspLC[1] * l0 / (c1 * cuspLC[0] + cuspLC[1] * (l0 - l1))
else:
# Upper half
# First intersect with triangle
t = cuspLC[1] * (l0 - 1.0) / (c1 * (cuspLC[0] - 1.0) + cuspLC[1] * (l0 - l1))
# Then one step Halley's method
dL = l1 - l0
dC = c1
k_l = +0.3963377774 * a + 0.2158037573 * b
k_m = -0.1055613458 * a - 0.0638541728 * b
k_s = -0.0894841775 * a - 1.2914855480 * b
l_dt = dL + dC * k_l
m_dt = dL + dC * k_m
s_dt = dL + dC * k_s
# If higher accuracy is required, 2 or 3 iterations of the following block can be used:
l = l0 * (1.0 - t) + t * l1
c = t * c1
l_ = l + c * k_l
m_ = l + c * k_m
s_ = l + c * k_s
l = l_ * l_ * l_
m = m_ * m_ * m_
s = s_ * s_ * s_
ldt = 3 * l_dt * l_ * l_
mdt = 3 * m_dt * m_ * m_
sdt = 3 * s_dt * s_ * s_
ldt2 = 6 * l_dt * l_dt * l_
mdt2 = 6 * m_dt * m_dt * m_
sdt2 = 6 * s_dt * s_dt * s_
r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s - 1
r1 = 4.0767416621 * ldt - 3.3077115913 * mdt + 0.2309699292 * sdt
r2 = 4.0767416621 * ldt2 - 3.3077115913 * mdt2 + 0.2309699292 * sdt2
u_r = r1 / (r1 * r1 - 0.5 * r * r2)
t_r = -r * u_r
g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s - 1
g1 = -1.2684380046 * ldt + 2.6097574011 * mdt - 0.3413193965 * sdt
g2 = -1.2684380046 * ldt2 + 2.6097574011 * mdt2 - 0.3413193965 * sdt2
u_g = g1 / (g1 * g1 - 0.5 * g * g2)
t_g = -g * u_g
b = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s - 1
b1 = -0.0041960863 * ldt - 0.7034186147 * mdt + 1.7076147010 * sdt
b2 = -0.0041960863 * ldt2 - 0.7034186147 * mdt2 + 1.7076147010 * sdt2
u_b = b1 / (b1 * b1 - 0.5 * b * b2)
t_b = -b * u_b
t_r = t_r if u_r >= 0.0 else sys.float_info.max
t_g = t_g if u_g >= 0.0 else sys.float_info.max
t_b = t_b if u_b >= 0.0 else sys.float_info.max
t += min(t_r, t_g, t_b)
return t
@staticmethod
def cuspToST(cuspLC: tuple):
l: float = cuspLC[0]
c: float = cuspLC[1]
return (c / l, c / (1 - l))
# Returns a smooth approximation of the location of the cusp
# This polynomial was created by an optimization process
# It has been designed so that S_mid < S_max and T_mid < T_max
@staticmethod
def getMidST(a_: float, b_: float):
s = 0.11516993 + 1.0 / (+7.44778970 + 4.15901240 * b_
+ a_ * (-2.19557347 + 1.75198401 * b_
+ a_ * (-2.13704948 - 10.02301043 * b_
+ a_ * (-4.24894561 + 5.38770819 * b_ + 4.69891013 * a_
))))
t = 0.11239642 + 1.0 / (+1.61320320 - 0.68124379 * b_
+ a_ * (+0.40370612 + 0.90148123 * b_
+ a_ * (-0.27087943 + 0.61223990 * b_
+ a_ * (+0.00299215 - 0.45399568 * b_ - 0.14661872 * a_
))))
return (s, t)
@staticmethod
def getCs(l: float, a_: float, b_: float):
cuspLC = Convert.findCuspLC(a_, b_)
cMax = Convert.findGamutIntersection(a_, b_, l, 1, l, cuspLC)
maxST = Convert.cuspToST(cuspLC)
# Scale factor to compensate for the curved part of gamut shape:
k = cMax / min(l * maxST[0], (1 - l) * maxST[1])
midST = Convert.getMidST(a_, b_)
# Use a soft minimum function,
# instead of a sharp triangle shape to get a smooth value for chroma.
cMid = 0.9 * k * (1 / (1 / (l * midST[0]) ** 4 + 1 / ((1 - l) * midST[1]) ** 4)) ** (1 / 4)
# for C_0, the shape is independent of hue, so ST are constant.
# Values picked to roughly be the average values of ST.
c0 = (1 / (1 / (l * 0.4) ** 2 + 1 / ((1 - l) * 0.8) ** 2)) ** (1 / 2)
return (c0, cMid, cMax)
@staticmethod
def rgbToTRC(rgb: tuple, trc: str):
if trc == "sRGB":
r = Convert.clampF(Convert.componentToSRGB(rgb[0]))
g = Convert.clampF(Convert.componentToSRGB(rgb[1]))
b = Convert.clampF(Convert.componentToSRGB(rgb[2]))
return (r, g, b)
else:
r = Convert.componentToLinear(rgb[0])
g = Convert.componentToLinear(rgb[1])
b = Convert.componentToLinear(rgb[2])
return (r, g, b)
@staticmethod
def rgbFToInt8(r: float, g: float, b: float, trc: str):
if trc == "sRGB":
r = int(r * 255)
g = int(g * 255)
b = int(b * 255)
else:
r = round(Convert.componentToSRGB(r) * 255)
g = round(Convert.componentToSRGB(g) * 255)
b = round(Convert.componentToSRGB(b) * 255)
return (r, g, b)
@staticmethod
def rgbFToHexS(r: float, g: float, b: float, trc: str):
# hex codes are in 8 bits per color
rgb = Convert.rgbFToInt8(r, g, b, trc)
# hex converts int to str with first 2 char being 0x
r = hex(rgb[0])[2:].zfill(2).upper()
g = hex(rgb[1])[2:].zfill(2).upper()
b = hex(rgb[2])[2:].zfill(2).upper()
return f"#{r}{g}{b}"
@staticmethod
def hexSToRgbF(syntax: str, trc: str):
if len(syntax) != 7:
print("Invalid syntax")
return
try:
r = int(syntax[1:3], 16) / 255.0
g = int(syntax[3:5], 16) / 255.0
b = int(syntax[5:7], 16) / 255.0
except ValueError:
print("Invalid syntax")
return
if trc == "sRGB":
return (r, g, b)
r = Convert.componentToLinear(r)
g = Convert.componentToLinear(g)
b = Convert.componentToLinear(b)
return (r, g, b)
@staticmethod
def rgbFToOklabS(r: float, g: float, b: float, trc: str):
# if rgb not linear, convert to linear for oklab conversion
if trc == "sRGB":
r = Convert.componentToLinear(r)
g = Convert.componentToLinear(g)
b = Convert.componentToLinear(b)
oklab = Convert.linearToOklab(r, g, b)
# l in percentage, a and b is 0 to 0.3+
okL = round(oklab[0] * 100, 2)
okA = Convert.roundZero(oklab[1], 4)
okB = Convert.roundZero(oklab[2], 4)
return f"oklab({okL}% {okA} {okB})"
@staticmethod
def oklabSToRgbF(syntax: str, trc: str):
strings = syntax[5:].strip("( )").split()
if len(strings) != 3:
print("Invalid syntax")
return
okL = strings[0]
okA = strings[1]
okB = strings[2]
try:
if "%" in okL:
okL = Convert.clampF(float(okL.strip("%")) / 100)
else:
okL = Convert.clampF(float(okL))
if "%" in okA:
okA = Convert.clampF(float(okA.strip("%")) / 250, 0.4, -0.4)
else:
okA = Convert.clampF(float(okA), 0.4, -0.4)
if "%" in okB:
okB = Convert.clampF(float(okB.strip("%")) / 250, 0.4, -0.4)
else:
okB = Convert.clampF(float(okB), 0.4, -0.4)
except ValueError:
print("Invalid syntax")
return
rgb = Convert.oklabToLinear(okL, okA, okB)
# if rgb not linear, perform transfer functions for components
r = Convert.componentToSRGB(rgb[0]) if trc == "sRGB" else rgb[0]
g = Convert.componentToSRGB(rgb[1]) if trc == "sRGB" else rgb[1]
b = Convert.componentToSRGB(rgb[2]) if trc == "sRGB" else rgb[2]
return (Convert.clampF(r), Convert.clampF(g), Convert.clampF(b))
@staticmethod
def rgbFToOklchS(r: float, g: float, b: float, trc: str):
# if rgb not linear, convert to linear for oklab conversion
if trc == "sRGB":
r = Convert.componentToLinear(r)
g = Convert.componentToLinear(g)
b = Convert.componentToLinear(b)
oklab = Convert.linearToOklab(r, g, b)
l = round(oklab[0] * 100, 2)
ch = Convert.cartesianToPolar(oklab[1], oklab[2])
c = ch[0]
h = 0
# chroma of neutral colors will not be exactly 0 due to floating point errors
if c < 0.000001:
c = 0
else:
# chroma adjustment due to rounding up blue hue
if 264.052 < ch[1] < 264.06:
h = 264.06
c = round(c - 0.0001, 4)
else:
h = round(ch[1], 2)
c = Convert.roundZero(c, 4)
# l in percentage, c is 0 to 0.3+, h in degrees
return f"oklch({l}% {c} {h})"
@staticmethod
def oklchSToRgbF(syntax: str, trc: str):
strings = syntax[5:].strip("( )").split()
if len(strings) != 3:
print("Invalid syntax")
return
l = strings[0]
c = strings[1]
h = strings[2]
try:
if "%" in l:
l = Convert.clampF(float(l.strip("%")) / 100)
else:
l = Convert.clampF(float(l))
if "%" in c:
c = Convert.clampF(float(c.strip("%")) / 250, 0.4)
else:
c = Convert.clampF(float(c), 0.4)
h = Convert.clampF(float(h.strip("deg")), 360.0)
except ValueError:
print("Invalid syntax")
return
# clip chroma if exceed sRGB gamut
ab = Convert.polarToCartesian(1, h)
if c:
u = Convert.findGamutIntersection(*ab, l, 1, l)
if c > u:
c = u
rgb = Convert.oklabToLinear(l, ab[0] * c, ab[1] * c)
# if rgb not linear, perform transfer functions for components
r = Convert.componentToSRGB(rgb[0]) if trc == "sRGB" else rgb[0]
g = Convert.componentToSRGB(rgb[1]) if trc == "sRGB" else rgb[1]
b = Convert.componentToSRGB(rgb[2]) if trc == "sRGB" else rgb[2]
return (Convert.clampF(r), Convert.clampF(g), Convert.clampF(b))
@staticmethod
def hSectorToRgbF(hSector: float, v: float, m: float, x: float, trc: str="sRGB"):
# assign max, med and min according to hue sector
if hSector == 1: # between yellow and green
r = x
g = v
b = m
elif hSector == 2: # between green and cyan
r = m
g = v
b = x
elif hSector == 3: # between cyan and blue
r = m
g = x
b = v
elif hSector == 4: # between blue and magenta
r = x
g = m
b = v
elif hSector == 5: # between magenta and red
r = v
g = m
b = x
else: # between red and yellow
r = v
g = x
b = m
# convert to linear if not sRGB
if trc == "sRGB":
return (r, g, b)
r = Convert.componentToLinear(r)
g = Convert.componentToLinear(g)
b = Convert.componentToLinear(b)
return (r, g, b)
@staticmethod
def rgbFToHsv(r: float, g: float, b: float, trc: str):
# if rgb is linear, convert to sRGB
if trc == "linear":
r = Convert.componentToSRGB(r)
g = Convert.componentToSRGB(g)
b = Convert.componentToSRGB(b)
# value is equal to max(R,G,B) while min(R,G,B) determines saturation
v = max(r,g,b)
m = min(r,g,b)
# chroma is the colorfulness of the color compared to the neutral color of equal value
c = v - m
if c == 0:
# hue cannot be determined if the color is neutral
return (0, 0, round(v * 100, 2))
# hue is defined in 60deg sectors
# hue = primary hue + deviation
# max(R,G,B) determines primary hue while med(R,G,B) determines deviation
# deviation has a range of -0.999... to 0.999...
if v == r:
# red is 0, range of hues that are predominantly red is -0.999... to 0.999...
# dividing (g - b) by chroma takes saturation and value out of the equation
# resulting in hue deviation of the primary color
h = ((g - b) / c) % 6
elif v == g:
# green is 2, range of hues that are predominantly green is 1.000... to 2.999...
h = (b - r) / c + 2
elif v == b:
# blue is 4, range of hues that are predominantly blue is 3.000... to 4.999...
h = (r - g) / c + 4
# saturation is the ratio of chroma of the color to the maximum chroma of equal value
# which is normalized chroma to fit the range of 0-1
s = c / v
return (round(h * 60, 2), round(s * 100, 2), round(v * 100, 2))
@staticmethod
def hsvToRgbF(h: float, s: float, v: float, trc: str):
# derive hue in 60deg sectors
h /= 60
hSector = int(h)
# scale saturation and value range from 0-100 to 0-1
s /= 100
v /= 100
# max(R,G,B) = value
# chroma = saturation * value
# min(R,G,B) = max(R,G,B) - chroma
m = v * (1 - s)
# calculate deviation from closest secondary color with range of -0.999... to 0.999...
# |deviation| = 1 - derived hue - hue sector if deviation is positive
# |deviation| = derived hue - hue sector if deviation is negative
d = h - hSector if hSector % 2 else 1 - (h - hSector)
# med(R,G,B) = max(R,G,B) - (|deviation| * chroma)
x = v * (1 - d * s)
return Convert.hSectorToRgbF(hSector, v, m, x, trc)
@staticmethod
def rgbFToHsl(r: float, g: float, b: float, trc: str):
# if rgb is linear, convert to sRGB
if trc == "linear":
r = Convert.componentToSRGB(r)
g = Convert.componentToSRGB(g)
b = Convert.componentToSRGB(b)
v = max(r,g,b)
m = min(r,g,b)
# lightness is defined as the midrange of the RGB components
l = (v + m) / 2
c = v - m
# hue cannot be determined if the color is neutral
if c == 0:
return (0, 0, round(l * 100, 2))
# same formula as hsv to find hue
if v == r:
h = ((g - b) / c) % 6
elif v == g:
h = (b - r) / c + 2
elif v == b:
h = (r - g) / c + 4
# saturation = chroma / chroma range
# max chroma range when lightness at half
s = c / (1 - abs(2 * l - 1))
return (round(h * 60, 2), round(s * 100, 2), round(l * 100, 2))
@staticmethod
def hslToRgbF(h: float, s: float, l: float, trc: str):
# derive hue in 60deg sectors
h /= 60
hSector = int(h)
# scale saturation and value range from 0-100 to 0-1
s /= 100
l /= 100
# max(R,G,B) = s(l) + l if l<0.5 else s(1 - l) + l
v = l * (1 + s) if l < 0.5 else s * (1 - l) + l
m = 2 * l - v
# calculate deviation from closest secondary color with range of -0.999... to 0.999...
d = h - hSector if hSector % 2 else 1 - (h - hSector)
x = v - d * (v - m)
return Convert.hSectorToRgbF(hSector, v, m, x, trc)
@staticmethod
def rgbFToHcy(r: float, g: float, b: float, h: float, trc: str, luma: bool):
# if y should always be luma, convert to sRGB
if luma and trc == "linear":
r = Convert.componentToSRGB(r)
g = Convert.componentToSRGB(g)
b = Convert.componentToSRGB(b)
# y can be luma or relative luminance depending on rgb format
y = Y709R * r + Y709G * g + Y709B * b
v = max(r, g, b)
m = min(r, g, b)
c = v - m
yHue = 0
# if color is neutral, use previous hue to calculate luma coefficient of hue
# max(R,G,B) coefficent + med(R,G,B) coefficient * deviation from max(R,G,B) hue
if (c != 0 and v == g) or (c == 0 and 60 <= h <= 180):
h = (b - r) / c + 2 if c != 0 else h / 60
if 1 <= h <= 2: # between yellow and green
d = h - 1
# luma coefficient of hue ranges from 0.9278 to 0.7152
yHue = Y709G + Y709R * (1 - d)
elif 2 < h <= 3: # between green and cyan
d = h - 2
# luma coefficient of hue ranges from 0.7152 to 0.7874
yHue = Y709G + Y709B * d
elif (c != 0 and v == b) or (c == 0 and 180 < h <= 300):
h = (r - g) / c + 4 if c != 0 else h / 60
if 3 < h <= 4: # between cyan and blue
d = h - 3
# luma coefficient of hue ranges from 0.7874 to 0.0722
yHue = Y709B + Y709G * (1 - d)
elif 4 < h <= 5: # between blue and magenta
d = h - 4
# luma coefficient of hue ranges from 0.0722 to 0.2848
yHue = Y709B + Y709R * d
elif (c != 0 and v == r) or (c == 0 and (h > 300 or h < 60)):
h = ((g - b) / c) % 6 if c != 0 else h / 60
if 5 < h <= 6: # between magenta and red
d = h - 5
# luma coefficient of hue ranges from 0.2848 to 0.2126
yHue = Y709R + Y709B * (1 - d)
elif 0 <= h < 1: # between red and yellow
d = h
# luma coefficient of hue ranges from 0.2126 to 0.9278
yHue = Y709R + Y709G * d
# calculate upper limit of chroma for hue and luma pair
u = y / yHue if y <= yHue else (1 - y) / (1 - yHue)
return (round(h * 60, 2), round(c * 100, 3), round(y * 100, 2), round(u * 100, 3))
@staticmethod
def hcyToRgbF(h: float, c: float, y: float, u: float, trc: str, luma: bool):
# derive hue in 60deg sectors
h /= 60
hSector = int(h)
# pass in y and u as -1 for max chroma conversions
if y != -1:
# scale luma to 1
y /= 100
if c == 0 or y == 0 or y == 1:
# if y is always luma, convert to linear
if luma and trc == "linear":
y = Convert.componentToLinear(y)
# luma coefficients add up to 1
return (y, y, y)
# calculate deviation from closest primary color with range of -0.999... to 0.999...
# |deviation| = 1 - derived hue - hue sector if deviation is negative
# |deviation| = derived hue - hue sector if deviation is positive
d = h - hSector if hSector % 2 == 0 else 1 - (h - hSector)
# calculate luma coefficient of hue
yHue = 0
if hSector == 1: # between yellow and green
yHue = Y709G + Y709R * d
elif hSector == 2: # between green and cyan
yHue = Y709G + Y709B * d
elif hSector == 3: # between cyan and blue
yHue = Y709B + Y709G * d
elif hSector == 4: # between blue and magenta
yHue = Y709B + Y709R * d
elif hSector == 5: # between magenta and red
yHue = Y709R + Y709B * d
else: # between red and yellow
yHue = Y709R + Y709G * d
# when chroma is at maximum, y = luma coefficient of hue
if y == -1:
y = yHue
# it is not always possible for chroma to be constant when adjusting hue or luma
# adjustment have to either clip chroma or have consistent saturation instead
cMax = y / yHue if y <= yHue else (1 - y) / (1 - yHue)
if u == -1:
# scale chroma to 1 before comparing
c /= 100
# clip chroma to new limit
if c > cMax:
c = cMax
else:
# scale chroma to hue or luma adjustment
s = 0
if u:
s = c / u
c = s * cMax
# luma = max(R,G,B) * yHue + min(R,G,B) * (1 - yHue)
# calculate min(R,G,B) based on the equation above
m = y - c * yHue
# med(R,G,B) = min(R,G,B) + (|deviation| * chroma)
x = y - c * (yHue - d)
# max(R,G,B) = min(R,G,B) + chroma
v = y + c * (1 - yHue)
# if y is always luma, hsector to rgbf needs trc param
if luma:
return Convert.hSectorToRgbF(hSector, v, m, x, trc)
return Convert.hSectorToRgbF(hSector, v, m, x)
@staticmethod
def rgbFToOkhcl(r: float, g: float, b: float, h: float, trc: str):
# if rgb not linear, convert to linear for oklab conversion
if trc == "sRGB":
r = Convert.componentToLinear(r)
g = Convert.componentToLinear(g)
b = Convert.componentToLinear(b)
oklab = Convert.linearToOklab(r, g, b)
l = oklab[0]
ch = Convert.cartesianToPolar(oklab[1], oklab[2])
c = ch[0]
# chroma of neutral colors will not be exactly 0 due to floating point errors
if c < 0.000001:
# use current hue to calulate chroma limit in sRGB gamut for neutral colors
ab = Convert.polarToCartesian(1, h)
cuspLC = Convert.findCuspLC(*ab)
u = Convert.findGamutIntersection(*ab, l, 1, l, cuspLC)
u /= cuspLC[1]
c = 0
else:
# gamut intersection jumps for parts of blue
h = ch[1] if not 264.052 < ch[1] < 264.06 else 264.06
# a and b must be normalized to c = 1 to calculate chroma limit in sRGB gamut
a_ = oklab[1] / c
b_ = oklab[2] / c
cuspLC = Convert.findCuspLC(a_, b_)
u = Convert.findGamutIntersection(a_, b_, l, 1, l, cuspLC)
if c > u:
c = u
u /= cuspLC[1]
c /= cuspLC[1]
l = Convert.toe(l)
return (round(h, 2), round(c * 100, 3), round(l * 100, 2), round(u * 100, 3))
@staticmethod
def okhclToRgbF(h: float, c: float, l: float, u: float, trc: str):
# convert lref back to okL
l = Convert.toeInv(l / 100)
# clip chroma if exceed sRGB gamut
ab = (0, 0)
if c:
ab = Convert.polarToCartesian(1, h)
cuspLC = Convert.findCuspLC(*ab)
cMax = Convert.findGamutIntersection(*ab, l, 1, l, cuspLC)
if u == -1:
c = c / 100 * cuspLC[1]
if c > cMax:
c = cMax
else:
s = c / u
c = s * cMax
ab = Convert.polarToCartesian(c, h)
rgb = Convert.oklabToLinear(l, *ab)
# perform transfer functions for components if output to sRGB
r = Convert.componentToSRGB(rgb[0]) if trc == "sRGB" else rgb[0]
g = Convert.componentToSRGB(rgb[1]) if trc == "sRGB" else rgb[1]
b = Convert.componentToSRGB(rgb[2]) if trc == "sRGB" else rgb[2]
return (Convert.clampF(r), Convert.clampF(g), Convert.clampF(b))
@staticmethod
def rgbFToOkhsv(r: float, g: float, b: float, trc: str):
# if rgb not linear, convert to linear for oklab conversion
if trc == "sRGB":
r = Convert.componentToLinear(r)
g = Convert.componentToLinear(g)
b = Convert.componentToLinear(b)
oklab = Convert.linearToOklab(r, g, b)
l = oklab[0]
ch = Convert.cartesianToPolar(oklab[1], oklab[2])
c = ch[0]
# chroma of neutral colors will not be exactly 0 due to floating point errors
if c < 0.000001:
return (0, 0, round(Convert.toe(l) * 100, 2))
else:
# gamut intersection jumps for parts of blue
h = ch[1] if not 264.052 < ch[1] < 264.06 else 264.06
# a and b must be normalized to c = 1 to calculate chroma limit in sRGB gamut
a_ = oklab[1] / c
b_ = oklab[2] / c
cuspLC = Convert.findCuspLC(a_, b_)
st = Convert.cuspToST(cuspLC)
sMax = st[0]
tMax = st[1]
s0 = 0.5
k = 1 - s0 / sMax
# first we find L_v, C_v, L_vt and C_vt
t = tMax / (c + l * tMax)
l_v = t * l
c_v = t * c
l_vt = Convert.toeInv(l_v)
c_vt = c_v * l_vt / l_v
# we can then use these to invert the step that compensates for the toe
# and the curved top part of the triangle:
rgbScale = Convert.oklabToLinear(l_vt, a_ * c_vt, b_ * c_vt)
scaleL = (1 / max(rgbScale[0], rgbScale[1], rgbScale[2])) ** (1 / 3)
l = Convert.toe(l / scaleL)
# // we can now compute v and s:
v = l / l_v
s = (s0 + tMax) * c_v / ((tMax * s0) + tMax * k * c_v)
if s > 1:
s = 1.0
return (round(h, 2), round(s * 100, 2), round(v * 100, 2))
@staticmethod
def okhsvToRgbF(h: float, s: float, v: float, trc: str):
# scale saturation and value range from 0-100 to 0-1
s /= 100
v /= 100
rgb = None
if v == 0:
return (0, 0, 0)
elif s == 0:
rgb = Convert.oklabToLinear(Convert.toeInv(v), 0, 0)
else:
ab = Convert.polarToCartesian(1, h)
cuspLC = Convert.findCuspLC(*ab)
st = Convert.cuspToST(cuspLC)
sMax = st[0]
tMax = st[1]
s0 = 0.5
k = 1 - s0 / sMax
# first we compute L and V as if the gamut is a perfect triangle:
# L, C when v==1:
l_v = 1 - s * s0 / (s0 + tMax - tMax * k * s)
c_v = s * tMax * s0 / (s0 + tMax - tMax * k * s)
l = v * l_v
c = v * c_v
# then we compensate for both toe and the curved top part of the triangle:
l_vt = Convert.toeInv(l_v)
c_vt = c_v * l_vt / l_v
l_new = Convert.toeInv(l)
c *= l_new / l
l = l_new
rgbScale = Convert.oklabToLinear(l_vt, ab[0] * c_vt, ab[1] * c_vt)
scaleL = (1 / max(rgbScale[0], rgbScale[1], rgbScale[2])) ** (1 / 3)
l *= scaleL
c *= scaleL
rgb = Convert.oklabToLinear(l, ab[0] * c, ab[1] * c)
# perform transfer functions for components if output to sRGB
r = Convert.componentToSRGB(rgb[0]) if trc == "sRGB" else rgb[0]
g = Convert.componentToSRGB(rgb[1]) if trc == "sRGB" else rgb[1]
b = Convert.componentToSRGB(rgb[2]) if trc == "sRGB" else rgb[2]
return (Convert.clampF(r), Convert.clampF(g), Convert.clampF(b))
@staticmethod
def rgbFToOkhsl(r: float, g: float, b: float, trc: str):
# if rgb not linear, convert to linear for oklab conversion
if trc == "sRGB":
r = Convert.componentToLinear(r)
g = Convert.componentToLinear(g)
b = Convert.componentToLinear(b)
oklab = Convert.linearToOklab(r, g, b)
l = oklab[0]
ch = Convert.cartesianToPolar(oklab[1], oklab[2])
s = 0
c = ch[0]
# chroma of neutral colors will not be exactly 0 due to floating point errors
if c >= 0.000001:
a_ = oklab[1] / c
b_ = oklab[2] / c
cs = Convert.getCs(l, a_, b_)
c0 = cs[0]
cMid = cs[1]
cMax = cs[2]
# Inverse of the interpolation in okhsl_to_srgb:
mid = 0.8
midInv = 1.25
if c < cMid:
k1 = mid * c0
k2 = 1 - k1 / cMid
t = c / (k1 + k2 * c)
s = t * mid
else:
k1 = (1 - mid) * cMid * cMid * midInv * midInv / c0
k2 = 1 - k1 / (cMax - cMid)
t = (c - cMid) / (k1 + k2 * (c - cMid))
s = mid + (1 - mid) * t
# gamut intersection jumps for parts of blue
h = ch[1] if not 264.052 < ch[1] < 264.06 else 264.06
l = Convert.toe(l)
return (round(h, 2), round(s * 100, 2), round(l * 100, 2))
@staticmethod
def okhslToRgbF(h: float, s: float, l: float, trc: str):
# scale saturation and lightness range from 0-100 to 0-1
s /= 100
l /= 100
if l == 0 or l == 1:
return (l, l, l)
ab = Convert.polarToCartesian(1, h)
l = Convert.toeInv(l)
c = 0
if s:
cs = Convert.getCs(l, *ab)
c0 = cs[0]
cMid = cs[1]
cMax = cs[2]
# Interpolate the three values for C so that:
# At s=0: dC/ds = C_0, C=0
# At s=0.8: C=C_mid
# At s=1.0: C=C_max
mid = 0.8
midInv = 1.25
if s < mid:
t = midInv * s
k1 = mid * c0
k2 = 1 - k1 / cMid
c = t * k1 / (1 - k2 * t)
else:
t = (s - mid) / (1 - mid)
k1 = (1 - mid) * cMid * cMid * midInv * midInv / c0
k2 = 1 - k1 / (cMax - cMid)
c = cMid + t * k1 / (1 - k2 * t)
rgb = Convert.oklabToLinear(l, ab[0] * c, ab[1] * c)
# perform transfer functions for components if output to sRGB
r = Convert.componentToSRGB(rgb[0]) if trc == "sRGB" else rgb[0]
g = Convert.componentToSRGB(rgb[1]) if trc == "sRGB" else rgb[1]
b = Convert.componentToSRGB(rgb[2]) if trc == "sRGB" else rgb[2]
return (Convert.clampF(r), Convert.clampF(g), Convert.clampF(b))
Reference in New Issue Copy Permalink