Worley / Cellular Noise

Math essence

For a query point x with cell index p = floor(x) and fractional part f, scan the 3x3 neighbour cells (p+offset). Each cell hosts one feature point at hash(cell). Compute squared distances to these 9 points; keep F1 = min and F2 = second-min. Render via sqrt(F1) or sqrt(F2-F1) or by hashing F1's owner cell id. Multi-octave stacking scales frequency by 2 and amplitude by 0.55 per octave.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/hodgin_iquilezles/WorleyNoise/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


def _hash2(ix: np.ndarray, iy: np.ndarray, seed: int) -> tuple[np.ndarray, np.ndarray]:
    ix = ix.astype(np.uint64, copy=False)
    iy = iy.astype(np.uint64, copy=False)
    s = np.uint64(np.int64(seed) & 0xFFFFFFFF) * np.uint64(0x9E3779B97F4A7C15)
    s &= np.uint64(0xFFFFFFFFFFFFFFFF)
    h = (ix * np.uint64(0x27D4EB2F165667C5)) ^ (
        iy * np.uint64(0x165667B19E3779F9)
    ) ^ s
    h &= np.uint64(0xFFFFFFFFFFFFFFFF)
    h ^= h >> np.uint64(33)
    h *= np.uint64(0xFF51AFD7ED558CCD)
    h &= np.uint64(0xFFFFFFFFFFFFFFFF)
    h ^= h >> np.uint64(33)
    h *= np.uint64(0xC4CEB9FE1A85EC53)
    h &= np.uint64(0xFFFFFFFFFFFFFFFF)
    h ^= h >> np.uint64(33)
    a = (h & np.uint64(0xFFFFFFFF)).astype(np.float64) / 4294967296.0
    h ^= h >> np.uint64(27)
    b = (h & np.uint64(0xFFFFFFFF)).astype(np.float64) / 4294967296.0
    return a.astype(np.float32), b.astype(np.float32)


class WorleyNoise:
    """Worley / Cellular Noise — Inigo Quilez (iquilezles.org).

    Quilez's classic 2D Worley noise (a.k.a. cellular noise, Voronoi noise)
    partitions the plane into a regular grid of unit cells, places a single
    pseudo-random feature point inside each cell using his compact 2D hash,
    and at every query point ``x`` returns the distance to the closest
    feature point in the 3×3 cell neighborhood.

    The image is rendered by sampling the scalar field at every pixel and
    colouring by the F1 distance, the F2-F1 difference (cell edges), or a
    hash of the nearest cell id (Voronoi diagram).

    Reference code is from the canonical Quilez snippet:

        float voronoi( in vec2 x ) {
            ivec2 p = ivec2( floor( x ) );
            vec2  f = fract( x );
            float res = 8.0;
            for ( int j=-1; j<=1; j++ )
            for ( int i=-1; i<=1; i++ ) {
                ivec2 b = ivec2( i, j );
                vec2  r = vec2( b ) - f + hash2( p + b );
                float d = dot( r, r );
                res = min( res, d );
            }
            return sqrt( res );
        }

    (See also https://iquilezles.org/articles/voronoise/ for IQ's "voro-noise"
    extension.)