Strudel 16-Step Pattern Visualiser (4x4 grid of sample-typed shapes)

Math essence

parse(pattern) -> steps[16] of (sample, variant). For each step s_i in 0..15: (r, c) = (s_i // 4, s_i % 4); cx,cy = margin + c*cs + cs*0.5. shape(sample): bd -> disc(0.30*cs); sn -> square(0.85*0.30*cs); hh -> X-mark(0.30*cs); cp -> diamond(0.30*cs); bass/lead -> bar(0.30*cs, 0.6 + 0.4*v/8); ~ -> dot(0.04*cs). active_step = (tick // 4) % 16; draw cursor rectangle in (250, 220, 140). canvas[y0:y1,x0:x1] = max(canvas, ink).

Parameters

Reference

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

"""StrudelVisualizer — Strudel's 16-step pattern as a 4x4 grid of shapes.

Strudel (https://strudel.cc) is the JavaScript port of TidalCycles
by Felix Roos and the tidalcycles/strudel team — the same
mini-notation (``bd*4, hh*8, ~ sn``) but running live in the
browser. Strudel's signature visualisation is a 4×4 (16-step)
grid of "events" — each cell shows the sample name, an icon
(Drum, Note, Chord, Rest), and a brightness driven by the
event's `gain` / `velocity`.

This module renders the same 4×4 grid in pure numpy:

* parses a Strudel-style mini-notation pattern (full Tidal
  subset — `bd`, `~`, `[ ]`, `*N`, `/N`, `:N`, `< >`, `,`);
* flattens it to exactly 16 events per cycle (the canonical
  16-step Strudel cycle);
* draws each event as a small shape in a 4×4 grid:
  - kick / bd       → red filled disc + glow ring
  - snare / sn      → yellow square + glow ring
  - hi-hat / hh     → cyan X-mark
  - clap / cp       → violet diamond
  - bass note       → green bar (size = note value)
  - chord           → 3-stacked triangle
  - rest (`~`)      → empty cell with thin gridline
  - other           → small white ring

A playback cursor (the active step) sweeps column-by-column on
a per-cycle clock — the same "playhead" you see in a Strudel
REPL. Per-step gain modulates each cell's brightness.
"""

from __future__ import annotations

import re
from dataclasses import dataclass
from typing import ClassVar

import numpy as np


_DRUM_HUE: dict[str, tuple[int, int, int]] = {
    "bd": (240, 70, 80),
    "sd": (250, 220, 110),
    "sn": (250, 220, 110),
    "hh": (130, 230, 250),
    "cp": (180, 120, 250),
    "lt": (180, 250, 180),
    "mt": (250, 180, 200),
    "ht": (250, 130, 80),
    "cb": (250, 130, 80),
    "rim": (210, 200, 240),
    "arpy": (140, 220, 180),
    "arps": (140, 220, 180),
    "bass": (160, 250, 200),
    "lead": (255, 200, 240),
    "pad": (130, 180, 255),
    "stab": (255, 220, 130),
    "chord": (255, 220, 130),
}