Hobbs QLIQUE (Tyler Hobbs — QQL dense-streamline tangle)

Math essence

Build G[i, j] = 2*pi * P(i*s, j*s) over a (rows, cols) grid with margin ~60%. Spawn N agents uniformly in the canvas+margin box. At each step: x_{t+1} = x_t + L*cos(G[floor(x), floor(y)]); y_{t+1} = y_t + L*sin(G[floor(x), floor(y)]); h(t) = h0 + omega*t (mod 1). Each segment painted with alpha 0.05 on a cream background, with the 3x3 Gaussian splat narrower than HobbsFlowField to keep the higher-density weave readable.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/hobbs_cherniak_penne_deep/HobbsQLIQUE/reference.py

"""HobbsQLIQUE — Tyler Hobbs dense-streamline tangle of curves.

Inspired by the "QLIQUE" / "QL-style" aesthetic that emerged from
Tyler Hobbs's 2022 QQL release with Dandelion Mane: a dense, chaotic
tangle of curves where every curve is a streamline through a Perlin
flow field, and the whole field is filled with N agents each drawing
K path steps.

Hobbs's own description (LACMA, 2024):

    "QQL and Fidenza share one core component, which is an
    underlying flow field that structures most of the image. ...
    QQL takes a lot of care to establish larger structures that
    interact with the flow fields in various ways that tend to have
    a lot of emergent possibility."

The QLIQUE kernel we implement:

    1. Build a Perlin angle grid covering the canvas plus a wide
       margin (so strands that wander out can curve back in).
    2. Spawn N agents, each at a random starting position, each
       with a small "shape vector" of K angles drawn from the seed.
    3. Each agent steps along the local field angle. The agent's
       hue cycles slightly with each step (the "QL color band"
       technique that gives QQL its translucent, ribbon-like look).
    4. Each segment is deposited with a low alpha, building up the
       dense tangle over a fixed number of steps.

This is much denser than HobbsFlowField (1500 agents, 1500 steps):
~2000-3000 agents, each completing 800-1500 path steps, ~2-3 million
segments total — the "chaotic single image" of the QL aesthetic.

Reference:
- https://www.tylerxhobbs.com/words/qql
- https://qql.art
- https://unframed.lacma.org/2024/06/05/remembrance-things-future-conversation-tyler-hobbs-artist-experimenting-blockchain
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np


# ---------------------------------------------------------------------------
# Vectorised 2D Perlin noise (the kernel Hobbs uses to initialise the field)
# ---------------------------------------------------------------------------
def _fade(t: np.ndarray) -> np.ndarray:
    return t * t * t * (t * (t * 6 - 15) + 10)


def _perlin2(perm: np.ndarray, x: np.ndarray, y: np.ndarray) -> np.ndarray:
    xi = np.floor(x).astype(np.int64) & 255
    yi = np.floor(y).astype(np.int64) & 255
    xf = x - np.floor(x)
    yf = y - np.floor(y)
    u = _fade(xf)
    v = _fade(yf)

    dirs = np.array(