Hobbs Watercolor Blob

Math essence

A small set of large, overlapping radial splats are drawn with translucent pigments. Each splat has a position, a soft Gaussian falloff, and a sampled color from a curated palette.

Parameters

Reference

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

"""HobbsWatercolorBlob — Tyler Hobbs' layered watercolor "blobs".

A second implementation of Tyler Hobbs' 2017 watercolor recipe,
distinct from HobbsWatercolorEdge (which produces watercolor ink
edges via Sobel detection).  HobbsWatercolorBlob instead produces
**filled watercolor blobs** by stacking many translucent,
noise-deformed filled polygons — the technique Hobbs used in his
*Isohedral* series (2017) and the core of his watercolor aesthetic.

Hobbs's recipe (2017 essay):

    "The technique to simulate watercolor in generative art consists of
    stacking lots of nearly transparent layers on top of each other. ...
    The core of the watercolor technique is a recursive polygon
    deformation algorithm. ... Depending on the variation in your
    Gaussian distribution and the recursion depth, this will produce a
    polygon with jagged, detailed edges."

For each blob:
    1. Choose an N-gon centred on a random canvas position.
    2. Run ~7 rounds of recursive polygon deformation (midpoint
       Gaussian jitter with sigma proportional to segment length).
    3. Rasterise the deformed polygon to a mask.
    4. Stamp the mask at low alpha (~4%) with a per-layer tint.
    5. Repeat for `num_layers` layers, optionally interleaving
       different colours to produce blended watercolor regions.

The implementation here uses ~30–100 layers (Hobbs' range) at
4% alpha each, producing the soft pigment-on-paper look of his
*Isohedral XI* and *Linear II* works.

Reference:
- https://www.tylerxhobbs.com/words/a-guide-to-simulating-watercolor-paint-with-generative-art
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np


def _deform_polygon(
    pts: np.ndarray, depth: int, sigma_frac: float, rng: np.random.Generator
) -> np.ndarray:
    """Hobbs' recursive polygon deformation: midpoint Gaussian jitter,
    repeated `depth` times.  Output has N * 2^depth vertices.
    """
    out = pts.astype(np.float64).copy()
    for _ in range(int(depth)):
        n = out.shape[0]
        mids = np.empty((n, 2), dtype=np.float64)
        for i in range(n):
            x0, y0 = out[i]
            x1, y1 = out[(i + 1) % n]
            mx, my = 0.5 * (x0 + x1), 0.5 * (y0 + y1)
            seg_len = np.hypot(x1 - x0, y1 - y0)
            sigma = sigma_frac * seg_len
            mids[i, 0] = mx + rng.normal(0, sigma)
            mids[i, 1] = my + rng.normal(0, sigma)
        new = np.empty((2 * n, 2), dtype=np.float64)