Pleated Fabric

Math essence

x, y normalized to [-1, 1]. z = A * clip(1 - 0.7*|y|, 0, 1) * sin(2π*f_x*x + phase) + 0.18*A*sin(2π*f_y*y + phase*0.6). Project: u = x + z*tilt, v = y - z*(1-tilt). Painter's-algorithm sort by u+v yields correct overlap. Fold frequency fx drifts by N(0, fold_drift) per step.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/akten_quayola/PleatedFabric/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


class PleatedFabric:
    """Pleated Fabric — Quayola, *Pleated* / folded-textile studies.

    Quayola's research into pleating (Issey-Miyake-influenced folded
    surfaces) translates into a periodic vertical displacement of a
    textile grid:  z(x, y, t) = amp * sin(fold_freq * x + phase(t)) *
    envelope(y).  Here the grid is projected under a slow oblique
    camera tilt so the folds read as parallel ridges of light; a
    secondary horizontal pleating introduces a subtle cross-hatch.

    The pleats evolve over time — Quayola's "form and matter in
    tension" — with the fold frequency drifting so the textile never
    freezes.  A fabric-coloured palette of bone, indigo and rose
    completes the look.
    """

    family: ClassVar[str] = "akten_quayola"
    sketch: ClassVar[str] = "PleatedFabric"

    def __init__(
        self,
        dim: int = 512,
        fold_freq: float = 0.03,
        fold_drift: float = 0.0008,
        cross_freq: float = 0.012,
        amplitude: float = 0.45,
        tilt: float = 0.65,
        depth: float = 0.6,
        seed: int | None = None,
        background: tuple[int, int, int] = (240, 232, 214),
        **_,
    ) -> None:
        self.dim = int(dim)
        self.fold_freq = float(fold_freq)
        self.fold_drift = float(fold_drift)
        self.cross_freq = float(cross_freq)
        self.amplitude = float(amplitude)
        self.tilt = float(tilt)
        self.depth = float(depth)
        self.bg_color = np.array(background, dtype=np.float32)
        self.reset(seed=seed)

    def reset(self, seed: int | None = None) -> None:
        self.rng = np.random.default_rng(seed)
        self.t = 0.0
        self.fold_phase = 0.0
        gn = self.dim
        ys, xs = np.mgrid[0:gn, 0:gn].astype(np.float32)
        self.grid_x = xs / gn
        self.grid_y = ys / gn

    def step(self, n: int = 1) -> None:
        for _ in range(n):