Structure Computer (Cohen / AARON)

Math essence

A finite-state machine with seven emitting rules R = {open_line, closed_polygon, branch_tree, arc, connect, loop, oblong} and a probability vector p ∈ Δ⁶. At each tick t = 1..N we sample rₜ ~ p, execute rₜ which mutates a path list P, and re-render. The list P is a deduplicated union of all primitives emitted by the rules, and the canvas is a rasterisation of P with the ink thickness set to 1.2 px. After a configurable number of ticks we trim P to its most recent K entries to keep the density bounded.

Parameters

Reference

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

from __future__ import annotations

from typing import ClassVar

import imageio.v2 as imageio
import numpy as np


class CohenStructureComputer:
    family: ClassVar[str] = "generative_pioneers_2"
    sketch: ClassVar[str] = "cohen_structure_computer"

    def __init__(
        self,
        dim: int = 512,
        margin: float = 0.06,
        rules_per_pass: int = 200,
        rule_probs: tuple[float, ...] = (0.18, 0.14, 0.14, 0.10, 0.20, 0.10, 0.14),
        seed: int | None = None,
    ) -> None:
        if len(rule_probs) != 7:
            raise ValueError("rule_probs must have exactly 7 entries")
        s = sum(rule_probs)
        if s <= 0:
            raise ValueError("rule_probs must sum to a positive number")
        self.dim = dim
        self.margin = margin
        self.rules_per_pass = rules_per_pass
        self.rule_probs = tuple(p / s for p in rule_probs)
        self._seed = seed
        self.rng = np.random.default_rng(seed)
        self.canvas = np.full((dim, dim, 3), 245, dtype=np.uint8)
        self.state = "INIT"
        self._paths: list[dict] = []
        self._shapes: list[dict] = []
        self._ticks = 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), 245, dtype=np.uint8)
        self._paths = []
        self._shapes = []
        self._ticks = 0
        self.state = "INIT"
        self._dirty = True

    def _stroke(
        self,
        x0: float,
        y0: float,
        x1: float,
        y1: float,
        color: np.ndarray,
        thickness: float = 1.4,
    ) -> None:
        d = float(np.hypot(x1 - x0, y1 - y0))
        if d < 0.5: