Chromie Squiggle (Snowfro / Cherniak — Squiggles)

Math essence

For each segment k in [0, num_segments): x_k = lerp(x_start, x_end, k/K); y_k = canvas_centre + amplitude * cos(2*pi*k*freq/K + phase + phase_drift[k]) + wobble[k]; colour_k = HSV->RGB(hue_start + hue_end_diff * k/K + hue_noise * noise[k]). The Type determines how the segment is rasterised: Normal/Slinky/Bold/Pipe draw thick polylines; Fuzzy stamps Gaussian-jittered dots; Ribbed draws the segment then paints a 1-px gap every N segments.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/art_blocks/CherniakSquiggles/reference.py

"""CherniakSquiggles — "Squiggles" inspired by Snowfro's Chromie Squiggle.

This is the spectral, harmonic undulating-line family of generative
artworks descended from Erick Calderon's (Snowfro's) *Chromie Squiggle*
(Art Blocks #0, November 2020) — the on-chain generative-art collection
that launched the Art Blocks platform itself.  The Squiggle is a single
undulating line whose segments cycle through a curated palette of
colours; each piece is determined by a hash string that controls the
segment count, the colour spread, the start/end hues, and other
parameters.

The Squiggle's formal language (per NiftyFifty / SquiggleDAO 2025
documentation) has six 'Types':
    - **Normal** — the default undulating line.
    - **Slinky** — tightly coiled spring.
    - **Fuzzy** — line is replaced with small dots (pointillism).
    - **Ribbed** — segmented with breaks that produce a ridged texture.
    - **Bold** — fattened line (chunky ribbon).
    - **Pipe** — solid beam (Slinky grounded).

And six 'Hyper' variants (chromatic boost with color_spread >=10x).
The complete taxonomy:
    - 6,195 Normals, 1,145 Slinkies, 1,074 Fuzzies, 768 Ribbed,
      443 Bolds, 181 Pipes; 128 Hyper variants (Hyper Normal = 104,
      Hyper Slinky = 13, Hyper Bold = 7, Hyper Pipe = 4).

This implementation builds a generic Squiggle-family line that uses
the canonical undulating-curve kernel:

    For each segment k in [0, num_segments):
        x_k = canvas.x_start + (k / num_segments) * canvas.width
        y_k = canvas.centre_y + amp * cos(2*pi*k*freq + phase)
        colour = lerp(hue_start, hue_end, k/num_segments)

The amplitude / frequency / phase are perturbed per segment by
hash-derived noise so the curve has the gentle wobble of canonical
Squiggles.  Hyper mode is achieved by using the full HSL spectrum
spread (colour_spread >= 0.9) and a small wobble (high curve_freq).

This file is named CherniakSquiggles per the project brief but the
Squiggle kernel is canonical Snowfro.  Cherniak's connection is that
Squiggles are referenced as the second project he saw when he first
discovered Art Blocks (alongside Genesis), inspiring his own algorithmic
practice — but the actual algorithm here is the Squiggle kernel,
which Snowfro authored.

Reference:
- https://www.artblocks.io/articles/chromie-squiggle-algorithm-guide
- https://www.artblocks.io/collection/chromie-squiggle-by-snowfro
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np


# ---------------------------------------------------------------------------
def _hsv_to_rgb_vec(h: np.ndarray, s: float = 0.85, v: float = 0.95) -> np.ndarray:
    """Vectorised HSV->RGB. h in [0, 1]."""