Cellular Automata Worm

Math essence

Wolfram 1D CA on a ring of N bits: each new row b'_{i} = LUT[3·b_{i-1} + 2·b_i + b_{i+1}] where LUT is the bit-table for the chosen rule (default 114). Each successive row is then drawn at scale s_n = scale_per_step^n and angle theta_n = n · rotate_per_step, so successive generations walk outward in a log-spiral.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/complexification_net/cellularAutomataWorm/reference.py

from __future__ import annotations

from typing import ClassVar

import imageio.v2 as imageio
import numpy as np


class CellularAutomataWorm:
    family: ClassVar[str] = "complexification_net"
    sketch: ClassVar[str] = "cellularAutomataWorm"

    def __init__(
        self,
        dim: int = 400,
        rule: int = 114,
        rotate_per_step_deg: float = 0.85,
        scale_per_step: float = 1.018,
        max_rows: int = 400,
        start_density: float = 0.5,
        bg_color: tuple[int, int, int] = (250, 245, 235),
        worm_color: tuple[int, int, int] = (40, 30, 60),
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.rule = int(rule)
        self.rotate_per_step = float(np.deg2rad(rotate_per_step_deg))
        self.scale_per_step = float(scale_per_step)
        self.max_rows = max_rows
        self.start_density = float(start_density)
        self.bg_color = np.array(bg_color, dtype=np.uint8)
        self.worm_color = np.array(worm_color, dtype=np.uint8)
        self._seed = seed
        self.rng = np.random.default_rng(seed)
        self._rule_table: np.ndarray = np.zeros(8, dtype=np.uint8)
        self._build_rule_table()
        self.canvas = np.full((dim, dim, 3), self.bg_color, dtype=np.uint8)
        self.rows: list[np.ndarray] = []
        self.positions: list[tuple[float, float]] = []
        self.scales: list[float] = []
        self.angle = 0.0
        self.scale = 1.0
        self.cx = dim / 2.0
        self.cy = dim / 2.0
        self.num_rows = 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._build_rule_table()
        self.canvas = np.full((self.dim, self.dim, 3), self.bg_color, dtype=np.uint8)
        self.rows = []
        self.positions = []
        self.scales = []
        self.angle = 0.0
        self.scale = 1.0
        self.cx = self.dim / 2.0