Hi! I just stumbled upon this thread and thought I'd share an OKLab conversion DCTL I wrote about a year ago. It;s written as a header file to be included in any other DCTL you may need it for. It supports conversion from ACES, Davinci Wide and Rec.709/sRGB.
OKLab_Transform.h:
#line 2
#ifndef ENCODING_ENUMS_DEFINED_IN_UI
enum Encoding
{
gAcc,
gAcct,
gDWI,
gLIN,
g709,
gSRGB
};
#endif
#ifndef COLORSPACE_ENUMS_DEFINED_IN_UI
enum ColorSpace
{
cACES0,
cACES1,
cDWG,
c709
};
#endif
// =============================================================
// Util
// =============================================================
// =============================================================
__DEVICE__ float powCf(float base, float exp)
{
return _copysignf(_powf(_fabs(base), exp), base);
}
__DEVICE__ float3 VecMatMul3x3(const float3 m[3], float3 v)
{
float3 r;
r.x = m[0].x * v.x + m[0].y * v.y + m[0].z * v.z;
r.y = m[1].x * v.x + m[1].y * v.y + m[1].z * v.z;
r.z = m[2].x * v.x + m[2].y * v.y + m[2].z * v.z;
return r;
}
// =============================================================
// Matrices
// =============================================================
// =============================================================
// These matrices are the concatenated forms of (colorspace -> XYZ -> OKlms)
// or, XYZToLMS @ ColorspaceToXYZ and, XYZToColorspace @ LMSToXYZ
// original matrices are included as comments at the bottom of this script
// ACES (AP0)
// ==============================
__CONSTANT__ float3 mat_ACES0_LMS[3] =
{
{0.90454662f, 0.26349909f, -0.15602258f },
{0.35107161f, 0.6766934f, -0.03056591f },
{0.13684644f, 0.19250255f, 0.62038067f }
};
__CONSTANT__ float3 mat_LMS_ACES0[3] =
{
{1.2881401f, -0.58554348f, 0.29511118f },
{-0.67171287f, 1.76268516f, -0.08208556f },
{-0.0757131f, -0.41779486f, 1.57228749f }
};
// ACES (AP1)
// ==============================
__CONSTANT__ float3 mat_ACES1_LMS[3] =
{
{0.64173446f, 0.35314498f, 0.0171437f },
{0.27463463f, 0.63099904f, 0.09156544f },
{0.10036508f, 0.18723743f, 0.66212716f }
};
__CONSTANT__ float3 mat_LMS_ACES1[3] =
{
{2.04479741f, -1.17697875f, 0.10982058f },
{-0.88115384f, 2.15979229f, -0.27586256f },
{-0.06077576f, -0.43234352f, 1.57164623f }
};
// ITU BT.709
// ==============================
__CONSTANT__ float3 mat_709_LMS[3] =
{
{ 0.4122214708f, 0.5363325363f, 0.0514459929f },
{ 0.2119034982f, 0.6806995451f, 0.1073969566f },
{ 0.0883024619f, 0.2817188376f, 0.6299787005f }
};
__CONSTANT__ float3 mat_LMS_709[3] =
{
{ 4.0767416621f, -3.3077115913f, 0.2309699292f },
{ -1.2684380046f, 2.6097574011f, -0.3413193965f },
{ -0.0041960863f, -0.7034186147f, 1.7076147010f }
};
// Davinci Wide
// ==============================
__CONSTANT__ float3 mat_DWG_LMS[3] =
{
{ 0.68570951f, 0.45574409f, -0.14156279f },
{ 0.27427422f, 0.81179945f, -0.08604675f },
{ 0.04351009f, 0.15072461f, 0.80624495f }
};
__CONSTANT__ float3 mat_LMS_DWG[3] =
{
{ 1.8836253f, -1.09713301f, 0.21364045f },
{ -0.63460063f, 1.57752473f, 0.05693684f },
{ 0.01698397f, -0.23570436f, 1.21814431f }
};
// OKLab <-> Cone Response
// ==============================
__CONSTANT__ float3 mat_LMS_LAB[3] =
{
{ 0.2104542553f, 0.7936177850f, -0.0040720468f },
{ 1.9779984951f, -2.4285922050f, 0.4505937099f },
{ 0.0259040371f, 0.7827717662f, -0.8086757660f }
};
__CONSTANT__ float3 mat_LAB_LMS[3] =
{
{ 1.0f, 0.3963377774f, 0.2158037573f },
{ 1.0f, -0.1055613458f, -0.0638541728f },
{ 1.0f, -0.0894841775f, -1.2914855480f }
};
// =============================================================
// Transfer Functions
// =============================================================
// =============================================================
// ACEScc
// ==============================
__DEVICE__ float ACEScc_DecodeBase(float v, float a, float b, float upperClampThreshold, float lowerDecodeThreshold, float two_m16)
{
float out = v;
if (v >= upperClampThreshold)
out = 65504.0f;
else if (v < lowerDecodeThreshold)
out = (_exp2f(v * b - a) - two_m16) * 2.0f;
else
out = _exp2f(v * b - a);
return out;
}
__DEVICE__ float3 ACEScc_Decode(float3 in)
{
const float two_m16 = _exp2f(-16.0f);
const float a = 9.72f;
const float b = 17.52f;
const float lowerDecodeThreshold = (a - 15.0f) / b;
const float upperClampThreshold = (_log2f(65504.0f) + a) / b;
float3 out = in;
out.x = ACEScc_DecodeBase(out.x, a, b, upperClampThreshold, lowerDecodeThreshold, two_m16);
out.y = ACEScc_DecodeBase(out.y, a, b, upperClampThreshold, lowerDecodeThreshold, two_m16);
out.z = ACEScc_DecodeBase(out.z, a, b, upperClampThreshold, lowerDecodeThreshold, two_m16);
return out;
}
__DEVICE__ float ACEScc_EncodeBase(float v, float a, float b, float negConstant, float two_m15, float two_m16)
{
float out;
if (v < 0.0f)
out = negConstant;
else if (v < two_m15)
out = (_log2f(two_m16 + v * 0.5f) + a) / b;
else
out = (_log2f(v) + a) / b;
return out;
}
__DEVICE__ float3 ACEScc_Encode(float3 in)
{
const float two_m16 = _exp2f(-16.0f);
const float two_m15 = _exp2f(-15.0f);
const float a = 9.72f;
const float b = 17.52f;
const float negConstant = (_log2f(two_m16) + a) / b;
float3 out = in;
out.x = ACEScc_EncodeBase(out.x, a, b, negConstant, two_m15, two_m16);
out.y = ACEScc_EncodeBase(out.y, a, b, negConstant, two_m15, two_m16);
out.z = ACEScc_EncodeBase(out.z, a, b, negConstant, two_m15, two_m16);
return out;
}
// ACEScct
// ==============================
__DEVICE__ float3 ACEScct_Encode(float3 in)
{
const float a = 9.72f;
const float b = 17.52f;
const float X_BRK = 0.0078125f;
const float A = 10.5402377416545f;
const float B = 0.0729055341958355f;
float3 out;
out.x = (in.x <= X_BRK) ? (A * in.x + B) : ((_log2f(in.x) + a) / b);
out.y = (in.y <= X_BRK) ? (A * in.y + B) : ((_log2f(in.y) + a) / b);
out.z = (in.z <= X_BRK) ? (A * in.z + B) : ((_log2f(in.z) + a) / b);
return out;
}
__DEVICE__ float3 ACEScct_Decode(float3 in)
{
const float a = 9.72f;
const float b = 17.52f;
const float Y_BRK = 0.155251141552511f;
const float A = 10.5402377416545f;
const float B = 0.0729055341958355f;
float3 out = in;
out.x = (in.x > Y_BRK) ? _exp2f(in.x * b - a) : ((in.x - B) / A);
out.y = (in.y > Y_BRK) ? _exp2f(in.y * b - a) : ((in.y - B) / A);
out.z = (in.z > Y_BRK) ? _exp2f(in.z * b - a) : ((in.z - B) / A);
return out;
}
// Davinci Intermediate
// ==============================
__DEVICE__ float3 DWI_Decode(float3 in)
{
float3 out = in;
float a = 0.0075;
float b = 7.0;
float c = 0.07329248;
float m = 10.44426855;
float log_cut = 0.02740668;
out.x = in.x > log_cut ? powCf(2.0f, (in.x / c) - b) - a : in.x / m;
out.y = in.y > log_cut ? powCf(2.0f, (in.y / c) - b) - a : in.y / m;
out.z = in.z > log_cut ? powCf(2.0f, (in.z / c) - b) - a : in.z / m;
return out;
}
__DEVICE__ float3 DWI_Encode(float3 in)
{
float3 out = in;
float a = 0.0075;
float b = 7.0;
float c = 0.07329248;
float m = 10.44426855;
float lin_cut = 0.00262409;
out.x = in.x > lin_cut ? (_log2f(in.x + a) + b) * c : in.x * m;
out.y = in.y > lin_cut ? (_log2f(in.y + a) + b) * c : in.y * m;
out.z = in.z > lin_cut ? (_log2f(in.z + a) + b) * c : in.z * m;
return out;
}
// ITU BT.709
// ==============================
__DEVICE__ float3 BT709_Decode(float3 in)
{
float3 out = in;
out.x = out.x < 0.081f ? out.x / 4.5f : powCf((out.x + 0.099f) / 1.099f, 1.0f / 0.45f);
out.y = out.y < 0.081f ? out.y / 4.5f : powCf((out.y + 0.099f) / 1.099f, 1.0f / 0.45f);
out.z = out.z < 0.081f ? out.z / 4.5f : powCf((out.z + 0.099f) / 1.099f, 1.0f / 0.45f);
return out;
}
__DEVICE__ float3 BT709_Encode(float3 in)
{
float3 out = in;
out.x = out.x < 0.018 ? out.x * 4.5f : 1.099f * powCf(out.x, 0.45f) - 0.099f;
out.y = out.y < 0.018 ? out.y * 4.5f : 1.099f * powCf(out.y, 0.45f) - 0.099f;
out.z = out.z < 0.018 ? out.z * 4.5f : 1.099f * powCf(out.z, 0.45f) - 0.099f;
return out;
}
// sRGB
// ==============================
__DEVICE__ float3 sRGB_Decode(float3 in)
{
float3 out = in;
out.x = out.x < 0.04045 ? out.x / 12.92f : powCf((out.x + 0.055f) / 1.055f, 2.4f);
out.y = out.y < 0.04045 ? out.y / 12.92f : powCf((out.y + 0.055f) / 1.055f, 2.4f);
out.z = out.z < 0.04045 ? out.z / 12.92f : powCf((out.z + 0.055f) / 1.055f, 2.4f);
return out;
}
__DEVICE__ float3 sRGB_Encode(float3 in)
{
float3 out = in;
out.x = out.x < 0.0031308 ? out.x * 12.92f : 1.055f * powCf(out.x, 1.0f / 2.4f) - 0.055f;
out.y = out.y < 0.0031308 ? out.y * 12.92f : 1.055f * powCf(out.y, 1.0f / 2.4f) - 0.055f;
out.z = out.z < 0.0031308 ? out.z * 12.92f : 1.055f * powCf(out.z, 1.0f / 2.4f) - 0.055f;
return out;
}
// =============================================================
// Convert
// =============================================================
// =============================================================
__DEVICE__ float3 Decode(float3 in, int tFunction)
{
float3 out = in;
switch (tFunction)
{
case gAcc:
out = ACEScc_Decode(in);
break;
case gAcct:
out = ACEScct_Decode(in);
break;
case gDWI:
out = DWI_Decode(in);
break;
case g709:
out = BT709_Decode(in);
break;
case gSRGB:
out = sRGB_Decode(in);
break;
}
return out;
}
__DEVICE__ float3 Encode(float3 in, int tFunction)
{
float3 out = in;
switch (tFunction)
{
case gAcc:
out = ACEScc_Encode(in);
break;
case gAcct:
out = ACEScct_Encode(in);
break;
case gDWI:
out = DWI_Encode(in);
break;
case g709:
out = BT709_Encode(in);
break;
case gSRGB:
out = sRGB_Encode(in);
break;
}
return out;
}
__DEVICE__ float3 OKLab_OKLCh(float3 lab)
{
float C = _hypotf(lab.y, lab.z);
float h = _atan2f(lab.z, lab.y);
return make_float3(lab.x, C, h);
}
__DEVICE__ float3 OKLCh_OKLab(float3 lch)
{
float a = lch.y * cosf(lch.z);
float b = lch.y * sinf(lch.z);
return make_float3(lch.x, a, b);
}
__DEVICE__ float3 RGB_OKLab(float3 rgb, int colorspace)
{
const float3* mat;
switch (colorspace)
{
case cACES0:
mat = mat_ACES0_LMS;
break;
case cACES1:
mat = mat_ACES1_LMS;
break;
case cDWG:
mat = mat_DWG_LMS;
break;
case c709:
mat = mat_709_LMS;
break;
}
float3 lms = VecMatMul3x3(mat, rgb);
float3 lms_;
lms_.x = cbrt(lms.x);
lms_.y = cbrt(lms.y);
lms_.z = cbrt(lms.z);
return VecMatMul3x3(mat_LMS_LAB, lms_);
}
__DEVICE__ float3 OKLab_RGB(float3 lab, int colorspace)
{
const float3* mat;
switch (colorspace)
{
case cACES0:
mat = mat_LMS_ACES0;
break;
case cACES1:
mat = mat_LMS_ACES1;
break;
case cDWG:
mat = mat_LMS_DWG;
break;
case c709:
mat = mat_LMS_709;
break;
}
float3 lms = VecMatMul3x3(mat_LAB_LMS, lab);
lms.x = powCf(lms.x, 3.0f);
lms.y = powCf(lms.y, 3.0f);
lms.z = powCf(lms.z, 3.0f);
return VecMatMul3x3(mat, lms);
}
__DEVICE__ float3 RGB_OkLCh(float3 rgb, int colorspace)
{
float3 lab = RGB_OKLab(rgb, colorspace);
return OKLab_OKLCh(lab);
}
__DEVICE__ float3 OKLCh_RGB(float3 lch, int colorspace)
{
float3 lab = OKLCh_OKLab(lch);
return OKLab_RGB(lab, colorspace);
}
// =============================================================
// Ref Matrices
// =============================================================
// =============================================================
// DWG -> XYZ
// 0.70062239, 0.14877482, 0.10105872
// 0.27411851, 0.87363190, -0.14775041
// -0.09896291, -0.13789533, 1.32591599
// XYZ -> DWG
// 1.51667204, -0.28147805, -0.14696363
// -0.46491710, 1.25142378, 0.17488461
// 0.06484905, 0.10913934, 0.76141462
// 709 -> XYZ
// 0.4123908, 0.35758434, 0.18048079
// 0.21263901, 0.71516868, 0.07219232
// 0.01933082, 0.11919478, 0.95053215
// XYZ -> 709
// 3.24096994, -1.53738318, -0.49861076
// -0.96924364, 1.8759675, 0.04155506
// 0.05563008, -0.20397696 , 1.05697151
// XYZ -> LMS
// 0.8189330101, 0.3618667424, -0.1288597137
// 0.0329845436, 0.9293118715, 0.0361456387
// 0.0482003018, 0.2643662691, 0.6338517070
// LMS -> XYZ
// 1.22701385, -0.55779998, 0.28125615
// -0.04058018, 1.11225687, -0.07167668
// -0.07638128, -0.42148198, 1.58616322
Using it another DCTL looks something like this:
#line 2
#define ENCODING_ENUMS_DEFINED_IN_UI
#define COLORSPACE_ENUMS_DEFINED_IN_UI
#include "OKLab_Transforms.h"
DEFINE_UI_PARAMS(p_InCSpace, Input Color Space, DCTLUI_COMBO_BOX, 2, {cACES0, cACES1, cDWG, c709}, {ACES (AP0), ACES (AP1), Davinci Wide Gamut, Rec.709 / sRGB / BT.1886});
DEFINE_UI_PARAMS(p_InGamma, Input Gamma, DCTLUI_COMBO_BOX, 2, {gAcc, gAcct, gDWI, gLIN, g709, gSRGB}, {ACEScc, ACEScct, Davinci Intermediate, Linear, Rec.709, sRGB});
__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y, float p_R, float p_G, float p_B)
{
float3 in = make_float3(p_R, p_G, p_B);
float3 out = in;
// Convert to OKLCh:
float3 linear = Decode(in, p_InGamma);
float3 oklch = RGB_OkLCh(linear, p_InCSpace);
// Convert back:
linear = OKLCh_RGB(oklch, p_InCSpace);
out = Encode(linear, p_InGamma);
return out;
}
