mucolor 0.1.0__py3-none-any.whl

mucolor-0.1.0.dist-info/METADATA

@@ -0,0 +1,318 @@
+Metadata-Version: 2.5
+Name: mucolor
+Version: 0.1.0
+Summary: Minimal pure-python colorimetry: gamuts, transfer functions and colorspace conversion with no dependencies.
+Project-URL: Source, https://github.com/jedypod/mucolor
+Author-email: Jed Smith <jed.coma316@passmail.net>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# mucolor
+
+**μcolor**, "micro color". The "mu" is the Greek letter μ, the SI symbol for micro: one
+millionth. The name is the goal: the colorimetry a pipeline needs, made as small as it can be.
+
+Minimal pure-python colorimetry calculations, transfer functions and colorspace conversions. 
+
+Convert stimuli between camera, working and display colorspaces. Pure Python, one file,
+no dependencies.
+
+## Install
+
+mucolor is a single file. Either copy `mucolor.py` next to your own code, or install it
+from this folder:
+
+```
+pip install .
+```
+
+## Quick start
+
+```python
+import mucolor as mc
+
+# Convert one RGB triplet: (red, green, blue), from colorspace, to colorspace
+mc.convert((0.41, 0.41, 0.41), 'sony-sgamut3-slog3', 'acescg')
+# -> (0.179, 0.179, 0.179)
+```
+
+An RGB triplet is a tuple of three numbers: `(red, green, blue)`. The result is a tuple too.
+
+## Colorspace names
+
+Every colorspace has a long name, a short name and an alias. You can use any of them, and
+upper or lower case does not matter. These all result in the same colorspace conversion:
+
+```python
+rgb = (0.41, 0.41, 0.41)
+
+mc.convert(rgb, 'Sony - S-Gamut3 - S-Log3', 'acescg')
+mc.convert(rgb, 'sony-sgamut3-slog3', 'acescg')
+mc.convert(rgb, 'sg3lg3', 'acescg')
+```
+
+The [full list](#colorspaces) is at the end of this page. To list them from Python:
+
+```python
+for cs in mc.colorspaces():
+    print(cs.shortname, '|', cs.name)
+```
+
+If you misspell a name, the error suggests close matches:
+
+```
+KeyError: "unknown colorspace 'slog3', did you mean 'smlg', 'sg3ln'?"
+```
+
+## Converting many stimuli
+
+`convert` looks up both colorspaces every time you call it. To convert a lot of stimuli
+between the same two colorspaces, make a converter once and reuse it:
+
+```python
+slog3_to_acescg = mc.converter('sony-sgamut3-slog3', 'acescg')
+
+slog3_to_acescg((0.41, 0.41, 0.41))   # -> (0.179, 0.179, 0.179)
+slog3_to_acescg((0.6, 0.5, 0.4))      # -> (1.107, 0.434, 0.160)
+```
+
+For bigger challenges, use [numpy](#numpy-arrays) which is much faster to process.
+
+## Transfer functions on their own
+
+A transfer function turns linear signal into code values and back. Each one has two methods:
+
+- `encode`: linear signal -> code value
+- `decode`: code value -> linear signal
+
+They work on one number at a time, not an RGB triplet:
+
+```python
+mc.sony_slog3.encode(0.18)    # -> 0.411  (18% grey in S-Log3)
+mc.sony_slog3.decode(0.41)    # -> 0.179
+```
+
+## Matrices
+
+`matrix` gives the 3x3 matrix between the linear versions of two colorspaces, as a tuple of
+three rows:
+
+```python
+mc.matrix('p3d65-lin', 'rec709-lin')
+# -> ((1.2249, -0.2249, 0.0), (-0.0421, 1.0421, 0.0), (-0.0196, -0.0786, 1.0983))
+```
+
+## numpy arrays
+
+The functions above work on one RGB triplet at a time, which is slow for large jobs such as
+baking a LUT or converting an image. If you have [numpy](https://numpy.org) installed,
+add `np=True` to work on whole arrays at once:
+
+```python
+import numpy as np
+import mucolor as mc
+
+rgb = np.array([   # two RGB triplets
+    [0.41, 0.41, 0.41],
+    [0.6, 0.5, 0.4],
+])
+mc.convert(rgb, 'sony-sgamut3-slog3', 'acescg', np=True)
+# -> array([[0.179, 0.179, 0.179],
+#           [1.107, 0.434, 0.160]])
+```
+
+`np=True` works the same way everywhere:
+
+```python
+f = mc.converter('sony-sgamut3-slog3', 'acescg', np=True)
+f(rgb)
+
+mc.sony_slog3.decode(np.array([0.1, 0.41, 0.6]), np=True)
+# -> array([0.0011, 0.179, 1.037])
+```
+
+Things to know:
+
+- The array can have any shape, as long as the last axis holds the three channels: a list
+  of RGB triplets `(n, 3)`, an image `(height, width, 3)`, or a LUT grid `(n, n, n, 3)`.
+- You always get a new array back. Your input array is never changed.
+- numpy is only needed when you use `np=True`. Without numpy installed, everything else
+  still works.
+- A value a curve cannot handle, such as a negative number into a pure log curve, gives
+  `nan` and a numpy warning. Without `np=True` the same value raises an error.
+
+### Example: bake a 3D LUT to a .cube file
+
+```python
+import numpy as np
+import mucolor as mc
+
+size = 33
+
+# A grid of every input RGB triplet. In a .cube file red changes fastest, then green, then blue.
+steps = np.linspace(0.0, 1.0, size)
+b, g, r = np.meshgrid(steps, steps, steps, indexing='ij')
+grid = np.stack([r, g, b], axis=-1)    # shape (33, 33, 33, 3)
+
+lut = mc.convert(grid, 'arri-wg4-logc4', 'davinci-wg-ilog', np=True)
+
+with open('logc4_to_davinci.cube', 'w') as file:
+    file.write(f'LUT_3D_SIZE {size}\n')
+    for red, green, blue in lut.reshape(-1, 3):
+        file.write(f'{red:.6f} {green:.6f} {blue:.6f}\n')
+```
+
+## Conventions
+
+- **Linear signal**: scene-linear 0.18 is 18% grey. For display colorspaces, linear 1.0 is
+  100 nits, including `pq` and `hlg`.
+- **No "tone mapping"**: mucolor converts colorimetry exactly. Converting a camera log
+  image straight to a display colorspace gives values above 1.0 for bright areas, the
+  same as a plain colorspace conversion in other software. It is not a viewing transform.
+- **Chromatic adaptation**: when two colorspaces have different white points, mucolor
+  adapts between them with CAT02. Pass `cat='bradford'` to use Bradford, or `cat=None`
+  for none: `mc.convert((0.18, 0.18, 0.18), 'aces', 'rec709-lin', cat='bradford')`.
+- **Gamuts** are flat tuples of xy chromaticities: `(rx, ry, gx, gy, bx, by, wx, wy)`.
+  `mc.matrix` and `mc.npm` accept these as well as colorspace names.
+
+## Colorspaces
+
+The short name is shown. `encoding` tells you what kind of values the colorspace holds.
+
+| Short name | Name | Encoding |
+|---|---|---|
+| `xyz-d65` | XYZ D65 | scene-linear |
+| `xyz-e` | XYZ E | scene-linear |
+| `aces` | ACES 2065-1 | scene-linear |
+| `acescg` | ACEScg | scene-linear |
+| `acescct` | ACEScct | log |
+| `jplog2` | JPLog2 | log |
+| `filmlight-egamut-lin` | Filmlight - E-Gamut - Linear | scene-linear |
+| `filmlight-egamut-tlog` | Filmlight - E-Gamut - T-Log | log |
+| `filmlight-egamut2-lin` | Filmlight - E-Gamut2 - Linear | scene-linear |
+| `filmlight-egamut2-tlog` | Filmlight - E-Gamut2 - T-Log | log |
+| `filmlight-egamut2-tloge` | Filmlight - E-Gamut2 - T-LogE | log |
+| `davinci-wg-lin` | DaVinci - WideGamut - Linear | scene-linear |
+| `davinci-wg-ilog` | DaVinci - WideGamut - Intermediate Log | log |
+| `arri-wg3-lin` | Arri - WideGamut3 - Linear | scene-linear |
+| `arri-wg3-logc3` | Arri - WideGamut3 - LogC3 | log |
+| `arri-wg4-lin` | Arri - WideGamut4 - Linear | scene-linear |
+| `arri-wg4-logc4` | Arri - WideGamut4 - LogC4 | log |
+| `blackmagic-wg-lin` | Blackmagic - WideGamut - Linear | scene-linear |
+| `blackmagic-wg-gen5log` | Blackmagic - WideGamut - Gen5 Log | log |
+| `canon-cgamut-lin` | Canon - C-Gamut - Linear | scene-linear |
+| `canon-cgamut-clog2` | Canon - C-Gamut - C-Log2 | log |
+| `canon-cgamut-clog3` | Canon - C-Gamut - C-Log3 | log |
+| `dji-dgamut-lin` | DJI - D-Gamut - Linear | scene-linear |
+| `dji-dgamut-dlog` | DJI - D-Gamut - D-Log | log |
+| `fuji-fgamut-lin` | Fujifilm - F-Gamut - Linear | scene-linear |
+| `fuji-fgamut-flog` | Fujifilm - F-Gamut - F-Log | log |
+| `fuji-fgamut-flog2` | Fujifilm - F-Gamut - F-Log2 | log |
+| `fuji-fgamutc-lin` | Fujifilm - F-GamutC - Linear | scene-linear |
+| `fuji-fgamutc-flog2` | Fujifilm - F-GamutC - F-Log2 | log |
+| `cineon` | Kodak Cineon | log |
+| `gopro-rec709-protune` | GoPro - Rec.709 - Protune | log |
+| `leica-rec2020-lin` | Leica - Rec.2020 - Linear | scene-linear |
+| `leica-rec2020-llog` | Leica - Rec.2020 - L-Log | log |
+| `nikon-rec2020-lin` | Nikon - Rec.2020 - Linear | scene-linear |
+| `nikon-rec2020-nlog` | Nikon - Rec.2020 - N-Log | log |
+| `apple-rec2020-lin` | Apple - Rec.2020 - Linear | scene-linear |
+| `apple-rec2020-alog` | Apple - Rec.2020 - Apple-Log | log |
+| `samsung-rec2020-lin` | Samsung - Rec.2020 - Linear | scene-linear |
+| `samsung-rec2020-slog` | Samsung - Rec.2020 - Samsung-Log | log |
+| `xiaomi-rec2020-lin` | Xiaomi - Rec.2020 - Linear | scene-linear |
+| `xiaomi-rec2020-xlog` | Xiaomi - Rec.2020 - Xiaomi-Log | log |
+| `panasonic-vgamut-lin` | Panasonic - V-Gamut - Linear | scene-linear |
+| `panasonic-vgamut-vlog` | Panasonic - V-Gamut - V-Log | log |
+| `red-wg-lin` | Red - WideGamutRGB - Linear | scene-linear |
+| `red-wg-log3g10` | Red - WideGamutRGB - Log3G10 | log |
+| `sony-sgamut3-lin` | Sony - S-Gamut3 - Linear | scene-linear |
+| `sony-sgamut3-slog3` | Sony - S-Gamut3 - S-Log3 | log |
+| `sony-sgamut3cine-lin` | Sony - S-Gamut3.Cine - Linear | scene-linear |
+| `sony-sgamut3cine-slog3` | Sony - S-Gamut3.Cine - S-Log3 | log |
+| `sony-venice-sgamut3-lin` | Sony - Venice S-Gamut3 - Linear | scene-linear |
+| `sony-venice-sgamut3-slog3` | Sony - Venice S-Gamut3 - S-Log3 | log |
+| `sony-venice-sgamut3cine-lin` | Sony - Venice S-Gamut3.Cine - Linear | scene-linear |
+| `sony-venice-sgamut3cine-slog3` | Sony - Venice S-Gamut3.Cine - S-Log3 | log |
+| `rec709-lin` | Rec.709 - Linear | scene-linear |
+| `rec2020-lin` | Rec.2020 - Linear | scene-linear |
+| `p3d65-lin` | P3D65 - Linear | scene-linear |
+| `rec1886` | Rec.1886 | sdr-video |
+| `srgb-display` | sRGB Display | sdr-video |
+| `srgb-encoding` | sRGB Encoding | sdr-video |
+| `dci-p3d65` | DCIP3 D65 | sdr-video |
+| `display-p3` | Display P3 | sdr-video |
+| `rec2100-pq` | Rec2100 PQ | hdr-video |
+| `rec2100-hlg` | Rec2100 HLG | hdr-video |
+
+## How the curves are defined
+
+Most camera log curves are a `Log`: a natural log curve with an optional piecewise linear toe.
+
+```
+y = gain*ln(x + offset) + bias     x >  toe
+y = slope*(x - toe) + y0           x <= toe
+```
+
+The linear toe always meets the log segment at the same value (C0 continuity). Its slope
+is the one the whitepaper publishes, which is not always the slope of the log segment at
+the join.
+
+**Why the slope is kept.** Several curves are designed with a kink at the join: the linear
+segment is steeper than the log segment there (S-Log3 by 27%, F-Log 4.7%, F-Log2 3.7%,
+L-Log 1.3%, D-Log 1.2%). Forcing matching slopes (C1 continuity) would move every code
+value in the toe away from what the camera records. A kink does no harm: the curve still
+rises everywhere, so it decodes exactly. If you build a `Log` without a `slope`, it uses
+the slope of the log segment.
+
+**Why the join value is not kept.** Some whitepapers publish the linear segment's offset
+as a separate constant, and with the rounded published values the two segments do not quite
+meet: there is a small step at the join. With a step, decode cannot exactly undo encode
+near the join, because code values inside the step belong to neither segment. F-Log shows
+this in its own whitepaper: the linear segment ends at 0.100639, but its decode formula
+switches segments at 0.100538. mucolor derives the offset so the segments meet, and in
+the toe it differs from the whitepaper by the size of the step:
+
+| Curve | Step at the join |
+|---|---|
+| Leica L-Log | 9.0e-4 (about 0.9 of a 10-bit code value) |
+| Fujifilm F-Log | 1.0e-4 |
+| DJI D-Log | 2.0e-6 |
+| Panasonic V-Log | 3.1e-7 |
+| ARRI LogC3 | 2.5e-7 |
+| Fujifilm F-Log2 | 3.6e-8 |
+
+Above the join, every curve matches its whitepaper to floating point precision. Below it,
+the difference is a constant offset of exactly the step. `tests/test_external.py` lists the
+tolerance used for each curve.
+
+Each curve is built from the constants and formula of its whitepaper, so it can be
+checked against the source:
+
+```python
+# ARRI LogC3 EI800
+#   y = c*log10(a*x + b) + d     x >  cut
+#   y = e*x + f                  x <= cut
+cut, a, b, c, d, e, f = 0.010591, 5.555556, 0.052272, 0.247190, 0.385537, 5.367655, 0.092809
+arri_logc3 = Log.from_base(10, c, a, b, d, toe=cut, slope=e)
+```
+
+Display curves are a `Power` with the same optional toe. Curves that fit neither form are
+a `Curve` of two functions.
+
+## Tests
+
+```
+python -m unittest discover -s tests
+```
+
+`tests/test_external.py` compares every colorspace it can against
+[colour-science](https://www.colour-science.org) and the OCIO built-in ACES studio config.
+It is skipped unless those packages are installed (OCIO 2.6 or newer):
+
+```
+pip install colour-science opencolorio
+python -m unittest discover -s tests
+```

mucolor-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+mucolor.py,sha256=w65bHc4bgRD2dj0FPQVYDA2x9qWfQ7wYQG2eEmyG1ZY,35776
+mucolor-0.1.0.dist-info/METADATA,sha256=cL7mE0KDvEDIbNiuHCPxc_CXAc1QEWPkv4b5Nh-fC_A,12439
+mucolor-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+mucolor-0.1.0.dist-info/licenses/LICENSE,sha256=6pUWAfL3ibwwmlcv1c32hXOBjTkODpviMp6iFazgfQA,1066
+mucolor-0.1.0.dist-info/RECORD,,

mucolor-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mucolor-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jed Smith
+
+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.

mucolor.py

@@ -0,0 +1,819 @@
+''' mucolor - minimal pure-python colorimetry
+
+		import mucolor as mc
+		mc.convert((0.4, 0.4, 0.4), 'sony-sgamut3-slog3', 'rec709-lin')
+		f = mc.converter('arri-wg4-logc4', 'srgb-display')   # resolve once, call many times
+		mc.matrix('p3d65-lin', 'rec709-lin')                 # 3x3 tuple of tuples
+		mc.sony_slog3.decode(0.41)                           # transfer functions on their own
+
+	Conventions
+		encode: linear signal -> code value.  decode: code value -> linear signal.
+		Gamuts are flat xy chromaticity tuples: (rx, ry, gx, gy, bx, by, wx, wy).
+		Display linear 1.0 is 100 nits for every display transfer function.
+
+	numpy
+		Pass np=True to any encode, decode, converter or convert to process numpy arrays.
+		numpy is imported only then. RGB arrays have shape (..., 3) and results are float64.
+		Out of domain values give nan with a numpy warning where the scalar version raises.
+
+		f = mc.converter('arri-wg4-logc4', 'srgb-display', np=True)
+		f(lut_grid)                                          # array of shape (n, n, n, 3)
+'''
+import difflib
+import math
+from types import SimpleNamespace
+from typing import Callable, NamedTuple
+
+__version__ = '0.1.0'
+__license__ = 'MIT License'
+
+
+###################################################################################################
+# Scalar or numpy: each formula is written once against xp, which is numpy with np=True,
+# or this stdlib stand-in for the numpy functions the formulas use
+
+_math = SimpleNamespace(log=math.log, log2=math.log2, log10=math.log10, exp=math.exp, sqrt=math.sqrt,
+						copysign=math.copysign, maximum=max)
+_np = None
+
+def _array(x):
+	# x as a float64 numpy array, importing numpy on first use
+	global _np
+	if _np is None:
+		try:
+			import numpy
+		except ImportError:
+			raise ImportError('np=True requires numpy') from None
+		_np = numpy
+	return _np.asarray(x, dtype=float)
+
+def _xp(x, np):
+	# x and the namespace to compute it with
+	return (_array(x), _np) if np else (x, _math)
+
+def _split(rgb, np):
+	# RGB as three channels: scalars, or arrays of shape (...)
+	return (rgb[..., 0], rgb[..., 1], rgb[..., 2]) if np else tuple(rgb)
+
+def _join(channels, np):
+	return _np.stack(channels, axis=-1) if np else tuple(channels)
+
+def _select(x, *pieces):
+	''' if / elif / else on a scalar or a numpy array.
+			pieces are (condition, value) pairs then a final value. Each value is a constant or
+			a function, evaluated only where its condition is the first one true, so out of
+			domain branches never see the wrong values.
+	'''
+	if _np is None or not isinstance(x, _np.ndarray):
+		for p in pieces:
+			cond, value = p if type(p) is tuple else (True, p)
+			if cond:
+				return value(x) if callable(value) else value
+	out = _np.empty_like(x)
+	todo = _np.ones(x.shape, dtype=bool)
+	for cond, value in [p if isinstance(p, tuple) else (True, p) for p in pieces]:
+		m = todo & cond
+		out[m] = value(x[m]) if callable(value) else value
+		todo &= ~m
+	return out
+
+
+###################################################################################################
+# Matrix helpers: 3x3 matrices are tuples of row tuples
+
+_IDENTITY = ((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0))
+
+def _matmul(m0, m1):
+	return tuple(tuple(sum(a*b for a, b in zip(r, c)) for c in zip(*m1)) for r in m0)
+
+def _dot(m, v):
+	return tuple(sum(a*b for a, b in zip(r, v)) for r in m)
+
+def _diag(v):
+	return ((v[0], 0.0, 0.0), (0.0, v[1], 0.0), (0.0, 0.0, v[2]))
+
+def _inv(m):
+	(a, b, c), (d, e, f), (g, h, i) = m
+	det = a*(e*i - f*h) - b*(d*i - f*g) + c*(d*h - e*g)
+	if det == 0.0:
+		raise ValueError(f'matrix is not invertible: {m}')
+	return (
+		((e*i - f*h)/det, (c*h - b*i)/det, (b*f - c*e)/det),
+		((f*g - d*i)/det, (a*i - c*g)/det, (c*d - a*f)/det),
+		((d*h - e*g)/det, (b*g - a*h)/det, (a*e - b*d)/det))
+
+def _is_identity(m, tol=1e-12):
+	return all(abs(a - b) <= tol for r0, r1 in zip(m, _IDENTITY) for a, b in zip(r0, r1))
+
+
+###################################################################################################
+# Colorimetry
+
+def xy_to_XYZ(xy):
+	# xy chromaticity to XYZ tristimulus with Y=1
+	x, y = xy
+	return (x/y, 1.0, (1.0 - x - y)/y)
+
+def npm(gamut):
+	''' Normalized Primaries Matrix: RGB in gamut -> CIE XYZ
+			Primaries (1,0) (0,1) (0,0) denote CIE XYZ itself, which returns identity.
+			SMPTE RP 177 - Derivation of Basic Television Color Equations
+			http://doi.org/10.5594/S9781614821915
+	'''
+	rx, ry, gx, gy, bx, by, wx, wy = gamut
+	if (rx, ry, gx, gy, bx, by) == (1, 0, 0, 1, 0, 0):
+		return _IDENTITY
+	P = ((rx, gx, bx), (ry, gy, by), (1.0 - rx - ry, 1.0 - gx - gy, 1.0 - bx - by))
+	C = _dot(_inv(P), xy_to_XYZ((wx, wy)))
+	return _matmul(P, _diag(C))
+
+_CAT = {
+	'bradford': ((0.8951, 0.2664, -0.1614), (-0.7502, 1.7135, 0.0367), (0.0389, -0.0685, 1.0296)),
+	'cat02': ((0.7328, 0.4296, -0.1624), (-0.7036, 1.6975, 0.0061), (0.003, 0.0136, 0.9834)),
+}
+
+def cat(src_white, dst_white, method='cat02'):
+	''' von Kries chromatic adaptation matrix (XYZ -> XYZ) between two xy whitepoints
+			method is 'cat02', 'bradford', or None for no adaptation.
+			Mark D. Fairchild - Color Appearance Models Third Edition p. 181-186
+			Bruce Lindbloom - http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html
+	'''
+	if method is None or tuple(src_white) == tuple(dst_white):
+		return _IDENTITY
+	try:
+		m = _CAT[method]
+	except KeyError:
+		raise ValueError(f'unknown cat method {method!r}, use one of {sorted(_CAT)} or None') from None
+	s = _dot(m, xy_to_XYZ(src_white))
+	d = _dot(m, xy_to_XYZ(dst_white))
+	return _matmul(_matmul(_inv(m), _diag([b/a for a, b in zip(s, d)])), m)
+
+_cat = cat  # matrix() has a parameter named cat
+
+def matrix(src, dst, cat='cat02'):
+	''' 3x3 matrix converting linear RGB in src to linear RGB in dst, with chromatic adaptation
+			src and dst are colorspaces, colorspace names, or gamut tuples.
+	'''
+	src, dst = _gamut(src), _gamut(dst)
+	return _matmul(_inv(npm(dst)), _matmul(_cat(src[6:], dst[6:], cat), npm(src)))
+
+def _gamut(x):
+	if isinstance(x, (tuple, list)) and len(x) == 8:
+		return tuple(x)
+	cs = get(x)
+	if cs.gamut is None:
+		raise ValueError(f'{cs.name!r} has no gamut')
+	return cs.gamut
+
+
+###################################################################################################
+# Transfer function types
+
+class Log(NamedTuple):
+	''' Log curve in natural log form, with an optional piecewise linear extension toe.
+			encode (linear -> log):
+				y = gain*ln(x + offset) + bias     x >  toe
+				y = slope*(x - toe) + y0           x <= toe,  y0 = gain*ln(toe + offset) + bias
+			slope defaults to the slope of the log segment at toe.
+			toe=None means a pure log curve, defined only for x > -offset.
+	'''
+	gain: float
+	offset: float
+	bias: float
+	toe: float = None
+	slope: float = None
+
+	@classmethod
+	def from_base(cls, base, gain, scale, offset, bias, toe=None, slope=None):
+		''' Build from the form most whitepapers use: y = gain*log_base(scale*x + offset) + bias '''
+		g = gain/math.log(base)
+		return cls(g, offset/scale, bias + g*math.log(scale), toe, slope)
+
+	def _toe(self):
+		slope = self.gain/(self.toe + self.offset) if self.slope is None else self.slope
+		return slope, self.gain*math.log(self.toe + self.offset) + self.bias
+
+	def encode(self, x, np=False):
+		x, xp = _xp(x, np)
+		log = lambda x: self.gain*xp.log(x + self.offset) + self.bias
+		if self.toe is None:
+			return log(x)
+		slope, y0 = self._toe()
+		return _select(x, (x <= self.toe, lambda x: slope*(x - self.toe) + y0), log)
+
+	def decode(self, y, np=False):
+		y, xp = _xp(y, np)
+		exp = lambda y: xp.exp((y - self.bias)/self.gain) - self.offset
+		if self.toe is None:
+			return exp(y)
+		slope, y0 = self._toe()
+		return _select(y, (y <= y0, lambda y: (y - y0)/slope + self.toe), exp)
+
+
+class Power(NamedTuple):
+	''' Power curve with an optional piecewise linear extension toe.
+			decode (code -> linear):  x = ((y + offset)/(1 + offset))**p
+			encode (linear -> code):
+				y = (1 + offset)*x**(1/p) - offset     x >  toe
+				y = slope*(x - toe) + y0               x <= toe,  y0 = the power segment at toe
+			slope defaults to the slope of the power segment at toe.
+			Without a toe, negative values clamp to 0.
+	'''
+	p: float
+	offset: float = 0.0
+	toe: float = None
+	slope: float = None
+
+	def _pow(self, x):
+		return (1.0 + self.offset)*x**(1.0/self.p) - self.offset
+
+	def _inv_pow(self, y):
+		return ((y + self.offset)/(1.0 + self.offset))**self.p
+
+	def _toe(self):
+		slope = (1.0 + self.offset)/self.p*self.toe**(1.0/self.p - 1.0) if self.slope is None else self.slope
+		return slope, self._pow(self.toe)
+
+	def encode(self, x, np=False):
+		x, _ = _xp(x, np)
+		if self.toe is None:
+			return _select(x, (x > 0.0, self._pow), 0.0)
+		slope, y0 = self._toe()
+		return _select(x, (x <= self.toe, lambda x: slope*(x - self.toe) + y0), (x > 0.0, self._pow), 0.0)
+
+	def decode(self, y, np=False):
+		y, _ = _xp(y, np)
+		if self.toe is None:
+			return _select(y, (y > 0.0, self._inv_pow), 0.0)
+		slope, y0 = self._toe()
+		return _select(y, (y <= y0, lambda y: (y - y0)/slope + self.toe), (y > 0.0, self._inv_pow), 0.0)
+
+
+class Curve(NamedTuple):
+	''' A transfer function that fits no parametric form: a pair of functions f(x, xp).
+			xp is numpy with np=True, or a stdlib stand-in with the same names, so each
+			formula is written once. Branch with _select rather than if / else.
+	'''
+	encode_fn: Callable
+	decode_fn: Callable
+
+	def encode(self, x, np=False):
+		return self.encode_fn(*_xp(x, np))
+
+	def decode(self, y, np=False):
+		return self.decode_fn(*_xp(y, np))
+
+
+class HLG(NamedTuple):
+	''' ITU-R BT.2100 Hybrid Log-Gamma, display referred: inverse OETF then OOTF.
+			Works on RGB triplets because the OOTF depends on luminance.
+			peak is the nominal display peak in nits. Negative values clamp to 0.
+			https://www.itu.int/rec/R-REC-BT.2100
+	'''
+	peak: float = 1000.0
+	rgb = True  # class attribute, not a field
+
+	_a = 0.17883277
+	_b = 1.0 - 4.0*0.17883277
+	_c = 0.5 - 0.17883277*math.log(4.0*0.17883277)
+
+	def _gamma(self):
+		return 1.2 + 0.42*math.log10(self.peak/1000.0)
+
+	def encode(self, rgb, np=False):
+		rgb, xp = _xp(rgb, np)
+		F = [xp.maximum(v, 0.0)*100.0/self.peak for v in _split(rgb, np)]
+		Yd = 0.2627*F[0] + 0.6780*F[1] + 0.0593*F[2]
+		g = self._gamma()
+		s = _select(Yd, (Yd > 0.0, lambda Y: Y**((1.0 - g)/g)), 0.0)
+		return _join([_select(e, (e <= 1.0/12.0, lambda e: xp.sqrt(3.0*e)), lambda e: self._a*xp.log(12.0*e - self._b) + self._c)
+					  for e in (f*s for f in F)], np)
+
+	def decode(self, rgb, np=False):
+		rgb, xp = _xp(rgb, np)
+		E = [_select(e, (e <= 0.5, lambda e: e*e/3.0), lambda e: (xp.exp((e - self._c)/self._a) + self._b)/12.0)
+			 for e in (xp.maximum(v, 0.0) for v in _split(rgb, np))]
+		Ys = 0.2627*E[0] + 0.6780*E[1] + 0.0593*E[2]
+		s = _select(Ys, (Ys > 0.0, lambda Y: self.peak/100.0*Y**(self._gamma() - 1.0)), 0.0)
+		return _join([e*s for e in E], np)
+
+
+###################################################################################################
+# Camera log transfer functions
+
+# ACEScct - S-2016-001 http://j.mp/S-2016-001_
+#   y = (log2(x) + 9.72)/17.52     x >  0.0078125
+#   y = A*x + B                    x <= 0.0078125
+acescct = Log.from_base(2, 1/17.52, 1.0, 0.0, 9.72/17.52, toe=0.0078125, slope=10.5402377416545)
+
+# JPLog2 - https://community.acescentral.com/t/aceslog-strawman-proposal/5270
+#   y = (log2(x) + 10.5)/20.46     x >  0.006801176276
+#   y = ln_s*x + ln_o              x <= 0.006801176276
+jplog2 = Log.from_base(2, 1/20.46, 1.0, 0.0, 10.5/20.46, toe=0.006801176276, slope=10.36773919972907075549)
+
+def _filmlight_tlog(w=128.0, g=16.0, o=0.075):
+	# FilmLight T-Log - Baselight /etc/colourspaces/FilmLight_TLog_EGamut.flspace
+	#   y = A + B*ln(x + C)     x >= 0
+	#   y = G*x + o             x <  0
+	b = 1.0/(0.7107 + 1.2359*math.log(w*g))
+	gs = g/(1.0 - o)
+	C = b/gs
+	a = 1.0 - b*math.log(w + C)
+	y0 = a + b*math.log(C)
+	s = (1.0 - o)/(1.0 - y0)
+	A = 1.0 + (a - 1.0)*s
+	B = b*s
+	return Log(gain=B, offset=C, bias=A, toe=0.0)  # G = gs*s is the log slope at 0
+
+filmlight_tlog = _filmlight_tlog()
+filmlight_tloge = _filmlight_tlog(w=512.0)  # extended scene-linear range for 3D LUT shapers
+
+def _davinci_intermediate():
+	# DaVinci Intermediate
+	# https://documents.blackmagicdesign.com/InformationNotes/DaVinci_Resolve_17_Wide_Gamut_Intermediate.pdf
+	#   y = (log2(x + A) + B)*C     x >  LIN_CUT
+	#   y = x*M                     x <= LIN_CUT
+	A, B, C, M, LIN_CUT = 0.0075, 7.0, 0.07329248, 10.44426855, 0.00262409
+	return Log.from_base(2, C, 1.0, A, B*C, toe=LIN_CUT, slope=M)
+
+davinci_intermediate = _davinci_intermediate()
+
+def _arri_logc3():
+	# ARRI LogC3 EI800
+	# https://www.arri.com/resource/blob/31918/66f56e6abb6e5b6553929edf9aa7483e/2017-03-alexa-logc-curve-in-vfx-data.pdf
+	#   y = c*log10(a*x + b) + d     x >  cut
+	#   y = e*x + f                  x <= cut
+	cut, a, b, c, d, e, f = 0.010591, 5.555556, 0.052272, 0.247190, 0.385537, 5.367655, 0.092809
+	return Log.from_base(10, c, a, b, d, toe=cut, slope=e)
+
+arri_logc3 = _arri_logc3()
+
+def _arri_logc4():
+	# ARRI LogC4
+	# https://www.arri.com/resource/blob/278790/bea879ac0d041a925bed27a096ab3ec2/2022-05-arri-logc4-specification-data.pdf
+	#   y = (log2(a*x + 64) - 6)/14*b + c     x >= t
+	#   y = (x - t)/s                         x <  t
+	a = (2.0**18.0 - 16.0)/117.45
+	b = (1023.0 - 95.0)/1023.0
+	c = 95.0/1023.0
+	s = (7.0*math.log(2.0)*2.0**(7.0 - 14.0*c/b))/(a*b)
+	t = (2.0**(14.0*(-c/b) + 6.0) - 64.0)/a
+	return Log.from_base(2, b/14.0, a, 64.0, c - 6.0*b/14.0, toe=t, slope=1.0/s)
+
+arri_logc4 = _arri_logc4()
+
+def _blackmagic_film_gen5():
+	# Blackmagic Film Generation 5
+	# Blackmagic RAW SDK: Blackmagic Generation 5 Color Science Technical Reference.pdf
+	#   y = A*ln(x + B) + C     x >= LIN_CUT
+	#   y = D*x + E             x <  LIN_CUT
+	A, B, C, D = 0.08692876065491224, 0.005494072432257808, 0.5300133392291939, 8.283605932402494
+	LIN_CUT = 0.005
+	return Log(gain=A, offset=B, bias=C, toe=LIN_CUT, slope=D)
+
+blackmagic_film_gen5 = _blackmagic_film_gen5()
+
+# DJI D-Log - https://dl.djicdn.com/downloads/zenmuse+x7/20171010/D-Log_D-Gamut_Whitepaper.pdf
+#   y = log10(x*0.9892 + 0.0108)*0.256663 + 0.584555     x >  0.0078
+#   y = 6.025*x + 0.0929                                 x <= 0.0078
+dji_dlog = Log.from_base(10, 0.256663, 0.9892, 0.0108, 0.584555, toe=0.0078, slope=6.025)
+
+def _fujifilm_flog(a, b, c, d, e, cut1):
+	# Fujifilm F-Log / F-Log2
+	#   y = c*log10(a*x + b) + d     x >= cut1
+	#   y = e*x + f                  x <  cut1
+	return Log.from_base(10, c, a, b, d, toe=cut1, slope=e)
+
+# https://dl.fujifilm-x.com/support/lut/F-Log_DataSheet_E_Ver.1.0.pdf
+fujifilm_flog = _fujifilm_flog(a=0.555556, b=0.009468, c=0.344676, d=0.790453, e=8.735631, cut1=0.00089)
+# https://dl.fujifilm-x.com/support/lut/F-Log2_DataSheet_E_Ver.1.0.pdf
+fujifilm_flog2 = _fujifilm_flog(a=5.555556, b=0.064829, c=0.245281, d=0.384316, e=8.799461, cut1=0.000889)
+
+def _leica_llog():
+	# Leica L-Log - https://leica-camera.com/sites/default/files/pm-65977-210914__L-Log_Reference_Manual_EN.pdf
+	#   y = c*log10(d*x + e) + f     x >= c0
+	#   y = a*x + b                  x <  c0
+	a, b, c, d, e, f, c0 = 8.0, 0.09, 0.27, 1.3, 0.0115, 0.6, 0.006
+	return Log.from_base(10, c, d, e, f, toe=c0, slope=a)
+
+leica_llog = _leica_llog()
+
+def _panasonic_vlog():
+	# Panasonic V-Log - https://pro-av.panasonic.net/en/cinema_camera_varicam_eva/support/pdf/VARICAM_V-Log_V-Gamut.pdf
+	#   y = c*log10(x + b) + d     x >= cut1
+	#   y = 5.6*x + 0.125          x <  cut1
+	cut1, b, c, d = 0.01, 0.00873, 0.241514, 0.598206
+	return Log.from_base(10, c, 1.0, b, d, toe=cut1, slope=5.6)
+
+panasonic_vlog = _panasonic_vlog()
+
+def _red_log3g10():
+	# RED Log3G10
+	# https://docs.red.com/955-0187/PDF/915-0187%20Rev-C%20%20%20RED%20OPS,%20White%20Paper%20on%20REDWideGamutRGB%20and%20Log3G10.pdf
+	#   y = a*log10((x + c)*b + 1)     x >= -c
+	#   y = (x + c)*g                  x <  -c
+	a, b, c, g = 0.224282, 155.975327, 0.01, 15.1927
+	return Log.from_base(10, a, b, c*b + 1.0, 0.0, toe=-c, slope=g)
+
+red_log3g10 = _red_log3g10()
+
+def _sony_slog2():
+	# Sony S-Log2 - S-Log2_Technical_PaperV1_0.pdf
+	#   x' = x/0.9
+	#   y' = c0*log10(c1*x'/c2 + c3) + c4 + c5     x' >= 0
+	#   y' = x'*c6 + c7                            x' <  0
+	#   y  = y'*876/1023 + 64/1023
+	c0, c1, c2, c3, c4, c5, c6 = 0.432699, 155.0, 219.0, 0.037584, 0.616596, 0.03, 3.53881278538813
+	return Log.from_base(10, c0*876/1023, c1/(c2*0.9), c3, (c4 + c5)*876/1023 + 64/1023,
+						 toe=0.0, slope=c6/0.9*876/1023)
+
+sony_slog2 = _sony_slog2()
+
+def _sony_slog3():
+	# Sony S-Log3 - https://pro.sony/s3/cms-static-content/uploadfile/06/1237494271406.pdf
+	#   y = (420 + log10((x + 0.01)/(0.18 + 0.01))*261.5)/1023     x >= 0.01125
+	#   y = (x*(171.2102946929 - 95)/0.01125 + 95)/1023            x <  0.01125
+	return Log.from_base(10, 261.5/1023, 1/(0.18 + 0.01), 0.01/(0.18 + 0.01), 420/1023,
+						 toe=0.01125, slope=(171.2102946929 - 95)/0.01125/1023)
+
+sony_slog3 = _sony_slog3()
+
+def _kodak_cineon():
+	# Kodak Cineon - https://github.com/imageworks/OpenColorIO-Configs/blob/master/nuke-default/make.py
+	#   y = (a + b*log10(x*(1 - off) + off))/1023,  off = 10**((c - a)/b)
+	a, b, c = 685.0, 300.0, 95.0
+	off = 10.0**((c - a)/b)
+	return Log.from_base(10, b/1023, 1.0 - off, off, a/1023)
+
+kodak_cineon = _kodak_cineon()
+
+# GoPro Protune - https://github.com/hpd/OpenColorIO-Configs/blob/master/aces_1.0.3/python/aces_ocio/colorspaces/gopro.py
+#   y = ln(x*112 + 1)/ln(113)
+gopro_protune = Log.from_base(113, 1.0, 112.0, 1.0, 0.0)
+
+
+# Curves below fit no parametric form
+
+def _acescc_encode(x, xp):
+	A, B = 9.72, 17.52
+	return _select(x,
+		(x <= 0.0, (-16.0 + A)/B),
+		(x < 2.0**-15, lambda x: (xp.log2(2.0**-16 + x/2.0) + A)/B),
+		lambda x: (xp.log2(x) + A)/B)
+
+def _acescc_decode(y, xp):
+	A, B = 9.72, 17.52
+	return _select(y,
+		(y <= (A - 15.0)/B, lambda y: (2.0**(y*B - A) - 2.0**-16)*2.0),
+		(y < (math.log2(65504.0) + A)/B, lambda y: 2.0**(y*B - A)),
+		65504.0)
+
+acescc = Curve(_acescc_encode, _acescc_decode)
+
+# Canon Log - https://downloads.canon.com/nw/learn/white-papers/cinema-eos/white-paper-canon-log-gamma-curves.pdf
+# The /0.9 on scene-linear matches Canon's CTL IDTs ("Input Transform Version 202007 for EOS C500 Mark II").
+# The negative side is a mirrored log rather than a straight line.
+
+def _canon_clog2_encode(x, xp):
+	c0, c1, c2 = 0.092864125, 0.24136077, 87.099375
+	x = x/0.9
+	return _select(x, (x < 0.0, lambda x: -c1*xp.log10(1.0 - c2*x) + c0), lambda x: c1*xp.log10(c2*x + 1.0) + c0)
+
+def _canon_clog2_decode(y, xp):
+	c0, c1, c2 = 0.092864125, 0.24136077, 87.099375
+	x = _select(y, (y < c0, lambda y: -(10.0**((c0 - y)/c1) - 1.0)/c2), lambda y: (10.0**((y - c0)/c1) - 1.0)/c2)
+	return x*0.9
+
+canon_clog2 = Curve(_canon_clog2_encode, _canon_clog2_decode)
+
+_CLOG3 = (0.014, 0.09746547, 0.15277891, 0.36726845, 14.98325, 0.12783901, 1.9754798, 0.12512219, 0.12240537)
+
+def _canon_clog3_encode(x, xp):
+	sp0, sp1, sp2, c0, c1, c2, c3, c4, c5 = _CLOG3
+	x = x/0.9
+	return _select(x,
+		(x < -sp0, lambda x: -c0*xp.log10(1.0 - c1*x) + c2),
+		(x <= sp0, lambda x: c3*x + c4),
+		lambda x: c0*xp.log10(c1*x + 1.0) + c5)
+
+def _canon_clog3_decode(y, xp):
+	sp0, sp1, sp2, c0, c1, c2, c3, c4, c5 = _CLOG3
+	x = _select(y,
+		(y < sp1, lambda y: -(10.0**((c2 - y)/c0) - 1.0)/c1),
+		(y <= sp2, lambda y: (y - c4)/c3),
+		lambda y: (10.0**((y - c5)/c0) - 1.0)/c1)
+	return x*0.9
+
+canon_clog3 = Curve(_canon_clog3_encode, _canon_clog3_decode)
+
+# Nikon N-Log - http://download.nikonimglib.com/archive3/hDCmK00m9JDI03RPruD74xpoU905/N-Log_Specification_(En)01.pdf
+#   y = b*ln(x) + a              x >= 0.328
+#   y = c*(x + 0.0075)**(1/3)    x <  0.328
+
+def _nikon_nlog_encode(x, xp):
+	a, b, c, d = 619.0/1023.0, 150.0/1023.0, 650.0/1023.0, 0.0075
+	return _select(x, (x >= 0.328, lambda x: b*xp.log(x) + a), lambda x: c*xp.copysign(abs(x + d)**(1.0/3.0), x + d))
+
+def _nikon_nlog_decode(y, xp):
+	a, b, c, d = 619.0/1023.0, 150.0/1023.0, 650.0/1023.0, 0.0075
+	return _select(y, (y >= 452.0/1023.0, lambda y: xp.exp((y - a)/b)), lambda y: (y/c)**3 - d)
+
+nikon_nlog = Curve(_nikon_nlog_encode, _nikon_nlog_decode)
+
+# Apple Log - Apple_Log_Profile_White_Paper.pdf (Apple Developer)
+#   y = g*log2(x + b) + d     x >= R_t
+#   y = c*(x - R_0)**2        R_0 <= x < R_t
+#   y = 0                     x < R_0
+_APPLE = (-0.05641088, 0.01, 47.28711236, 0.00964052, 0.08550479, 0.69336945)  # R_0, R_t, c, b, g, d
+
+def _apple_log_encode(x, xp):
+	R_0, R_t, c, b, g, d = _APPLE
+	return _select(x, (x >= R_t, lambda x: g*xp.log2(x + b) + d), (x >= R_0, lambda x: c*(x - R_0)**2), 0.0)
+
+def _apple_log_decode(y, xp):
+	R_0, R_t, c, b, g, d = _APPLE
+	return _select(y,
+		(y >= c*(R_t - R_0)**2, lambda y: 2.0**((y - d)/g) - b),
+		(y >= 0.0, lambda y: xp.sqrt(y/c) + R_0),
+		R_0)
+
+apple_log = Curve(_apple_log_encode, _apple_log_decode)
+
+# Samsung Log - Samsung Log White Paper 2025, https://developer.samsung.com/mobile/samsung-log-video.html
+#   y = a1*log10(x + b1) + y1     x >= xt
+#   y = a2*log10(b2 - x) + y2     x0 <= x < xt
+#   y = 0                         x < x0
+_SAMSUNG = (-0.05, 0.01, 0.258984868, 0.0003645, 0.720504856, -0.20942, 0.016904, -0.24597, 0.206561909)
+# x0, xt, a1, b1, y1, a2, b2, y2, yt
+
+def _samsung_log_encode(x, xp):
+	x0, xt, a1, b1, y1, a2, b2, y2, yt = _SAMSUNG
+	return _select(x,
+		(x < x0, 0.0),
+		(x < xt, lambda x: a2*xp.log10(b2 - x) + y2),
+		lambda x: a1*xp.log10(x + b1) + y1)
+
+def _samsung_log_decode(y, xp):
+	x0, xt, a1, b1, y1, a2, b2, y2, yt = _SAMSUNG
+	return _select(y,
+		(y < 0.0, x0),
+		(y < yt, lambda y: -10.0**((y - y2)/a2) + b2),
+		lambda y: 10.0**((y - y1)/a1) - b1)
+
+samsung_log = Curve(_samsung_log_encode, _samsung_log_decode)
+
+# Xiaomi Log - Xiaomi Log Profile White Paper, December 2024, https://www.mi.com/global/product/aces/
+#   y = a*log2(x + b) + g     x >= xt
+#   y = c*(x - x0)**2         x0 <= x < xt
+#   y = 0                     x < x0
+_XIAOMI = (-0.09023729, 0.01974185, 0.09271529, 0.01384578, 0.67291850, 18.10531998)  # x0, xt, a, b, g, c
+
+def _xiaomi_log_encode(x, xp):
+	x0, xt, a, b, g, c = _XIAOMI
+	return _select(x, (x < x0, 0.0), (x < xt, lambda x: c*(x - x0)**2), lambda x: a*xp.log2(x + b) + g)
+
+def _xiaomi_log_decode(y, xp):
+	x0, xt, a, b, g, c = _XIAOMI
+	return _select(y,
+		(y < 0.0, x0),
+		(y < c*(xt - x0)**2, lambda y: xp.sqrt(y/c) + x0),
+		lambda y: 2.0**((y - g)/a) - b)
+
+xiaomi_log = Curve(_xiaomi_log_encode, _xiaomi_log_decode)
+
+
+###################################################################################################
+# Display transfer functions
+
+gamma22 = Power(2.2)  # sRGB display, Display P3
+gamma24 = Power(2.4)  # ITU-R BT.1886
+gamma26 = Power(2.6)  # DCI theatrical projection
+
+# IEC 61966-2-1 sRGB piecewise encoding. The correct EOTF for an sRGB display is gamma22.
+srgb_piecewise = Power(2.4, offset=0.055, toe=0.04045/12.92, slope=12.92)
+
+# ITU-R BT.709 camera OETF, using the precise continuous constants from ITU-R BT.2020
+#   y = alpha*x**0.45 - (alpha - 1)     x >= beta
+#   y = 4.5*x                           x <  beta
+rec709_oetf = Power(1/0.45, offset=1.09929682680944 - 1.0, toe=0.018053968510807, slope=4.5)
+
+# SMPTE ST 2084 PQ - https://www.itu.int/rec/R-REC-BT.2100
+_PQ = (2610.0/16384.0, 2523.0/32.0, 107.0/128.0, 2413.0/128.0, 2392.0/128.0)  # m1, m2, c1, c2, c3
+
+def _pq_encode(x, xp):
+	m1, m2, c1, c2, c3 = _PQ
+	def pq(x):
+		x = (x/100.0)**m1
+		return ((c1 + c2*x)/(1.0 + c3*x))**m2
+	return _select(x, (x <= 0.0, 0.0), pq)
+
+def _pq_decode(y, xp):
+	m1, m2, c1, c2, c3 = _PQ
+	def pq(y):
+		y = y**(1.0/m2)
+		return (xp.maximum(y - c1, 0.0)/(c2 - c3*y))**(1.0/m1)*100.0
+	return _select(y, (y <= 0.0, 0.0), pq)
+
+pq = Curve(_pq_encode, _pq_decode)
+
+hlg = HLG(1000.0)
+
+
+###################################################################################################
+# Colorspaces
+
+class Colorspace(NamedTuple):
+	name: str
+	shortname: str
+	alias: str
+	encoding: str  # 'scene-linear', 'log', 'sdr-video' or 'hdr-video'
+	gamut: tuple
+	tf: object = None  # None means linear
+
+	def decode(self, rgb, np=False):
+		''' code values -> linear RGB '''
+		if self.tf is None:
+			return _array(rgb).copy() if np else tuple(rgb)
+		if np or getattr(self.tf, 'rgb', False):
+			return self.tf.decode(rgb, np=np)  # elementwise on the whole array, or an RGB transfer function
+		return tuple(self.tf.decode(v) for v in rgb)
+
+	def encode(self, rgb, np=False):
+		''' linear RGB -> code values '''
+		if self.tf is None:
+			return _array(rgb).copy() if np else tuple(rgb)
+		if np or getattr(self.tf, 'rgb', False):
+			return self.tf.encode(rgb, np=np)  # elementwise on the whole array, or an RGB transfer function
+		return tuple(self.tf.encode(v) for v in rgb)
+
+
+# Whitepoints
+d65 = (0.3127, 0.329)
+aces_white = (0.32168, 0.33767)
+
+# Gamuts
+xyz_d65 = (1, 0, 0, 1, 0, 0) + d65
+xyz_e = (1, 0, 0, 1, 0, 0, 1/3, 1/3)
+# TB-2014-004 http://j.mp/TB-2014-004
+aces_ap0 = (0.7347, 0.2653, 0.0, 1.0, 0.0001, -0.077) + aces_white
+# S-2014-004 http://j.mp/S-2014-004
+aces_ap1 = (0.713, 0.293, 0.165, 0.83, 0.128, 0.044) + aces_white
+rec709 = (0.64, 0.33, 0.3, 0.6, 0.15, 0.06) + d65
+rec2020 = (0.708, 0.292, 0.17, 0.797, 0.131, 0.046) + d65
+p3d65 = (0.68, 0.32, 0.265, 0.69, 0.15, 0.06) + d65
+# Baselight /etc/colourspaces/FilmLight_Linear_EGamut.flspace
+filmlight_egamut = (0.8, 0.3177, 0.18, 0.9, 0.065, -0.0805) + d65
+# Baselight /etc/colourspaces/FilmLight_Linear_EGamut2.flspace
+filmlight_egamut2 = (0.83, 0.31, 0.15, 0.95, 0.065, -0.0805) + d65
+# https://documents.blackmagicdesign.com/InformationNotes/DaVinci_Resolve_17_Wide_Gamut_Intermediate.pdf
+davinci_wide_gamut = (0.8, 0.313, 0.1682, 0.9877, 0.079, -0.1155) + d65
+# https://www.arri.com/resource/blob/31918/66f56e6abb6e5b6553929edf9aa7483e/2017-03-alexa-logc-curve-in-vfx-data.pdf
+arri_wide_gamut3 = (0.684, 0.313, 0.221, 0.848, 0.0861, -0.102) + d65
+# https://www.arri.com/resource/blob/278790/bea879ac0d041a925bed27a096ab3ec2/2022-05-arri-logc4-specification-data.pdf
+arri_wide_gamut4 = (0.7347, 0.2653, 0.1424, 0.8576, 0.0991, -0.0308) + d65
+# Blackmagic RAW SDK: Blackmagic Generation 5 Color Science Technical Reference.pdf
+# The whitepoint is specified as (0.3127170, 0.3290312), not exactly D65.
+blackmagic_wide_gamut = (0.7177215, 0.3171181, 0.228041, 0.861569, 0.1005841, -0.0820452, 0.3127170, 0.3290312)
+# Canon Cinema Gamut, D55 daylight IDT (not tungsten)
+# Input Transform Version 202007 for EOS C300 Mark III - canon-eos-c300mk3-idt-202007.zip
+canon_cinema_gamut = (0.74, 0.27, 0.17, 1.14, 0.08, -0.1) + d65
+# https://dl.djicdn.com/downloads/zenmuse+x7/20171010/D-Log_D-Gamut_Whitepaper.pdf
+dji_dgamut = (0.71, 0.31, 0.21, 0.88, 0.09, -0.08) + d65
+# F-Gamut is Rec.2020 - https://dl.fujifilm-x.com/support/lut/F-Log_DataSheet_E_Ver.1.0.pdf
+fujifilm_fgamut = rec2020
+# https://dl.fujifilm-x.com/support/lut/F-Log2C_DataSheet_E_Ver.1.0.pdf
+fujifilm_fgamut_c = (0.7347, 0.2653, 0.0263, 0.9737, 0.1173, -0.0224) + d65
+# https://pro-av.panasonic.net/en/cinema_camera_varicam_eva/support/pdf/VARICAM_V-Log_V-Gamut.pdf
+panasonic_vgamut = (0.73, 0.28, 0.165, 0.84, 0.1, -0.03) + d65
+# https://docs.red.com/955-0187/PDF/915-0187%20Rev-C%20%20%20RED%20OPS,%20White%20Paper%20on%20REDWideGamutRGB%20and%20Log3G10.pdf
+red_wide_gamut = (0.780308, 0.304253, 0.121595, 1.493994, 0.095612, -0.084589) + d65
+# S-Gamut and S-Gamut3 share primaries - https://pro.sony/ue_US/support/article/CA000001
+sony_sgamut3 = (0.73, 0.28, 0.14, 0.855, 0.1, -0.05) + d65
+sony_sgamut3_cine = (0.766, 0.275, 0.225, 0.8, 0.089, -0.087) + d65
+# Venice gamuts: chromaticities calculated from the AP0 matrices in the Sony Venice IDTs
+# https://github.com/ampas/aces-core/blob/710ecbe52c87ce9f4a1e02c8ddf7ea0d6b611cc8/transforms/ctl/idt/vendorSupplied/sony/IDT.Sony.Venice_SLog3_SGamut3.ctl
+sony_venice_sgamut3 = (0.740464264304292, 0.27936437475066, 0.089241145423286, 0.893809528608105,
+					   0.110488236673827, -0.052579333080476) + d65
+# https://github.com/ampas/aces-core/blob/710ecbe52c87ce9f4a1e02c8ddf7ea0d6b611cc8/transforms/ctl/idt/vendorSupplied/sony/IDT.Sony.Venice_SLog3_SGamut3Cine.ctl
+sony_venice_sgamut3_cine = (0.775901871567345, 0.274502392854799, 0.188682902773355, 0.828684937020288,
+							0.101337382499301, -0.089187517306263) + d65
+
+_C = Colorspace
+_COLORSPACES = (
+	_C('XYZ D65', 'xyz-d65', 'xyzd65', 'scene-linear', xyz_d65),
+	_C('XYZ E', 'xyz-e', 'xyze', 'scene-linear', xyz_e),
+	_C('ACES 2065-1', 'aces', 'ap0', 'scene-linear', aces_ap0),
+	_C('ACEScg', 'acescg', 'ap1', 'scene-linear', aces_ap1),
+	_C('ACEScct', 'acescct', 'acescct', 'log', aces_ap1, acescct),
+	_C('JPLog2', 'jplog2', 'jplg2', 'log', aces_ap1, jplog2),
+	_C('Filmlight - E-Gamut - Linear', 'filmlight-egamut-lin', 'fegln', 'scene-linear', filmlight_egamut),
+	_C('Filmlight - E-Gamut - T-Log', 'filmlight-egamut-tlog', 'feglg', 'log', filmlight_egamut, filmlight_tlog),
+	_C('Filmlight - E-Gamut2 - Linear', 'filmlight-egamut2-lin', 'feg2ln', 'scene-linear', filmlight_egamut2),
+	_C('Filmlight - E-Gamut2 - T-Log', 'filmlight-egamut2-tlog', 'feg2lg', 'log', filmlight_egamut2, filmlight_tlog),
+	_C('Filmlight - E-Gamut2 - T-LogE', 'filmlight-egamut2-tloge', 'feg2lge', 'log', filmlight_egamut2, filmlight_tloge),
+	_C('DaVinci - WideGamut - Linear', 'davinci-wg-lin', 'dwgln', 'scene-linear', davinci_wide_gamut),
+	_C('DaVinci - WideGamut - Intermediate Log', 'davinci-wg-ilog', 'dwglg', 'log', davinci_wide_gamut, davinci_intermediate),
+	_C('Arri - WideGamut3 - Linear', 'arri-wg3-lin', 'awgln', 'scene-linear', arri_wide_gamut3),
+	_C('Arri - WideGamut3 - LogC3', 'arri-wg3-logc3', 'awglg', 'log', arri_wide_gamut3, arri_logc3),
+	_C('Arri - WideGamut4 - Linear', 'arri-wg4-lin', 'awg4ln', 'scene-linear', arri_wide_gamut4),
+	_C('Arri - WideGamut4 - LogC4', 'arri-wg4-logc4', 'awg4lg', 'log', arri_wide_gamut4, arri_logc4),
+	_C('Blackmagic - WideGamut - Linear', 'blackmagic-wg-lin', 'bwgln', 'scene-linear', blackmagic_wide_gamut),
+	_C('Blackmagic - WideGamut - Gen5 Log', 'blackmagic-wg-gen5log', 'bwglg', 'log', blackmagic_wide_gamut, blackmagic_film_gen5),
+	_C('Canon - C-Gamut - Linear', 'canon-cgamut-lin', 'ccgln', 'scene-linear', canon_cinema_gamut),
+	_C('Canon - C-Gamut - C-Log2', 'canon-cgamut-clog2', 'ccglg2', 'log', canon_cinema_gamut, canon_clog2),
+	_C('Canon - C-Gamut - C-Log3', 'canon-cgamut-clog3', 'ccglg3', 'log', canon_cinema_gamut, canon_clog3),
+	_C('DJI - D-Gamut - Linear', 'dji-dgamut-lin', 'dgln', 'scene-linear', dji_dgamut),
+	_C('DJI - D-Gamut - D-Log', 'dji-dgamut-dlog', 'dglg', 'log', dji_dgamut, dji_dlog),
+	_C('Fujifilm - F-Gamut - Linear', 'fuji-fgamut-lin', 'fgln', 'scene-linear', fujifilm_fgamut),
+	_C('Fujifilm - F-Gamut - F-Log', 'fuji-fgamut-flog', 'fglg', 'log', fujifilm_fgamut, fujifilm_flog),
+	_C('Fujifilm - F-Gamut - F-Log2', 'fuji-fgamut-flog2', 'fglg2', 'log', fujifilm_fgamut, fujifilm_flog2),
+	_C('Fujifilm - F-GamutC - Linear', 'fuji-fgamutc-lin', 'fgcln', 'scene-linear', fujifilm_fgamut_c),
+	_C('Fujifilm - F-GamutC - F-Log2', 'fuji-fgamutc-flog2', 'fgclg2', 'log', fujifilm_fgamut_c, fujifilm_flog2),
+	_C('Kodak Cineon', 'cineon', 'cin', 'log', rec709, kodak_cineon),
+	_C('GoPro - Rec.709 - Protune', 'gopro-rec709-protune', 'gplg', 'log', rec709, gopro_protune),
+	_C('Leica - Rec.2020 - Linear', 'leica-rec2020-lin', 'llgln', 'scene-linear', rec2020),
+	_C('Leica - Rec.2020 - L-Log', 'leica-rec2020-llog', 'llglg', 'log', rec2020, leica_llog),
+	_C('Nikon - Rec.2020 - Linear', 'nikon-rec2020-lin', 'ngln', 'scene-linear', rec2020),
+	_C('Nikon - Rec.2020 - N-Log', 'nikon-rec2020-nlog', 'nglg', 'log', rec2020, nikon_nlog),
+	_C('Apple - Rec.2020 - Linear', 'apple-rec2020-lin', 'apln', 'scene-linear', rec2020),
+	_C('Apple - Rec.2020 - Apple-Log', 'apple-rec2020-alog', 'aplg', 'log', rec2020, apple_log),
+	_C('Samsung - Rec.2020 - Linear', 'samsung-rec2020-lin', 'smln', 'scene-linear', rec2020),
+	_C('Samsung - Rec.2020 - Samsung-Log', 'samsung-rec2020-slog', 'smlg', 'log', rec2020, samsung_log),
+	_C('Xiaomi - Rec.2020 - Linear', 'xiaomi-rec2020-lin', 'xmln', 'scene-linear', rec2020),
+	_C('Xiaomi - Rec.2020 - Xiaomi-Log', 'xiaomi-rec2020-xlog', 'xmlg', 'log', rec2020, xiaomi_log),
+	_C('Panasonic - V-Gamut - Linear', 'panasonic-vgamut-lin', 'vgln', 'scene-linear', panasonic_vgamut),
+	_C('Panasonic - V-Gamut - V-Log', 'panasonic-vgamut-vlog', 'vglg', 'log', panasonic_vgamut, panasonic_vlog),
+	_C('Red - WideGamutRGB - Linear', 'red-wg-lin', 'rwgln', 'scene-linear', red_wide_gamut),
+	_C('Red - WideGamutRGB - Log3G10', 'red-wg-log3g10', 'rwglg', 'log', red_wide_gamut, red_log3g10),
+	_C('Sony - S-Gamut3 - Linear', 'sony-sgamut3-lin', 'sg3ln', 'scene-linear', sony_sgamut3),
+	_C('Sony - S-Gamut3 - S-Log3', 'sony-sgamut3-slog3', 'sg3lg3', 'log', sony_sgamut3, sony_slog3),
+	_C('Sony - S-Gamut3.Cine - Linear', 'sony-sgamut3cine-lin', 'sg3cln', 'scene-linear', sony_sgamut3_cine),
+	_C('Sony - S-Gamut3.Cine - S-Log3', 'sony-sgamut3cine-slog3', 'sg3clg3', 'log', sony_sgamut3_cine, sony_slog3),
+	_C('Sony - Venice S-Gamut3 - Linear', 'sony-venice-sgamut3-lin', 'vsg3ln', 'scene-linear', sony_venice_sgamut3),
+	_C('Sony - Venice S-Gamut3 - S-Log3', 'sony-venice-sgamut3-slog3', 'vsg3lg3', 'log', sony_venice_sgamut3, sony_slog3),
+	_C('Sony - Venice S-Gamut3.Cine - Linear', 'sony-venice-sgamut3cine-lin', 'vsg3cln', 'scene-linear', sony_venice_sgamut3_cine),
+	_C('Sony - Venice S-Gamut3.Cine - S-Log3', 'sony-venice-sgamut3cine-slog3', 'vsg3clg3', 'log', sony_venice_sgamut3_cine, sony_slog3),
+	_C('Rec.709 - Linear', 'rec709-lin', 'rec709ln', 'scene-linear', rec709),
+	_C('Rec.2020 - Linear', 'rec2020-lin', 'rec2020ln', 'scene-linear', rec2020),
+	_C('P3D65 - Linear', 'p3d65-lin', 'p3d65ln', 'scene-linear', p3d65),
+	_C('Rec.1886', 'rec1886', 'rec1886', 'sdr-video', rec709, gamma24),
+	_C('sRGB Display', 'srgb-display', 'srgb-display', 'sdr-video', rec709, gamma22),
+	_C('sRGB Encoding', 'srgb-encoding', 'srgb-encoding', 'sdr-video', rec709, srgb_piecewise),
+	_C('DCIP3 D65', 'dci-p3d65', 'dci-p3d65', 'sdr-video', p3d65, gamma26),
+	_C('Display P3', 'display-p3', 'display-p3', 'sdr-video', p3d65, gamma22),
+	_C('Rec2100 PQ', 'rec2100-pq', 'pq', 'hdr-video', rec2020, pq),
+	_C('Rec2100 HLG', 'rec2100-hlg', 'hlg', 'hdr-video', rec2020, hlg),
+)
+del _C
+
+def _build_index():
+	# Every name, shortname and alias must identify exactly one colorspace
+	index = {}
+	for cs in _COLORSPACES:
+		for key in {cs.name.lower(), cs.shortname.lower(), cs.alias.lower()}:
+			if key in index:
+				raise ValueError(f'colorspace key {key!r} is used by both {index[key].name!r} and {cs.name!r}')
+			index[key] = cs
+	return index
+
+_INDEX = _build_index()
+
+
+###################################################################################################
+# Public interface
+
+def colorspaces():
+	''' All available colorspaces '''
+	return _COLORSPACES
+
+def get(name):
+	''' Look up a colorspace by name, shortname or alias (case insensitive) '''
+	if isinstance(name, Colorspace):
+		return name
+	try:
+		return _INDEX[name.lower()]
+	except KeyError:
+		close = difflib.get_close_matches(name.lower(), _INDEX, n=3)
+		hint = f', did you mean {", ".join(map(repr, close))}?' if close else ''
+		raise KeyError(f'unknown colorspace {name!r}{hint}') from None
+
+def converter(src, dst, cat='cat02', np=False):
+	''' Return a function converting an RGB triplet from colorspace src to colorspace dst
+			With np=True it converts a numpy array of shape (..., 3) instead.
+	'''
+	src, dst = get(src), get(dst)
+	m = matrix(src, dst, cat=cat)
+	if np:
+		if _is_identity(m):
+			return lambda rgb: dst.encode(src.decode(rgb, np=True), np=True)
+		mt = _array(m).T
+		return lambda rgb: dst.encode(src.decode(rgb, np=True) @ mt, np=True)
+	if _is_identity(m):
+		return lambda rgb: dst.encode(src.decode(rgb))
+	return lambda rgb: dst.encode(_dot(m, src.decode(rgb)))
+
+def convert(rgb, src, dst, cat='cat02', np=False):
+	''' Convert an RGB triplet from colorspace src to colorspace dst
+			With np=True rgb is a numpy array of shape (..., 3).
+	'''
+	return converter(src, dst, cat=cat, np=np)(rgb)