Hobbs Color-Field Overlay (Tyler Hobbs compositional method)

Math essence

Build two fields on the canvas: an angle field G = 2*pi * P_flow and a colour field C = (H, S, V) all derived from independent Perlin noises, then Gaussian-blur C with sigma. Spawn N segments at random positions. For each segment: walk K steps along G to produce a polyline. At the polyline's midpoint m, sample (R, G, B) from C and brightness = 0.299 R + 0.587 G + 0.114 B. If brightness < threshold, skip the segment. Else draw the polyline with colour C(m) and alpha proportional to (brightness - threshold) / (1 - threshold).

Parameters

Reference

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

"""HobbsColorFieldOverlay — Tyler Hobbs compositional method.

Hobbs's compositional method of choice in *Incomplete Control*,
*Fidenza*, and many of his 2020 essays is to combine TWO
independent fields:

    1. A Perlin flow field that drives the *trajectory* of a set
       of line segments (the "structural" layer).
    2. A Gaussian-blurred colour field that drives the *colour*
       and *opacity* of those segments (the "expressive" layer).

The trick is the third step: the colour field's brightness is
used as a *mask* on the line segments, so segments that fall in
a dark patch of the colour field are not drawn at all.  The
result is a soft, painterly composition where the underlying
flow field's structure is visible only where the colour field
permits it.

Hobbs describes this exact approach in his 2020 "Flow Fields"
essay under "Mixing With Other Techniques":

    "You can insert objects that distort the grid around them.
    With Ectogenesis, I approximated how fluid would move and
    wrap around an object."

The kernel we implement:

    1. Build a Perlin angle grid covering the canvas plus a
       margin (the structural field).
    2. Build a second Perlin field of (R, G, B) values (the
       colour field).  Gaussian-blur this field with a
       configurable sigma to soften it.
    3. Spawn N line segments.  Each segment is a polyline
       through K points, each point advanced by the structural
       field's angle.
    4. For each segment, the colour is sampled from the colour
       field at the segment's midpoint, and the segment is drawn
       only if the colour field's brightness at that point is
       above a threshold.  The alpha is proportional to the
       brightness.
    5. The output is a flow-field drawing with the colour field
       acting as a soft mask.

Reference:
- https://www.tylerxhobbs.com/words/flow-fields
- https://www.tylerxhobbs.com/works/ectogenesis
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np

# Re-use the perlin kernel from HobbsFlowField (we redefine a small
# 2D Perlin here to keep this formula self-contained).
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: