Hypertransformations (Molnár)

Math essence

Each cell (ci, ri) is mapped to local coordinates (u, v) ∈ [0,1]²; a global field φ(u,v,t) = sin(kx·π·u + α·t)·cos(ky·π·v + β·t) drives rotation θ = amp_rot·φ, scale s = 1 + amp_scale·φ, displacement (dx, dy) = amp_disp·(φ, 1−φ), and a palette index ∝ φ. The deformation is continuous in (u, v, t) and renders as a quilt of tilted, scaled, recoloured squares.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/generative_pioneers_2/molnar_hypertransformations/reference.py

from __future__ import annotations

from typing import ClassVar

import imageio.v2 as imageio
import numpy as np


class MolnarHypertransformations:
    family: ClassVar[str] = "generative_pioneers_2"
    sketch: ClassVar[str] = "molnar_hypertransformations"

    def __init__(
        self,
        dim: int = 512,
        cols: int = 10,
        rows: int = 10,
        margin: float = 0.08,
        rotation_amp: float = 0.55,
        displacement_amp: float = 0.18,
        scale_amp: float = 0.35,
        color_shift: float = 0.6,
        kx: float = 0.7,
        ky: float = 1.1,
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.cols = cols
        self.rows = rows
        self.margin = margin
        self.rotation_amp = rotation_amp
        self.displacement_amp = displacement_amp
        self.scale_amp = scale_amp
        self.color_shift = color_shift
        self.kx = kx
        self.ky = ky
        self._seed = seed
        self.rng = np.random.default_rng(seed)
        self.canvas = np.full((dim, dim, 3), 245, dtype=np.uint8)
        self.time = 0
        self._dirty = True

    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), 245, dtype=np.uint8)
        self.time = 0
        self._dirty = True

    def _phi(self, u: float, v: float, t: float) -> float:
        return float(
            np.sin(self.kx * np.pi * u + 0.6 * t)
            * np.cos(self.ky * np.pi * v + 0.4 * t)
        )

    def _transformed_cell(
        self,
        cx: float,
        cy: float,