Lissajous 3D

Math essence

t.linspace(t0, t0 + 4π, N). x = ax*sin(fx_d*t + phase_xy), y = by*sin(fy_d*t), z = cz*sin(fz_d*t + phase_xz). Rotate (x, z) by angle = 0.6 + 0.25*sin(t*0.1) and perspective project: u = x/(fov + z), v = y/(fov + z). fx_d, fy_d, fz_d perform random walks to mutate the figure.

Parameters

Reference

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

from __future__ import annotations

from typing import ClassVar

import numpy as np


class Lissajous3D:
    """Lissajous 3D — Quayola, *Lissajous* series (ongoing).

    Quayola's Lissajous pieces push the classical x = A sin(at + δ),
    y = B sin(bt) parametric curve out into three dimensions:
    ``x = A sin(a t + δ)``, ``y = B sin(b t)``, ``z = C sin(c t + ε)``.

    Each formula below adds a slowly evolving perturbation to the
    integer frequency ratios so the curve never quite closes; the
    rendered figure rotates around a vertical axis and is projected
    onto a 2D canvas using a simple perspective divide.  Brightness
    comes from a depth-faded ink palette, evoking the precision
    line-art feel of Quayola's plotter output.
    """

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

    def __init__(
        self,
        num_points: int = 12000,
        dim: int = 512,
        fx: int = 3,
        fy: int = 2,
        fz: int = 5,
        ax: float = 1.0,
        by: float = 0.8,
        cz: float = 0.6,
        phase_xy: float = 0.0,
        phase_xz: float = 0.0,
        drift: float = 0.0008,
        fov: float = 1.6,
        background: tuple[int, int, int] = (12, 12, 22),
        **_,
    ) -> None:
        self.num_points = int(num_points)
        self.dim = int(dim)
        self.fx = int(fx)
        self.fy = int(fy)
        self.fz = int(fz)
        self.ax = float(ax)
        self.by = float(by)
        self.cz = float(cz)
        self.phase_xy = float(phase_xy)
        self.phase_xz = float(phase_xz)
        self.drift = float(drift)
        self.fov = float(fov)
        self.bg_color = np.array(background, dtype=np.float32)
        self.reset(seed=None)

    def reset(self, seed: int | None = None) -> None:
        self.rng = np.random.default_rng(seed)
        self.t = 0.0