Perlin Streamlines

Math essence

For each particle (x, y) compute theta = 2*pi * perlin(x*scale, y*scale) (summed across octaves). Position update: (x', y') = (x, y) + cos(theta), sin(theta) * noise_speed. Per-pixel trail blend: canvas = (1-a)*canvas + a*ink on the segment endpoints.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/reas_processing/perlinStreamlines/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 _perlin2(rng: np.random.Generator, grid_w: int, grid_h: int):
    perm = np.arange(256, dtype=np.int32)
    rng.shuffle(perm)
    perm = np.concatenate([perm, perm])
    angles = rng.uniform(0.0, 2.0 * np.pi, size=(grid_h + 1, grid_w + 1))
    grads = np.stack([np.cos(angles), np.sin(angles)], axis=-1).astype(np.float32)
    return perm, grads


def perlin(x: np.ndarray, y: np.ndarray, perm: np.ndarray, grads: np.ndarray) -> np.ndarray:
    gw = grads.shape[1] - 1
    gh = grads.shape[0] - 1
    x = np.mod(x, gw)
    y = np.mod(y, gh)
    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, gw)
    y1 = np.clip(yi + 1, 0, gh)
    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 PerlinStreamlines:
    """Streamlines in a Perlin noise field.

    A 2-D vector field is constructed from the gradient of one or two
    octaves of Perlin noise. Particles emit from random positions and
    follow the field, depositing semi-transparent trails. step(n)
    advances the simulation and accumulates onto the canvas. The
    rendering is the canonical 'flow field' popularised by Reas and the
    Processing community.
    """

    family: ClassVar[str] = "reas_processing"
    sketch: ClassVar[str] = "perlinStreamlines"