Glitch (Mario Klingemann — glitch-print aesthetic)

Math essence

Substrate S ∈ [0,1]^{H×W×3}. Each step: pick affine M (rot+scale+shear), translation t; sample canvas coords back through M^{-1} into S with bilinear interpolation → warped W; rotate colour via random orthogonal R ∈ R^{3×3}; alpha-blend W·R over the canvas at opacity α; with probability p_slice also paste a horizontal or vertical hard band of S directly onto the canvas.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/ml_artists/KlingemannGlitch/reference.py

"""KlingemannGlitch — Mario Klingemann glitch-art kernel.

Mario Klingemann's practice has long embraced glitch and failure modes
as expressive surface: in the *Memories of Passersby* series the GAN
output is "occasionally struggling to proceed" and visibly distorts,
and across his glitch work he amplifies the artefacts of digital
processing into the subject matter itself.  This is the algorithmic
backbone of that aesthetic, reduced to a numpy primitive:

  1. Build a synthetic noise substrate (per-pixel RGB).
  2. Apply a random affine warp (rotation + scale + shear + translate).
  3. Apply a per-channel colour shift (random rotation in RGB space).
  4. Alpha-blend the warped/shifted substrate over the canvas with
     controllable transparency and edge-cut (rectangular slice
     "tears" with hard horizontal/vertical seams).
  5. Repeat — each step introduces a new glitch event.

The result is a slow accumulation of torn, colour-shifted, geometrically
warped noise patches on top of a black canvas, in the spirit of
Klingemann's glitch prints.

References:
- https://aiartists.org/mario-klingemann
- http://quasimondo.com/
- "Memories of Passersby I" — Sotheby's / Klingemann, 2018
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np


def _bilinear_sample(img: np.ndarray, xs: np.ndarray, ys: np.ndarray) -> np.ndarray:
    """Sample img at fractional (xs, ys) with bilinear interpolation.

    img: (H, W, C) float32.  xs, ys: (H', W') float32 in [0, W-1]/[0, H-1].
    Returns (H', W', C) float32, with edge-clamp.
    """
    H, W, C = img.shape
    x0 = np.floor(xs).astype(np.int32)
    y0 = np.floor(ys).astype(np.int32)
    x1 = x0 + 1
    y1 = y0 + 1
    x0 = np.clip(x0, 0, W - 1)
    x1 = np.clip(x1, 0, W - 1)
    y0 = np.clip(y0, 0, H - 1)
    y1 = np.clip(y1, 0, H - 1)
    fx = (xs - np.floor(xs)).astype(np.float32)
    fy = (ys - np.floor(ys)).astype(np.float32)
    fx = fx[..., None]
    fy = fy[..., None]
    Ia = img[y0, x0]
    Ib = img[y0, x1]
    Ic = img[y1, x0]
    Id = img[y1, x1]
    top = Ia * (1.0 - fx) + Ib * fx
    bot = Ic * (1.0 - fx) + Id * fx
    return top * (1.0 - fy) + bot * fy