Wave Interference

Math essence

For each source i with normalized position p_i and frequency f_i, the wave contribution at pixel (x, y) is exp(-d/(w*0.45)) * sin(f_i*d - wave_speed*100*t + phase_i), where d = ||(x,y) - p_i||. Field = sum_i / num_sources; render reads tanh(field * 1.4) into a swell-trough-crest palette.

Parameters

Reference

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

from __future__ import annotations

from typing import ClassVar

import numpy as np


class WaveInterference:
    """Wave Interference — Memo Akten, *Waves* (2014–).

    Akten's Waves series renders the surface of an imagined ocean by
    simulating multiple radial wave sources and summing their
    contributions.  Here the kernel is reduced to its purest form:  N
    point sources at random positions emit circular sinusoidal waves;
    the field at each pixel is the sum of those contributions and is
    tone-mapped through a perceptual palette that evokes Akten's Hokusai-
    and Turner-inspired ocean abstractions.

    Sources slowly drift across the domain (Akten's "complex signal
    broken down into its basic elements at different frequencies") and
    their frequencies are quantized ratios so the resulting pattern
    exhibits clear constructive and destructive interference fringes.
    """

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

    def __init__(
        self,
        num_sources: int = 6,
        dim: int = 512,
        wave_speed: float = 0.06,
        frequency_base: float = 0.12,
        drift: float = 0.004,
        seed: int | None = None,
        background: tuple[int, int, int] = (8, 14, 28),
        **_,
    ) -> None:
        self.num_sources = int(num_sources)
        self.dim = int(dim)
        self.wave_speed = float(wave_speed)
        self.frequency_base = float(frequency_base)
        self.drift = float(drift)
        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
        self.positions = self.rng.uniform(0.0, 1.0, size=(self.num_sources, 2)).astype(np.float32)
        self.phases = self.rng.uniform(0.0, np.pi * 2.0, size=self.num_sources).astype(np.float32)
        ratios = np.array([1.0, 1.5, 2.0, 2.5, 3.0], dtype=np.float32)
        ratio_idx = self.rng.integers(0, len(ratios), size=self.num_sources)
        self.freqs = (self.frequency_base * ratios[ratio_idx]).astype(np.float32)
        ys, xs = np.mgrid[0:self.dim, 0:self.dim].astype(np.float32)
        self.grid_x = xs
        self.grid_y = ys

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