Hobbs Watercolor Edge (Tyler Hobbs — Soft Textures / Watercolor)

Math essence

For each layer L: (1) build a deformed copy of the base polygon P via D iterations of midpoint Gaussian jitter (sigma = jitter_frac * segment_length); (2) rasterise the deformed polygon to a mask; (3) blur the mask with a Gaussian of sigma blur_sigma px; (4) compute the Sobel magnitude of the luminance and threshold by edge_threshold; (5) tint the thresholded edge by the layer's palette colour; (6) alpha-blend onto the canvas with edge_alpha. Stack num_layers such layers. The Sobel magnitude effectively extracts the polygon boundary as a 1-px ink line.

Parameters

Reference

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

"""HobbsWatercolorEdge — Tyler Hobbs' watercolor "soft-edge" stack.

Inspired by Tyler Hobbs' *A Guide to Simulating Watercolor Paint with
Generative Art* (2017) and his subsequent watercolor series.  Hobbs'
recipe, quoted directly from his essay:

    "The technique to simulate watercolor in generative art consists of
    stacking lots of nearly transparent layers on top of each other.
    To create the watercolor-like appearance of a gradual fade out,
    the layers need to have a lot of variation in their shape.

    The core of the watercolor technique is a recursive polygon
    deformation algorithm:
        1. For each line A -> C in the polygon, find the midpoint B.
           From a Gaussian distribution centred on B, pick a new point B'.
        2. Update the polygon, replacing A -> C with two lines A -> B'
           and B' -> C.
        3. If we haven't hit our max recursion depth, repeat from
           step 1, splitting the child lines."

Hobbs runs the input through ~7 deformation rounds to make the "base
polygon", then for every layer (30–100 layers total) he starts from
that base and runs another 4–5 rounds, drawing each with ~4% alpha.
The result is the soft, ink-bleeding look of wet pigment on paper.

This implementation condenses Hobbs' "many translucent layers" recipe
into a single, fast numpy pipeline that captures the essential
visual signature:

    1. Build a base noise-driven substrate (Hobbs' underlying form —
       in his essay a polygon, here a Perlin-noise tinted field).
    2. Apply a sequence of small "translucent layer" passes: each pass
       is a deformed copy of the substrate plus a Gaussian blur and
       a Sobel edge detector to extract the ink-bleed lines, then
       alpha-blended onto the canvas.
    3. The cumulative effect after `num_layers` passes is the
       characteristic watercolor edge — soft, broken, organic.

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

from typing import ClassVar

import numpy as np


# ---------------------------------------------------------------------------
# Local helpers: 2D convolution, Gaussian kernel, Sobel edge detector
# ---------------------------------------------------------------------------
def _gaussian_kernel(size: int, sigma: float) -> np.ndarray:
    """Return a normalised (size x size) Gaussian kernel."""
    ax = np.arange(size) - (size - 1) / 2.0
    xx, yy = np.meshgrid(ax, ax)
    g = np.exp(-(xx * xx + yy * yy) / (2.0 * sigma * sigma))
    return (g / g.sum()).astype(np.float32)