Subdivided Columns

Math essence

Polygon P_0 has n_sides vertices on a circle of radius R. At each subdivision k in [0, K), each edge (a, b) is replaced by (edges_per_subdivision + 2) vertices: a, the p interior midpoints perturbed by normal-direction noise, and b. Perturbation magnitude decays as decay^k so coarse structure stays coarse. After K iterations the polygon has n_sides * (edges_per_subdivision + 2)^K vertices. Each edge of each subdivision is rendered as a vectorized line with alpha-blended color: color(depth) = (1 - 0.6 * (depth/max_depth)^0.8) * edge_color + 0.6 * (depth/max_depth)^0.8 * depth_color. The blend is associative so densely-overlapped regions accumulate toward the warm depth palette.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/nervous_system_hansmeyer/HansmeyerSubdivision/reference.py

from __future__ import annotations

from typing import ClassVar

import imageio.v2 as imageio
import numpy as np


class HansmeyerSubdivision:
    family: ClassVar[str] = "nervous_system_hansmeyer"
    sketch: ClassVar[str] = "HansmeyerSubdivision"

    def __init__(
        self,
        dim: int = 600,
        n_sides: int = 6,
        subdivisions: int = 9,
        edges_per_subdivision: int = 1,
        perturbation: float = 0.16,
        perturbation_decay: float = 0.78,
        radius: float = 0.36,
        edge_color: tuple[int, int, int] = (200, 215, 240),
        depth_color: tuple[int, int, int] = (255, 170, 120),
        bg_color: tuple[int, int, int] = (6, 8, 14),
        edge_thickness: int = 1,
        edge_alpha: float = 0.25,
        start_angle: float = 0.0,
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.n_sides = n_sides
        self.subdivisions = subdivisions
        self.edges_per_subdivision = edges_per_subdivision
        self.perturbation = perturbation
        self.perturbation_decay = perturbation_decay
        self.radius = radius
        self.edge_color = np.array(edge_color, dtype=np.uint8)
        self.depth_color = np.array(depth_color, dtype=np.uint8)
        self.bg_color = np.array(bg_color, dtype=np.uint8)
        self.edge_thickness = edge_thickness
        self.edge_alpha = edge_alpha
        self.start_angle = start_angle
        self._seed = seed
        self.rng = np.random.default_rng(seed)
        self.canvas = np.full((dim, dim, 3), self.bg_color, dtype=np.uint8)
        self._edges: list[tuple[tuple[float, float], tuple[float, float], int]] = []
        self._stage = 0
        self.time = 0
        self.reset()

    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)
        cx = self.dim / 2.0
        cy = self.dim / 2.0
        R = self.radius * self.dim
        angles = self.start_angle + 2.0 * np.pi * np.arange(self.n_sides) / self.n_sides
        polygon: list[tuple[float, float]] = [