Interpolation can have reversed domains

Author: facelessuser

coloraide/algebra.py

@@ -19,6 +19,7 @@
 """
 from __future__ import annotations
 import builtins
+import bisect
 import decimal
 import sys
 import cmath
@@ -261,6 +262,20 @@ def polar_to_rect(c: float, h: float) -> tuple[float, float]:
     return c * math.cos(r), c * math.sin(r)
 
 
+def reversed_bisect_left(a: Vector, x: float, lo: int = 0, hi: int | None = None) -> int:
+    """Perform bisect left on a reversed list."""
+
+    if hi is None:
+        hi = len(a)
+    while lo < hi:
+        mid = (lo + hi) // 2
+        if x >= a[mid]:
+            hi = mid
+        else:
+            lo = mid + 1
+    return lo
+
+
 def solve_bisect(
     low: float,
     high: float,
@@ -767,7 +782,8 @@ def __init__(
         self.num_coords = len(points[0])
         self.preprocess(points)
         self.points = [*zip(*points)]
-        self.domain = domain[:] if domain is not None else domain
+        self.domain = list(domain) if domain is not None else domain
+        self.increasing = not self.domain or len(self.domain) == 1 or self.domain[1] > self.domain[0]
 
     @classmethod
     def preprocess(cls, points: list[Vector]) -> None:
@@ -796,17 +812,29 @@ def handle_domain(self, t: float) -> float:
         if self.domain is None:
             return t
 
+        import operator as op
+        le, ge = (op.le, op.ge) if self.increasing else (op.ge, op.le)
+
         # Extrapolation
-        if t <= self.domain[0]:
+        if le(t, self.domain[0]):
             t = (t - self.domain[0]) / (self.domain[-1] - self.domain[0])
-        elif t >= self.domain[-1]:
+        elif ge(t, self.domain[-1]):
             t = 1.0 + (t - self.domain[-1]) / (self.domain[-1] - self.domain[0])
 
         # Interpolation
         else:
-            a, b = self.domain[0], self.domain[len(self.domain) - 1]
-            l = b - a
-            t = ((t - a) / l) if l else 0.0
+            bisect_left = bisect.bisect_left if self.increasing else reversed_bisect_left
+            regions = len(self.domain) - 1
+            size = (1 / regions)
+            index = bisect_left(self.domain, t) - 1
+            adjusted = 0.0
+            if index < regions:
+                a, b = self.domain[index:index + 2]
+                l = b - a
+                adjusted = ((t - a) / l) if l else 0.0
+            else:
+                index = regions - 1
+            t = size * index + (adjusted * size)
         return t
 
     def __call__(self, t: float) -> Vector:
@@ -859,7 +887,7 @@ def run(self, i: int, t: float) -> Vector:
 
 
 class CatmullRomInterpolator(_CubicInterpolator):
-    """Catrom-Mull interpolator."""
+    """Catmull-Rom interpolator."""
 
     @staticmethod
     def interpolate(p0: float, p1: float, p2: float, p3: float, t: float) -> float:
@@ -989,7 +1017,7 @@ def _matrix_141(n: int) -> Matrix:
 
 
 class NaturalBSplineInterpolator(BSplineInterpolator):
-    """Natrual B-Spline interpolator."""
+    """Natural B-Spline interpolator."""
 
     @staticmethod
     def naturalize(points: list[Vector]) -> None:

coloraide/cmfs.py

@@ -10,7 +10,7 @@ class CMFs(dict[float, Vector]):
     """A color matching function wrapper for CMFs."""
 
     def __init__(self, cmfs: dict[float, Vector], /, interpolator: str = 'cubic', **kwargs: Any):
-        """Initalize and capture attributes of CMF."""
+        """Initialize and capture attributes of CMF."""
 
         keys = list(cmfs.keys())
         self.spline = alg.interpolate(list(cmfs.values()), method='sprague')
@@ -30,7 +30,7 @@ def __getitem__(self, key: float) -> Vector:
         return self.spline(factor)
 
     def xy(self, key: float) -> Vector:
-        """Return CMFs data as XY coordiantes."""
+        """Return CMFs data as XY coordinates."""
 
         return util.xyz_to_xyY(self[key])[:-1]
 

coloraide/illuminants.py

@@ -8,7 +8,7 @@ class Illuminant(dict[float, float]):
     """Spectral distribution of illuminants."""
 
     def __init__(self, illuminant: dict[float, float], /, **kwargs: Any):
-        """Initalize and capture attributes of CMF."""
+        """Initialize and capture attributes of CMF."""
 
         keys = list(illuminant.keys())
         self.spline = alg.interpolate([[i]for i in illuminant.values()], method='linear')

coloraide/interpolate/__init__.py

@@ -15,6 +15,7 @@
 """
 from __future__ import annotations
 import math
+import bisect
 import functools
 from abc import ABCMeta, abstractmethod
 from .. import algebra as alg
@@ -101,6 +102,7 @@ def __init__(
         self.extrapolate = extrapolate
         self.current_easing = None  # type: Mapping[str, Callable[..., float]] | Callable[..., float] | None
         self.hue = hue
+        self.increasing = True
         cs = self.color_cls.CS_MAP[space]
         if cs.is_polar():
             self.hue_index = cs.hue_index()  # type: ignore[attr-defined]
@@ -119,6 +121,7 @@ def __init__(
 
         # Set the domain
         self._domain = []  # type: Vector
+
         if domain is not None:
             self.domain(domain)
 
@@ -186,6 +189,12 @@ def out_space(self, space: str) -> None:
             raise ValueError(f"'{space}' is not a valid color space")
         self._out_space = space
 
+    def domain(self, domain: Sequence[float]) -> None:
+        """Set the domain."""
+
+        self._domain = list(domain)
+        self.increasing = not domain or len(domain) == 1 or domain[1] > domain[0]
+
     def padding(self, padding: float | Sequence[float]) -> None:
         """Add/adjust padding."""
 
@@ -215,28 +224,6 @@ def padding(self, padding: float | Sequence[float]) -> None:
         else:
             self._padding = (0.0 + padding[0], 1.0 - padding[1])
 
-    def domain(self, domain: Sequence[float]) -> None:
-        """Set the domain."""
-
-        # Ensure domain ascends.
-        # If we have a domain of length 1, we will duplicate it.
-        d = []  # type: Vector
-        if domain:
-            length = len(domain)
-
-            # Ensure values are not descending
-            d.append(domain[0])
-            for index in range(length - 1):
-                b = domain[index + 1]
-                d.append(d[-1] if b <= d[-1] else b)
-
-            # We need at least two values, so duplicate the first.
-            if len(d) == 1:
-                d.append(d[0])
-            domain = d
-
-        self._domain = d
-
     @abstractmethod
     def setup(self) -> None:
         """Setup."""
@@ -405,38 +392,42 @@ def ease(self, t: float, channel_index: int) -> float:
 
         return progress(t) if progress is not None else t
 
-    def scale(self, point: float) -> float:
+    def handle_domain(self, p: float) -> float:
         """
         Scale a point from a custom domain into a domain of 0 to 1.
 
         This allows a user to have a custom domain, but for us to adapt back to 0 and 1
         so that our logic can remain consistent.
         """
 
-        if point < self._domain[0]:
-            point = (point - self._domain[0]) / (self._domain[-1] - self._domain[0]) if self.extrapolate else 0.0
-        elif point > self._domain[-1]:
-            point = 1.0 + (point - self._domain[-1]) / (self._domain[-1] - self._domain[0]) if self.extrapolate else 1.0
+        import operator as op
+
+        le, ge = (op.le, op.ge) if self.increasing else (op.ge, op.le)
+        bisect_left = bisect.bisect_left if self.increasing else alg.reversed_bisect_left
+
+        if le(p, self._domain[0]):
+            p = (p - self._domain[0]) / (self._domain[-1] - self._domain[0]) if self.extrapolate else 0.0
+        elif ge(p, self._domain[-1]):
+            p = 1.0 + (p - self._domain[-1]) / (self._domain[-1] - self._domain[0]) if self.extrapolate else 1.0
         else:
             regions = len(self._domain) - 1
             size = (1 / regions)
-            index = 0
+            index = bisect_left(self._domain, p) - 1
             adjusted = 0.0
-            for index in range(regions):
+            if index < regions:
                 a, b = self._domain[index:index + 2]
-                if point >= a and point <= b:
-                    l = b - a
-                    adjusted = ((point - a) / l) if l else 0.0
-                    break
-
-            point = size * index + (adjusted * size)
-        return point
+                l = b - a
+                adjusted = ((p - a) / l) if l else 0.0
+            else:
+                index = regions - 1
+            p = size * index + (adjusted * size)
+        return p
 
     def __call__(self, point: float) -> AnyColor:
         """Find which leg of the interpolation the request is between."""
 
         if self._domain:
-            point = self.scale(point)
+            point = self.handle_domain(point)
 
         if self._padding:
             slope = (self._padding[1] - self._padding[0])

docs/src/markdown/about/changelog.md

@@ -7,7 +7,8 @@ icon: lucide/scroll-text
 
 -   **NEW**: Refactor interpolation helpers and add Sprague interpolation.
 -   **NEW**: Refactor handling of CMFs, and when interpolating them use Sprague interpolation.
--   **NEW**: Use Sprague interpolation for the Ohno 2013 spline impelementation to reduce needed points.
+-   **NEW**: Use Sprague interpolation for the Ohno 2013 spline implementation to reduce needed points.
+-   **NEW**: Color interpolation can now have domains in reversed, sorted order.
 -   **NEW**: Discard unused CMFs, other than CIE 1931 2˚.
 -   **NEW**: Rename internal file.
 

docs/src/markdown/interpolation.md

@@ -801,9 +801,22 @@ Color.interpolate(
 )
 ```
 
-Lastly, domains must be specified in ascending order of values. If a value decreases in magnitude, it will assume the
-value that comes right before it. This means you cannot put a domain in reverse. If you need to reverse the order, just
-flip the color order and setup the domain accordingly.
+Domains can also be specified in descending order.
+
+
+```py play
+Color.interpolate(
+    ['blue', 'green', 'yellow', 'orange', 'red'],
+    domain=[95, 85, 60, 32, -32]
+)
+Color.interpolate(
+    ['blue', 'green', 'yellow', 'orange', 'red'],
+    domain=[95, -32]
+)
+```
+
+Lastly, while domains can be specified in either ascending or descending order, it needs to be consistent. If a values
+increase in values, and suddenly decreases in value, you will get discontinuities.
 
 ```py play
 i = Color.interpolate(