2D FFT Texture Spectrum (WebGPU butterfly FFT)

Math essence

F = fft2(synthesised_image); F = fftshift(F); mask F with a soft bandpass; render log|F| with a dark-blue → cyan → yellow → white colormap, OR inverse-Fourier to the real-domain image, OR wrapped phase. Each step multiplies the spectrum by exp(i*2π/n_textures) so successive frames show smoothly varying phase.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/anadol_webgpu/fft2dTexture/reference.py

"""fft2dTexture — WebGPU 2D FFT (butterfly) magnitude spectrum.

The WebGPU analogue is the classic two-pass Cooley-Tukey butterfly
algorithm: pass k does a butterfly operation at each (x, y) pixel
combining input1[p] and weighted input2[q] where (p, q) are the two
input indices and weights are precomputed butterfly twiddles for
that stage.  The two passes (rows then columns, with a transpose in
between) yield the 2D FFT.  GLSL/WGSL implementations are described
in the GPU Gems series and the gamedev.net butterfly compute-shader
write-up.

Here we use ``np.fft.fft2`` directly — the WebGPU equivalent (which
is what the user would write for a WebGPU port) is captured in
``spec.json``.  We synthesise a 2D image (sine + circles + Gabor-like
texture) so the spectrum has interesting structure, then render
log-magnitude to the canvas, optionally with a circular low/high-pass
mask and shifted by fftshift so DC is centred.

Reference:
- https://www.gamedev.net/forums/topic/671549-ifft-compute-shader/
- https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm
- https://github.com/rreusser/glsl-fft  (GLSL butterfly FFT, ~paradigm)
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np


class FFT2DTexture:
    """2D FFT spectrum visualisation (numpy FFT, WebGPU butterfly target).

    Parameters
    ----------
    dim : int
        Side length of the square FFT (and image).
    n_textures : int
        Number of synthetic images whose spectra are blended into the
        canvas.  Each step rotates phase by 2π/n_textures.
    texture_seed : int
        RNG seed for the input image synthesis.
    high_pass : float
        Radius (in cycles) below which low-frequency content is damped.
    low_pass : float
        Radius above which high-frequency content is damped.  Set to
        ``np.inf`` for no high-frequency cut.
    brightness : float
        Multiplier on the log-magnitude before tone-map.
    domain : str
        ``"freq"`` (default) renders shifted log-amplitude in
        frequency space; ``"real"`` renders the IFFT real part
        (the reconstructed image); ``"phase"`` renders the
        wrapped phase.
    """

    family: ClassVar[str] = "anadol_webgpu"
    sketch: ClassVar[str] = "fft2dTexture"

    def __init__(