Hydra Video Synth (numpy port of Olivia Jack's Hydra)

Math essence

chain := source (mod)* ; source in {solid, gradient, osc, noise, shape, voronoi} ; mod in {rotate, scale, scroll, kaleid, pixelate, repeat, invert, posterize, thresh, color, brightness, contrast, luma, saturate, hue, add, diff, mult, blend, modulate, modulateRotate, modulateScale, modulatePixelate, modulateKaleid}. modulate(b, k): resample a at uv + k * (b.r, b.g). canvas <- trail*canvas + (1-trail)*bg + eval(chain).

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/live_coding_synth/HydraVisualSynth/reference.py

"""HydraVisualSynth — Olivia Jack's Hydra video synth in pure numpy.

A small, faithful subset of the Hydra API
(`https://hydra.ojack.xyz`) ported to numpy arrays so the same
chained-function live-coding aesthetics can be rendered from a
deterministic seed:

    osc(freq, sync, offset)        # source: visual oscillator (sin-based)
    noise(scale, offset)           # source: hash-based pseudo-Perlin
    shape(sides, radius, smooth)   # source: regular polygon SDF
    gradient(speed)                # source: 3-channel horizontal gradient
    solid(r, g, b)                 # source: solid colour
    voronoi(scale, speed, blend)   # source: Voronoi cells

    .rotate(theta)                 # geometry: rotate uv around centre
    .scale(s)                      # geometry: scale uv around centre
    .scroll(x, y)                  # geometry: pan uv
    .kaleid(n)                     # geometry: kaleidoscope fold
    .pixelate(p, smooth)           # geometry: posterise uv
    .repeat(x, y)                  # geometry: tile

    .modulate(src, amount)         # modulate: src.r → x warp,
                                   #            src.g → y warp
    .modulateRotate(src, amount)   # modulate: src.r,g → θ(x,y)
    .modulateScale(src, amount)    # modulate: src.r → scale warp
    .modulatePixelate(src, range_) # modulate: src.r → pixelate amount
    .modulateKaleid(src, range_)   # modulate: src.r → kaleid fold count
    .add(src), .diff(src), .mult(src), .blend(src)
                                   # blend: arithmetic on RGB

The composition `osc(40).modulate(noise().rotate(0.1), 0.5).out()`
becomes ``hydra.evaluate("osc(40).modulate(noise().rotate(0.1), 0.5)")``.

A built-in operator chain can be edited at run-time with
``set_chain("osc(10, 0.1).rotate(0.1).kaleid(4).modulate(noise(3), 0.5)")``
so a viewer can "live-code" by swapping the chain string and calling
``step()`` again. The chain is parsed into an AST, evaluated against
the source dictionary, and composited onto a low-trail canvas so the
visual keeps an evolving ghost of past frames.
"""

from __future__ import annotations

import re
from dataclasses import dataclass, field
from typing import Any, Callable, ClassVar

import numpy as np


# ---------------------------------------------------------------------------
# Sources
# ---------------------------------------------------------------------------

def src_solid(canvas: np.ndarray, r: float, g: float, b: float) -> np.ndarray:
    h, w, _ = canvas.shape
    out = np.zeros((h, w, 3), dtype=np.float32)
    out[..., 0] = np.float32(r)
    out[..., 1] = np.float32(g)
    out[..., 2] = np.float32(b)