Perlin Noise Flow Field

Math essence

For each particle (x, y): theta = 2*pi * perlin(x*scale, y*scale, ...) [with octaves summed at half amplitude each]. Step: (x', y') = (x, y) + (cos theta, sin theta) * speed. Trail: canvas[p] = (1 - alpha) * canvas[p] + alpha * ink. Per-pixel Perlin: shuffled 64-permutation + random unit gradients + Ken-Perlin fade t^3(t(6t - 15) + 10).

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/shiffman_pearson_textbook/perlinFlowField/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


def _fade(t: np.ndarray) -> np.ndarray:
    return t * t * t * (t * (t * 6 - 15) + 10)


def _make_perlin(rng: np.random.Generator, size: int):
    perm = np.arange(size, dtype=np.int32)
    rng.shuffle(perm)
    perm = np.concatenate([perm, perm])
    angles = rng.uniform(0.0, 2.0 * np.pi, size=(size + 1, size + 1))
    grads = np.stack([np.cos(angles), np.sin(angles)], axis=-1).astype(np.float32)
    return perm, grads


def perlin2(x: np.ndarray, y: np.ndarray, perm: np.ndarray, grads: np.ndarray) -> np.ndarray:
    s = grads.shape[0] - 1
    x = np.mod(x, s).astype(np.float32)
    y = np.mod(y, s).astype(np.float32)
    xi = x.astype(np.int32)
    yi = y.astype(np.int32)
    xf = x - xi
    yf = y - yi
    u = _fade(xf)
    v = _fade(yf)
    x1 = np.clip(xi + 1, 0, s)
    y1 = np.clip(yi + 1, 0, s)
    g00 = grads[yi, xi]
    g10 = grads[yi, x1]
    g01 = grads[y1, xi]
    g11 = grads[y1, x1]
    d00 = xf * g00[..., 0] + yf * g00[..., 1]
    d10 = (xf - 1) * g10[..., 0] + yf * g10[..., 1]
    d01 = xf * g01[..., 0] + (yf - 1) * g01[..., 1]
    d11 = (xf - 1) * g11[..., 0] + (yf - 1) * g11[..., 1]
    nx0 = d00 + u * (d10 - d00)
    nx1 = d01 + u * (d11 - d01)
    return nx0 + v * (nx1 - nx0)


class PerlinFlowField:
    """Perlin-noise flow field following Shiffman, Nature of Code Ch. 6 / Coding Train.

    A scalar noise field n(x, y) is sampled on an integer grid of step size
    ``cell_size``; the per-cell heading is ``theta = 2*pi * n``. Particles emit
    at random positions, sample the heading at their current cell by bilinear
    interpolation, and step a small velocity. Trail segments are accumulated
    onto the canvas with a low-alpha blend. When a particle leaves the canvas
    it respawns at a fresh random position. The step(n) call advances the
    simulation n ticks; render() returns the running canvas.

    The flow-field is the canonical Nature of Code example: Perlin's gradient
    noise (1985) drives a non-divergent, smoothly varying 2-D vector field
    that produces the classic organic ink-trail look.
    """