P-159 D (Mohr)

Math essence

For each cell (ri, ci) sample N endpoints uniformly in the cell rectangle, form a line per pair, drop each line with probability (1 − keep_prob), clip the survivors to the cell with Liang-Barsky, then for every pair of surviving segments (s_i, s_j) that come from cells of opposite parity (ri+ci) mod 2, compute the segment intersection via the standard 2D cross-ratio test and mark the crossing with a small red dot. The cell-grid periodicity plus the parity-gated intersection layer is the P-159 D kernel.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/generative_pioneers_2/mohr_p159d/reference.py

from __future__ import annotations

from typing import ClassVar

import imageio.v2 as imageio
import numpy as np


class MohrP159D:
    family: ClassVar[str] = "generative_pioneers_2"
    sketch: ClassVar[str] = "mohr_p159d"

    def __init__(
        self,
        dim: int = 512,
        cells: int = 4,
        lines_per_cell: int = 14,
        margin: float = 0.06,
        line_jitter: float = 0.45,
        keep_prob: float = 0.5,
        thickness: float = 1.2,
        bg_color: tuple[int, int, int] = (240, 235, 222),
        line_color: tuple[int, int, int] = (12, 12, 18),
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.cells = cells
        self.lines_per_cell = lines_per_cell
        self.margin = margin
        self.line_jitter = line_jitter
        self.keep_prob = keep_prob
        self.thickness = thickness
        self.bg_color = np.array(bg_color, dtype=np.uint8)
        self.line_color = np.array(line_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 _stroke(
        self,
        x0: float,
        y0: float,
        x1: float,
        y1: float,
        color: np.ndarray,
    ) -> None:
        d = float(np.hypot(x1 - x0, y1 - y0))
        if d < 0.5:
            return
        steps = max(2, int(d))