Interruptions (Molnár)

Math essence

For each cell (ci, ri) on a (cols × rows) grid we draw each of the four rectangle edges with probability (1 − gap_prob), with small per-vertex Gaussian-like jitter jitter·cell_size. The full grid is independent draws, so the expected number of partial rectangles is gap_prob·4·cols·rows.

Parameters

Reference

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

from __future__ import annotations

from typing import ClassVar

import imageio.v2 as imageio
import numpy as np


class MolnarInterruptions:
    family: ClassVar[str] = "generative_pioneers"
    sketch: ClassVar[str] = "molnar_interruptions"

    def __init__(
        self,
        dim: int = 512,
        cols: int = 12,
        rows: int = 16,
        margin: float = 0.06,
        gap_prob: float = 0.45,
        jitter: float = 0.12,
        thickness: float = 1.4,
        bg_color: tuple[int, int, int] = (245, 240, 230),
        line_color: tuple[int, int, int] = (10, 10, 14),
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.cols = cols
        self.rows = rows
        self.margin = margin
        self.gap_prob = gap_prob
        self.jitter = jitter
        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))
        steps = max(2, int(d))
        base = self.canvas.astype(np.float32)
        c = color.astype(np.float32)