lib.color

  1import drawBot
  2import colorsys
  3import random
  4from typing import Literal
  5from lib import helpers
  6from loguru import logger
  7from icecream import ic
  8
  9
 10def pickRandomRGB(lightness=0.5) -> tuple[float, float, float]:
 11    """
 12    Picks a random RGB color with a specified lightness.
 13
 14    Args:
 15        lightness: Desired lightness level (0 = dark, 1 = light).
 16
 17    Returns:
 18        A tuple of three floats representing the RGB color.
 19    """
 20    h = random.random()  # Hue
 21    l = lightness  # Lightness
 22    s = 1  # Saturation
 23    return colorsys.hls_to_rgb(h, l, s)
 24
 25
 26def isRGBFloat(color) -> bool:
 27    """
 28    Checks if the given color is an RGB float tuple.
 29
 30    Args:
 31        color: The color to check.
 32
 33    Returns:
 34        True if the color is a tuple of three values, each less than or equal to 1; otherwise, False.
 35    """
 36    "`(1, 0, 0)` => `True`"
 37    return isinstance(color, tuple) and len(color) == 3 and all([c <= 1 for c in color])
 38
 39
 40def isRGBInt(color) -> bool:
 41    """
 42    Checks if the given color is an RGB integer tuple.
 43
 44    Args:
 45        color: The color to check.
 46
 47    Returns:
 48        True if the color is a tuple of three integer values; otherwise, False.
 49    """
 50    "`(255, 0, 0)` => `True`"
 51    return (
 52        isinstance(color, tuple)
 53        and len(color) == 3
 54        and all([isinstance(c, int) for c in color])
 55    )
 56
 57
 58def toRGBInt(color) -> tuple[int, int, int]:
 59    """
 60    Converts a color to an RGB integer tuple.
 61
 62    Args:
 63        color: The color to convert.
 64
 65    Returns:
 66        A tuple of three integers representing the RGB color.
 67    """
 68    "`(1, 0, 0)` => `(255, 0, 0)`"
 69    if isinstance(color, HSL):
 70        color = color.asRGB
 71    else:
 72        color = helpers.expand(color, n=3, format="tuple")
 73
 74    if isRGBFloat(color):
 75        return tuple(round(c * 255) for c in color)
 76    else:
 77        logger.warning("toRGBInt failed for {}", color)
 78
 79
 80def isDark(color, sensitivity=0.5) -> bool:
 81    """
 82    Determines if a color is considered dark based on luminance and sensitivity.
 83
 84    Args:
 85        color: The color to check.
 86        sensitivity: Threshold for darkness (0 = always dark, 1 = always light).
 87
 88    Returns:
 89        True if the color is dark, False otherwise.
 90    """
 91
 92    def _getLuminance(input) -> float:
 93        "`0` = dark, `1` = light"
 94        r, g, b = toRGBInt(input)
 95        return (0.299 * r + 0.587 * g + 0.114 * b) / 255
 96
 97    return _getLuminance(color) < sensitivity
 98
 99
100class CMYK:
101    def __init__(self, c=0, m=0, y=0, k=0, a=100):
102        """
103        Initializes a CMYK color.
104
105        Args:
106            c: Cyan value.
107            m: Magenta value.
108            y: Yellow value.
109            k: Black value.
110            a: Alpha value.
111        """
112        self.c = c
113        self.m = m
114        self.y = y
115        self.k = k
116        self.alpha = a
117
118    @property
119    def values(self):
120        """Returns a list of float values for drawBot."""
121        return list(
122            map(lambda v: v / 100, [self.c, self.m, self.y, self.k, self.alpha])
123        )
124
125    def setFill(self):
126        """
127        Sets the fill color in drawBot using this CMYK color.
128
129        Returns:
130            self
131        """
132        drawBot.cmykFill(*self.values)
133        return self
134
135    def setStroke(self):
136        """
137        Sets the stroke color in drawBot using this CMYK color.
138
139        Returns:
140            self
141        """
142        drawBot.cmykStroke(*self.values)
143        return self
144
145
146class HSL:
147    def __init__(self, h=0, s=100, l=50, a=1):
148        """
149        Initializes an HSL color.
150
151        Args:
152            h: Hue value.
153            s: Saturation value.
154            l: Lightness value.
155            a: Alpha value.
156        """
157        self.h = h
158        self.s = s
159        self.l = l
160        self.a = a
161
162    def __str__(self) -> str:
163        """Returns a string representation of the HSL color."""
164        return f"HSL({self.h}, {self.s}, {self.l}, {self.a})"
165
166    @property
167    def asRGB(self):
168        """Returns the RGB float tuple representation of this HSL color."""
169        hls = self.h / 360, self.l / 100, self.s / 100  # Different order for colorsys
170        return colorsys.hls_to_rgb(*hls)
171
172    @property
173    def asRGBA(self):
174        """Returns the RGBA float tuple representation of this HSL color."""
175        return (*self.asRGB, self.a)
176
177    def setFill(self):
178        """
179        Sets the fill color in drawBot using this HSL color.
180
181        Returns:
182            self
183        """
184        drawBot.fill(*self.asRGBA)
185        return self
186
187    def setStroke(self):
188        """
189        Sets the stroke color in drawBot using this HSL color.
190
191        Returns:
192            self
193        """
194        drawBot.stroke(*self.asRGBA)
195        return self
196
197    def isDark(self, sensitivity=0.5) -> bool:
198        """
199        Determines if this HSL color is considered dark based on luminance and sensitivity.
200
201        Args:
202            sensitivity: Threshold for darkness (0 = always dark, 1 = always light).
203
204        Returns:
205            True if the color is dark, False otherwise.
206        """
207        return isDark(self.asRGB, sensitivity)
208
209
210def mixComplementary(
211    source: HSL,
212    hueShift=360 / 2,
213    hueDirection: Literal["up", "down", "any"] = "any",
214    lightShift=30,
215    sensitivity=0.5,
216) -> HSL:
217    """
218    Mixes a complementary color based on the source HSL color.
219
220    Args:
221        source: The source HSL color.
222        hueShift: Amount to shift the hue.
223        hueDirection: Direction to shift the hue ("up", "down", or "any").
224        lightShift: Amount to shift the lightness.
225        sensitivity: Threshold for darkness (0 = always create darker, 1 = always create lighter).
226
227    Returns:
228        A new HSL color that is complementary to the source.
229    """
230    # Hue
231    hueDirections = dict(up=[1], down=[-1], any=[-1, 1])
232    hueRotate = lambda val: random.choice(hueDirections.get(hueDirection)) * val
233    h = (source.h + hueRotate(hueShift)) % 360
234    # Lightness
235    sourceIsDark = isDark(source.asRGB, sensitivity)
236    lightDelta = lightShift if sourceIsDark else -lightShift
237    l = source.l + lightDelta
238
239    return HSL(h, 100, l)