Boundaries

Math essence

Build a 2D fBm value-noise field F(x,y) of dim×dim pixels at `noise_octaves` octaves with persistence p. Compute gradient (gx, gy) = ∇F. Maintain edge field E(x,y). Each step: E *= edge_decay; E[i,j] = 1 if |∇F[i,j]| > edge_threshold and E[i,j] < 0.05; render E onto canvas as semi-transparent ink.

Parameters

Reference

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

from __future__ import annotations

from typing import ClassVar

import imageio.v2 as imageio
import numpy as np


class Boundaries:
    family: ClassVar[str] = "complexification_net"
    sketch: ClassVar[str] = "boundaries"

    def __init__(
        self,
        dim: int = 500,
        noise_scale: float = 0.018,
        noise_octaves: int = 5,
        noise_persistence: float = 0.55,
        edge_threshold: float = 0.012,
        edge_decay: float = 0.90,
        edge_init_density: float = 0.001,
        bg_color: tuple[int, int, int] = (240, 235, 225),
        line_color: tuple[int, int, int] = (35, 25, 45),
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.noise_scale = float(noise_scale)
        self.noise_octaves = int(noise_octaves)
        self.noise_persistence = float(noise_persistence)
        self.edge_threshold = float(edge_threshold)
        self.edge_decay = float(edge_decay)
        self.edge_init_density = float(edge_init_density)
        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.field: np.ndarray = np.zeros((dim, dim), dtype=np.float32)
        self.edge_field: np.ndarray = np.zeros((dim, dim), dtype=np.float32)
        self._grad_x: np.ndarray = np.zeros((dim, dim), dtype=np.float32)
        self._grad_y: np.ndarray = np.zeros((dim, dim), dtype=np.float32)
        self.time = 0
        self._build_noise()
        self.reset()

    def _build_noise(self) -> None:
        rng = np.random.default_rng(self._seed if self._seed is not None else 0)
        d = self.dim
        big = d * 4
        self._perm = rng.integers(0, 256, size=big * big, dtype=np.int32)
        self._noise_period = big

    @staticmethod
    def _fade(t: np.ndarray) -> np.ndarray:
        return t * t * t * (t * (t * 6 - 15) + 10)

    @staticmethod
    def _lerp(a: np.ndarray, b: np.ndarray, t: np.ndarray) -> np.ndarray:
        return a + t * (b - a)