Penne Imprecise Balance (Aaron Penne stacked-blocks column)

Math essence

For each block i in 0..N-1: draw a filled rectangle of width W and height H at centre (cx, y0 + i*(H+gap)), rotated by theta_i radians. theta_i is the cumulative sum of a Perlin-noise-driven offset, where the per-block offset is value_noise_1d(i) * max_rotation. If |sum(theta_i)| > balance_threshold, the column collapses: amplifications of (|sum| - threshold) are added to the rotation, producing the cascading topple.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/hobbs_cherniak_penne_deep/PenneImpreciseBalance/reference.py

"""PenneImpreciseBalance — Aaron Penne stacked-blocks column.

A direct homage to Aaron Penne's *Imprecise Balance* (2021):
a column of stacked rectangular forms where each block is
rotated by a seed-derived angle.  The result is a tall,
slightly-leaning tower that looks like a Jenga stack that
has been pushed just enough to feel precarious.

Penne's *Apparitions* essay (2021) describes the broader
visual idiom:

    "I had been working with this layered form for several
    years. It just holds so much mystery to me. It is a series
    of lines stacked, but it brings dynamic 3D movement to a
    2D rendering with the right parameter space and aesthetic.
    By tweaking parameters, it creates very different feelings,
    from the comfort of a silk sheet to the rugged adventure
    of canyons."

The *Imprecise Balance* kernel we implement:

    1. A column of N rectangular blocks is stacked vertically,
       each block of width w and height h.
    2. Each block i has its own rotation theta_i (in degrees),
       drawn from a Perlin-noise-driven field so the rotations
       feel "deliberately imprecise" rather than random.
    3. The column's centre-of-mass is computed as the rotation-
       weighted average of each block's centre; if the column
       exceeds a "balance threshold", the column collapses
       (the rotation cascade is amplified).
    4. Each block is filled with a colour drawn from a muted
       Penne-style palette (low-saturation, mid-brightness).
    5. A subtle horizontal noise is overlaid on each block to
       give it a hand-drawn / noisy feel (the Penne aesthetic
       of "algorithm + organic imperfection").

The visual is a tall, slightly-leaning stack of rectangles
that feels "imprecisely balanced" — the canonical Penne
silk-sheet-to-canyon spectrum, calibrated towards the
precarious end.

Reference:
- https://www.aaronpenne.io
- https://artynft.io/interviews/aaron-penne/  (Penne interview)
- Penne's broader *Apparitions* essay:
  https://www.artxcode.io/journal/aaron-penne-apparitions-on-art-blocks
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np


def _value_noise_1d(rng: np.random.Generator, n: int, grid: int) -> np.ndarray:
    """Simple value noise in 1D, like Penne's noise field."""
    g = rng.normal(0, 1, size=grid + 1)
    xs = np.linspace(0, grid, n)
    xi = np.floor(xs).astype(np.int64)
    xf = xs - xi