Update to ColorAide 1.7.1

Author: facelessuser

CHANGES.md

@@ -1,5 +1,9 @@
 # ColorHelper
 
+## 6.1.2
+
+- **FIX**: Update to ColorAide 1.7.1.
+
 ## 6.1.1
 
 - **FIX**: Fix broken gamut mapping logic after recent port of latest

lib/coloraide/__meta__.py

@@ -192,5 +192,5 @@ def parse_version(ver: str) -> Version:
     return Version(major, minor, micro, release, pre, post, dev)
 
 
-__version_info__ = Version(1, 7, 0, "final")
+__version_info__ = Version(1, 7, 1, "final")
 __version__ = __version_info__._get_canonical()

lib/coloraide/algebra.py

@@ -79,7 +79,7 @@ def is_nan(obj: float) -> bool:
     return math.isnan(obj)
 
 
-def no_nans(value: VectorLike, default: float = 0.0) -> Vector:
+def no_nans(value: Union[VectorLike, Iterable[float]], default: float = 0.0) -> Vector:
     """Ensure there are no `NaN` values in a sequence."""
 
     return [(default if is_nan(x) else x) for x in value]
@@ -608,7 +608,7 @@ def _extract_dims(
             yield m
     else:
         for m2 in m:
-            yield from cast(ArrayLike, _extract_dims(cast(ArrayLike, m2), total - 1, target, depth + 1))
+            yield from _extract_dims(cast(ArrayLike, m2), total - 1, target, depth + 1)
 
 
 @overload

lib/coloraide/css/serialize.py

@@ -22,12 +22,10 @@
 def named_color(obj: 'Color', alpha: Optional[bool], fit: Union[str, bool]) -> Optional[str]:
     """Get the CSS color name."""
 
-    a = get_alpha(obj, alpha, False)
+    a = get_alpha(obj, alpha, False, False)
     if a is None:
         a = 1
-    method = None if not isinstance(fit, str) else fit
-    coords = alg.no_nans(obj.clone().fit(method=method)[:-1])
-    return to_name(coords + [a])
+    return to_name(get_coords(obj, fit, False, False) + [a])
 
 
 def named_color_function(
@@ -44,7 +42,7 @@ def named_color_function(
     """Translate to CSS function form `name(...)`."""
 
     # Create the function `name` or `namea` if old legacy form.
-    a = get_alpha(obj, alpha, none)
+    a = get_alpha(obj, alpha, none, legacy)
     string = ['{}{}('.format(func, 'a' if legacy and a is not None else EMPTY)]
 
     # Iterate the coordinates formatting them for percent, not percent, and even scaling them (sRGB).
@@ -85,7 +83,7 @@ def color_function(
 
     # Export in the `color(space ...)` format
     coords = get_coords(obj, fit, none, False)
-    a = get_alpha(obj, alpha, none)
+    a = get_alpha(obj, alpha, none, False)
     return (
         'color({} {}{})'.format(
             obj._space._serialize()[0],
@@ -98,15 +96,14 @@ def color_function(
 def get_coords(obj: 'Color', fit: Union[str, bool], none: bool, legacy: bool) -> Vector:
     """Get the coordinates."""
 
-    method = None if not isinstance(fit, str) else fit
-    coords = obj.fit(method=method)[:-1] if fit else obj[:-1]
+    coords = obj.fit(method=None if not isinstance(fit, str) else fit)[:-1] if fit else obj[:-1]
     return alg.no_nans(coords) if legacy or not none else coords
 
 
-def get_alpha(obj: 'Color', alpha: Optional[bool], none: bool) -> Optional[float]:
+def get_alpha(obj: 'Color', alpha: Optional[bool], none: bool, legacy: bool) -> Optional[float]:
     """Get the alpha if required."""
 
-    a = alg.no_nan(obj[-1]) if not none else obj[-1]
+    a = alg.no_nan(obj[-1]) if not none or legacy else obj[-1]
     alpha = alpha is not False and (alpha is True or a < 1.0 or alg.is_nan(a))
     return None if not alpha else a
 
@@ -120,9 +117,8 @@ def hexadecimal(
 ) -> str:
     """Get the hex `RGB` value."""
 
-    method = None if not isinstance(fit, str) else fit
-    coords = [c for c in alg.no_nans(obj.fit(method=method)[:-1])]
-    a = get_alpha(obj, alpha, False)
+    coords = get_coords(obj, fit, False, False)
+    a = get_alpha(obj, alpha, False, False)
 
     if a is not None:
         value = "#{:02x}{:02x}{:02x}{:02x}".format(

lib/coloraide/spaces/cam16.py

@@ -10,7 +10,7 @@
 import bisect
 from ..spaces import Space, Labish
 from ..cat import WHITES
-from ..channels import Channel
+from ..channels import Channel, FLG_MIRROR_PERCENT
 from .. import util
 from .. import algebra as alg
 from ..types import Vector, VectorLike
@@ -85,8 +85,8 @@ def adapt(coords: Vector, fl: float) -> Vector:
 
     adapted = []
     for c in coords:
-        x = math.pow(fl * abs(c) * 0.01, ADAPTED_COEF)
-        adapted.append(math.copysign(400 * x / (x + 27.13), c))
+        x = alg.npow(fl * c * 0.01, ADAPTED_COEF)
+        adapted.append(400 * math.copysign(x, c) / (x + 27.13))
     return adapted
 
 
@@ -97,7 +97,7 @@ def unadapt(adapted: Vector, fl: float) -> Vector:
     constant = 100 / fl * math.pow(27.13, ADAPTED_COEF_INV)
     for c in adapted:
         cabs = abs(c)
-        coords.append(math.copysign(constant * math.pow(cabs / (400 - cabs), ADAPTED_COEF_INV), c))
+        coords.append(math.copysign(constant * alg.npow(cabs / (400 - cabs), ADAPTED_COEF_INV), c))
     return coords
 
 
@@ -330,18 +330,13 @@ def cam16_jmh_to_xyz_d65(jmh: Vector, env: Environment) -> Vector:
     """CAM16 JMh to XYZ."""
 
     J, M, h = jmh
-
-    if alg.is_nan(h):  # pragma: no cover
-        h = 0
-
     return cam16_to_xyz_d65(J=J, M=M, h=h, env=env)
 
 
 def cam16_jmh_to_cam16_jab(jmh: Vector) -> Vector:
     """Translate a CAM16 JMh to Jab of the same viewing conditions."""
 
     J, M, h = jmh
-
     return [
         J,
         M * math.cos(math.radians(h)),
@@ -353,6 +348,8 @@ def cam16_jab_to_cam16_jmh(jab: Vector) -> Vector:
     """Translate a CAM16 Jab to JMh of the same viewing conditions."""
 
     J, a, b = jab
+    if J <= 0.0:
+        J = a = b = 0.0
     M = math.sqrt(a ** 2 + b ** 2)
     h = math.degrees(math.atan2(b, a))
 
@@ -380,9 +377,9 @@ class CAM16(Labish, Space):
     NAME = "cam16"
     SERIALIZE = ("--cam16",)
     CHANNELS = (
-        Channel("j", 0.0, 100.0),
-        Channel("a", -90.0, 90.0),
-        Channel("b", -90.0, 90.0)
+        Channel("j", 0.0, 100.0, limit=(0.0, None)),
+        Channel("a", -90.0, 90.0, flags=FLG_MIRROR_PERCENT),
+        Channel("b", -90.0, 90.0, flags=FLG_MIRROR_PERCENT)
     )
     CHANNEL_ALIASES = {
         "lightness": "j"

lib/coloraide/spaces/cam16_jmh.py

@@ -15,7 +15,7 @@
 from ..channels import Channel, FLG_ANGLE
 from .. import algebra as alg
 from ..types import Vector
-from typing import List, Tuple, Dict
+from typing import Dict, List, Tuple
 
 
 class Achromatic:
@@ -101,6 +101,24 @@ def scale(self, point: float) -> float:
             point = size * index + (adjusted * size)
         return point
 
+    def get_ideal_chroma(self, j: float, m: float) -> float:
+        """Get the ideal chroma."""
+
+        if j < 0.0:  # pragma: no cover
+            return 0.0
+
+        if self.spline is not None:
+            point = self.scale(j)
+            m2 = self.spline(point)[1]
+            if abs(m2 - m) < self.threshold:
+                return m
+            elif m < m2:
+                return m2
+
+        # This would be for `discounting=True`,
+        # which we do not run with currently.
+        return m  # pragma: no cover
+
     def test(self, j: float, m: float) -> bool:
         """Test if the current color is achromatic."""
 
@@ -130,8 +148,8 @@ class CAM16JMh(LChish, Space):
     NAME = "cam16-jmh"
     SERIALIZE = ("--cam16-jmh",)
     CHANNELS = (
-        Channel("j", 0.0, 100.0),
-        Channel("m", 0, 55.0, limit=(0.0, None)),
+        Channel("j", 0.0, 100.0, limit=(0.0, None)),
+        Channel("m", 0, 105.0, limit=(0.0, None)),
         Channel("h", 0.0, 360.0, flags=FLG_ANGLE)
     )
     CHANNEL_ALIASES = {
@@ -176,6 +194,7 @@ def to_base(self, coords: Vector) -> Vector:
 
         j, m = coords[:2]
         if self.ACHROMATIC.test(j, m):
+            coords[1] = self.ACHROMATIC.get_ideal_chroma(j, m)
             coords[2] = self.ACHROMATIC.hue
 
         return cam16_jmh_to_cam16_jab(coords)

lib/coloraide/spaces/cam16_ucs.py

@@ -8,7 +8,7 @@
 import math
 from . cam16 import CAM16
 from ..types import Vector
-from ..channels import Channel
+from ..channels import Channel, FLG_MIRROR_PERCENT
 
 COEFFICENTS = {
     'lcd': (0.77, 0.007, 0.0053),
@@ -79,9 +79,9 @@ class CAM16UCS(CAM16):
     SERIALIZE = ("--cam16-ucs",)
     MODEL = 'ucs'
     CHANNELS = (
-        Channel("j", 0.0, 100.0),
-        Channel("a", -50.0, 50.0),
-        Channel("b", -50.0, 50.0)
+        Channel("j", 0.0, 100.0, limit=(0.0, None)),
+        Channel("a", -50.0, 50.0, flags=FLG_MIRROR_PERCENT),
+        Channel("b", -50.0, 50.0, flags=FLG_MIRROR_PERCENT)
     )
 
     def to_base(self, coords: Vector) -> Vector:
@@ -103,9 +103,9 @@ class CAM16LCD(CAM16UCS):
     ENV = ENV = CAM16.ENV
     MODEL = 'lcd'
     CHANNELS = (
-        Channel("j", 0.0, 100.0),
-        Channel("a", -70.0, 70.0),
-        Channel("b", -70.0, 70.0)
+        Channel("j", 0.0, 100.0, limit=(0.0, None)),
+        Channel("a", -70.0, 70.0, flags=FLG_MIRROR_PERCENT),
+        Channel("b", -70.0, 70.0, flags=FLG_MIRROR_PERCENT)
     )
 
 
@@ -117,7 +117,7 @@ class CAM16SCD(CAM16UCS):
     ENV = ENV = CAM16.ENV
     MODEL = 'scd'
     CHANNELS = (
-        Channel("j", 0.0, 100.0),
-        Channel("a", -40.0, 40.0),
-        Channel("b", -40.0, 40.0)
+        Channel("j", 0.0, 100.0, limit=(0.0, None)),
+        Channel("a", -40.0, 40.0, flags=FLG_MIRROR_PERCENT),
+        Channel("b", -40.0, 40.0, flags=FLG_MIRROR_PERCENT)
     )

lib/coloraide/spaces/din99o.py

@@ -38,8 +38,8 @@ def lab_to_din99o(lab: Vector) -> Vector:
     """XYZ to DIN99o."""
 
     l, a, b = lab
-    val = 1 + C2 * l
-    l99o = C1 * math.copysign(math.log(abs(val)), val) / KE
+    val = 1 + abs(C2 * l)
+    l99o = C1 * math.copysign(1, l) * math.log(val) / KE
 
     if a == 0 and b == 0:
         a99o = b99o = 0.0
@@ -48,7 +48,7 @@ def lab_to_din99o(lab: Vector) -> Vector:
         fo = FACTOR * (b * math.cos(RADS) - a * math.sin(RADS))
         go = math.sqrt(eo ** 2 + fo ** 2)
         val = 1 + C3 * go
-        c99o = math.copysign(math.log(abs(val)), val) / (C4 * KE * KCH)
+        c99o = math.log(val) / (C4 * KE * KCH)
         h99o = math.atan2(fo, eo) + RADS
 
         a99o = c99o * math.cos(h99o)
@@ -76,15 +76,12 @@ def din99o_to_lab(din99o: Vector) -> Vector:
 
     l99o, c99o, h99o = din99o_lab_to_lch(din99o)
     val = C4 * c99o * KCH * KE
-    g = (math.copysign(math.exp(abs(val)), val) - 1) / C3
+    g = (math.exp(val) - 1) / C3
     e = g * math.cos(h99o - RADS)
     f = g * math.sin(h99o - RADS)
 
-    val = (l99o * KE) / C1
-    (math.copysign(math.exp(abs(val)), val) - 1) / C2
-
     return [
-        (math.exp((l99o * KE) / C1) - 1) / C2,
+        math.copysign(1, l99o) * (math.exp((abs(l99o) * KE) / C1) - 1) / C2,
         e * math.cos(RADS) - (f / FACTOR) * math.sin(RADS),
         e * math.sin(RADS) + (f / FACTOR) * math.cos(RADS)
     ]

lib/coloraide/spaces/hct.py

@@ -219,6 +219,7 @@ def to_base(self, coords: Vector) -> Vector:
 
         m, j = coords[1:3]
         if self.ACHROMATIC.test(j, m):
+            coords[1] = self.ACHROMATIC.get_ideal_chroma(j, m)
             coords[0] = self.ACHROMATIC.hue
 
         return hct_to_xyz(coords, self.ENV)

lib/coloraide/spaces/ipt.py

@@ -74,9 +74,9 @@ class IPT(Labish, Space):
     NAME = "ipt"
     SERIALIZE = ("--ipt",)  # type: Tuple[str, ...]
     CHANNELS = (
-        Channel("i", 0.0, 1.0, bound=True),
-        Channel("p", -1.0, 1.0, bound=True, flags=FLG_MIRROR_PERCENT),
-        Channel("t", -1.0, 1.0, bound=True, flags=FLG_MIRROR_PERCENT)
+        Channel("i", 0.0, 1.0),
+        Channel("p", -1.0, 1.0, flags=FLG_MIRROR_PERCENT),
+        Channel("t", -1.0, 1.0, flags=FLG_MIRROR_PERCENT)
     )
     CHANNEL_ALIASES = {
         "intensity": "i",