Paint by Numbers (Haeberli)

Math essence

Sample N points {(x_i, y_i)} ~ U(canvas²); each gets color C_i = target[y_i, x_i] + ε, where ε ~ U(−j, j) per channel; stroke orientation θ_i = atan2(∇lum) + jitter. Sort the N strokes by L(y_i, x_i) ascending and render with low-alpha alpha_base per stroke so each lays down a soft pigment deposit that accumulates.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/generative_pioneers/haeberli_painterly/reference.py

from __future__ import annotations

from typing import ClassVar

import imageio.v2 as imageio
import numpy as np


class HaeberliPainterly:
    family: ClassVar[str] = "generative_pioneers"
    sketch: ClassVar[str] = "haeberli_painterly"

    def __init__(
        self,
        dim: int = 512,
        n_strokes: int = 1200,
        stroke_length: int = 18,
        stroke_thickness: int = 6,
        source: str = "diagonal_band",
        color_jitter: float = 0.15,
        luminance_seed: int = 42,
        alpha_base: float = 0.32,
        bg_color: tuple[int, int, int] = (245, 240, 230),
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.n_strokes = n_strokes
        self.stroke_length = stroke_length
        self.stroke_thickness = stroke_thickness
        self.source = source
        self.color_jitter = color_jitter
        self.luminance_seed = luminance_seed
        self.alpha_base = alpha_base
        self.bg_color = np.array(bg_color, dtype=np.uint8)
        self._seed = seed
        self.rng = np.random.default_rng(seed)
        self.canvas = np.full((dim, dim, 3), self.bg_color, dtype=np.uint8)
        self.time = 0
        self._dirty = True

    def reset(self, seed: int | None = None) -> None:
        if seed is not None:
            self._seed = seed
        self.rng = np.random.default_rng(self._seed)
        self.canvas = np.full((self.dim, self.dim, 3), self.bg_color, dtype=np.uint8)
        self.time = 0
        self._dirty = True

    def _build_target_field(self) -> np.ndarray:
        d = self.dim
        ys, xs = np.indices((d, d))
        xn = (xs / d - 0.5) * 2.0
        yn = (ys / d - 0.5) * 2.0
        if self.source == "diagonal_band":
            v = 0.5 + 0.45 * np.sin((xn + yn) * 3.0)
        elif self.source == "sunset":
            v = 0.55 + 0.45 * (np.sin(xn * 2.0) * np.cos(yn * 2.5))
        elif self.source == "rose":
            r = np.hypot(xn, yn)
            v = 0.5 + 0.5 * np.sin(r * 8.0 - xn * 3.0)