Hobbs Flow Field (Tyler Hobbs — Incomplete Control / Fidenza)

Math essence

Build G[i, j] = 2*pi * P(i*s, j*s) over a (rows, cols) grid with margin >=50%. Spawn N agents with uniform-random starting positions. 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)]). Each segment painted with alpha ~0.06 onto a neutral canvas, accumulating into the dense, non-crossing trail that defines the Hobbs aesthetic.

Parameters

Reference

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

"""HobbsFlowField — Tyler Hobbs perlin-noise flow-field agent simulation.

Inspired by Tyler Hobbs' *Incomplete Control* (Bright Moments / Art Blocks
2021) and *Fidenza* (Art Blocks 2021), the defining works of the modern
Art-Blocks era.  Hobbs' canonical "flow field" algorithm is described in
his 2020 essay "Flow Fields" (https://www.tylerxhobbs.com/words/flow-fields):

    "Flow fields are based around a grid. Roughly speaking, this grid
    covers the whole image/canvas. At each point in the grid, you store
    an angle. ... When you initialize the grid, you need to pick a
    resolution. ... About 90% of the time, people use Perlin noise to
    initialize the vectors."

The algorithm is:

    1. Build a grid G of floating-point angles covering the canvas plus
       a generous margin (so agents that wander out can curve back in).
    2. Initialize each cell with the angle implied by Perlin noise:
           angle(c, r) = 2*pi * noise(c * scale, r * scale)
       This is the "continuous distortion" case that gives non-crossing,
       organic curves — Hobbs' signature.
    3. Spawn N agents at uniformly-random starting positions.
    4. Each step, every agent advances along its current cell's angle
       by `step_length` pixels and deposits a coloured segment.  With
       `low_alpha` (e.g. 0.05–0.10) and ~1500 steps the canvas fills.

Here we collapse the implementation to a numpy analogue that uses the
same construction pattern as Hobbs' pseudocode: vectorised Perlin noise
gives the grid, and one matrix multiply + cumulative sum per step
advances all N agents simultaneously.  The HSL-cycling colour scheme
follows Hobbs' "Incomplete Control" palette — soft, neutral backgrounds
with occasional vivid colour rectangles, painted as a low-alpha trail.

Reference:
- https://www.tylerxhobbs.com/words/flow-fields
- https://www.tylerxhobbs.com/words/fidenza
- https://www.tylerxhobbs.com/works/2021/incomplete-control
- https://www.artblocks.io/collection/fidenza-by-tyler-hobbs
"""
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:
    # Perlin's quintic fade: 6t^5 - 15t^4 + 10t^3
    return t * t * t * (t * (t * 6 - 15) + 10)


def _perlin2(perm: np.ndarray, x: np.ndarray, y: np.ndarray) -> np.ndarray:
    """Vectorised 2D Perlin noise. Returns values roughly in [-1, 1]."""
    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)