File modularization

image_postprocess/utils/__init__.py

@@ -0,0 +1,18 @@
+from .autowb import auto_white_balance_ref
+from .clahe import clahe_color_correction
+from .color_lut import load_lut, apply_lut
+from .exif import remove_exif_pil
+from .fourier_pipeline import fourier_match_spectrum
+from .gaussian_noise import add_gaussian_noise
+from .perturbation import randomized_perturbation
+
+__all__ = [
+    'auto_white_balance_ref',
+    'clahe_color_correction',
+    'load_lut',
+    'apply_lut',
+    'remove_exif_pil',
+    'fourier_match_spectrum',
+    'add_gaussian_noise',
+    'randomized_perturbation'
+]

image_postprocess/utils/autowb.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+def auto_white_balance_ref(img_arr: np.ndarray, ref_img_arr: np.ndarray = None) -> np.ndarray:
+    """
+    Auto white-balance correction using a reference image.
+    If ref_img_arr is None, uses a gray-world assumption instead.
+    """
+    img = img_arr.astype(np.float32)
+
+    if ref_img_arr is not None:
+        ref = ref_img_arr.astype(np.float32)
+        ref_mean = ref.reshape(-1, 3).mean(axis=0)
+    else:
+        # Gray-world assumption: target is neutral gray
+        ref_mean = np.array([128.0, 128.0, 128.0], dtype=np.float32)
+
+    img_mean = img.reshape(-1, 3).mean(axis=0)
+
+    # Avoid divide-by-zero
+    eps = 1e-6
+    scale = (ref_mean + eps) / (img_mean + eps)
+
+    corrected = img * scale
+    corrected = np.clip(corrected, 0, 255).astype(np.uint8)
+
+    return corrected

image_postprocess/utils/clahe.py

@@ -0,0 +1,28 @@
+import numpy as np
+from PIL import Image, ImageOps
+
+try:
+    import cv2
+    _HAS_CV2 = True
+except Exception:
+    cv2 = None
+    _HAS_CV2 = False
+
+def clahe_color_correction(img_arr: np.ndarray, clip_limit=2.0, tile_grid_size=(8,8)) -> np.ndarray:
+    if _HAS_CV2:
+        lab = cv2.cvtColor(img_arr, cv2.COLOR_RGB2LAB)
+        l, a, b = cv2.split(lab)
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)
+        l2 = clahe.apply(l)
+        lab2 = cv2.merge((l2, a, b))
+        out = cv2.cvtColor(lab2, cv2.COLOR_LAB2RGB)
+        return out
+    else:
+        pil = Image.fromarray(img_arr)
+        channels = pil.split()
+        new_ch = []
+        for ch in channels:
+            eq = ImageOps.equalize(ch)
+            new_ch.append(eq)
+        merged = Image.merge('RGB', new_ch)
+        return np.array(merged)

image_postprocess/utils/color_lut.py

@@ -0,0 +1,224 @@
+import numpy as np
+import re, os
+from PIL import Image
+
+def apply_1d_lut(img_arr: np.ndarray, lut: np.ndarray, strength: float = 1.0) -> np.ndarray:
+    """
+    Apply a 1D LUT to an image.
+    - img_arr: HxWx3 uint8
+    - lut: either shape (256,) (applied equally to all channels), (256,3) (per-channel),
+           or (N,) / (N,3) (interpolated across [0..255])
+    - strength: 0..1 blending between original and LUT result
+    Returns uint8 array.
+    """
+    if img_arr.ndim != 3 or img_arr.shape[2] != 3:
+        raise ValueError("apply_1d_lut expects an HxWx3 image array")
+
+    # Normalize indices 0..255
+    arr = img_arr.astype(np.float32)
+    # Prepare LUT as float in 0..255 range if necessary
+    lut_arr = np.array(lut, dtype=np.float32)
+
+    # If single channel LUT (N,) expand to three channels
+    if lut_arr.ndim == 1:
+        lut_arr = np.stack([lut_arr, lut_arr, lut_arr], axis=1)  # (N,3)
+
+    if lut_arr.shape[1] != 3:
+        raise ValueError("1D LUT must have shape (N,) or (N,3)")
+
+    # Build index positions in source LUT space (0..255)
+    N = lut_arr.shape[0]
+    src_positions = np.linspace(0, 255, N)
+
+    # Flatten and interpolate per channel
+    out = np.empty_like(arr)
+    for c in range(3):
+        channel = arr[..., c].ravel()
+        mapped = np.interp(channel, src_positions, lut_arr[:, c])
+        out[..., c] = mapped.reshape(arr.shape[0], arr.shape[1])
+
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    if strength >= 1.0:
+        return out
+    else:
+        blended = ((1.0 - strength) * img_arr.astype(np.float32) + strength * out.astype(np.float32))
+        return np.clip(blended, 0, 255).astype(np.uint8)
+
+def _trilinear_sample_lut(img_float: np.ndarray, lut: np.ndarray) -> np.ndarray:
+    """
+    Vectorized trilinear sampling of 3D LUT.
+    - img_float: HxWx3 floats in [0,1]
+    - lut: SxSxS x 3 floats in [0,1]
+    Returns HxWx3 floats in [0,1]
+    """
+    S = lut.shape[0]
+    if lut.shape[0] != lut.shape[1] or lut.shape[1] != lut.shape[2]:
+        raise ValueError("3D LUT must be cubic (SxSxSx3)")
+
+    # map [0,1] -> [0, S-1]
+    idx = img_float * (S - 1)
+    r_idx = idx[..., 0]
+    g_idx = idx[..., 1]
+    b_idx = idx[..., 2]
+
+    r0 = np.floor(r_idx).astype(np.int32)
+    g0 = np.floor(g_idx).astype(np.int32)
+    b0 = np.floor(b_idx).astype(np.int32)
+
+    r1 = np.clip(r0 + 1, 0, S - 1)
+    g1 = np.clip(g0 + 1, 0, S - 1)
+    b1 = np.clip(b0 + 1, 0, S - 1)
+
+    dr = (r_idx - r0)[..., None]
+    dg = (g_idx - g0)[..., None]
+    db = (b_idx - b0)[..., None]
+
+    # gather 8 corners: c000 ... c111
+    c000 = lut[r0, g0, b0]
+    c001 = lut[r0, g0, b1]
+    c010 = lut[r0, g1, b0]
+    c011 = lut[r0, g1, b1]
+    c100 = lut[r1, g0, b0]
+    c101 = lut[r1, g0, b1]
+    c110 = lut[r1, g1, b0]
+    c111 = lut[r1, g1, b1]
+
+    # interpolate along b
+    c00 = c000 * (1 - db) + c001 * db
+    c01 = c010 * (1 - db) + c011 * db
+    c10 = c100 * (1 - db) + c101 * db
+    c11 = c110 * (1 - db) + c111 * db
+
+    # interpolate along g
+    c0 = c00 * (1 - dg) + c01 * dg
+    c1 = c10 * (1 - dg) + c11 * dg
+
+    # interpolate along r
+    c = c0 * (1 - dr) + c1 * dr
+
+    return c  # float in same range as lut (expected [0,1])
+
+def apply_3d_lut(img_arr: np.ndarray, lut3d: np.ndarray, strength: float = 1.0) -> np.ndarray:
+    """
+    Apply a 3D LUT to the image.
+    - img_arr: HxWx3 uint8
+    - lut3d: SxSxSx3 float (expected range 0..1)
+    - strength: blending 0..1
+    Returns uint8 image.
+    """
+    if img_arr.ndim != 3 or img_arr.shape[2] != 3:
+        raise ValueError("apply_3d_lut expects an HxWx3 image array")
+
+    img_float = img_arr.astype(np.float32) / 255.0
+    sampled = _trilinear_sample_lut(img_float, lut3d)  # HxWx3 floats in [0,1]
+    out = np.clip(sampled * 255.0, 0, 255).astype(np.uint8)
+    if strength >= 1.0:
+        return out
+    else:
+        blended = ((1.0 - strength) * img_arr.astype(np.float32) + strength * out.astype(np.float32))
+        return np.clip(blended, 0, 255).astype(np.uint8)
+
+def apply_lut(img_arr: np.ndarray, lut: np.ndarray, strength: float = 1.0) -> np.ndarray:
+    """
+    Auto-detect LUT type and apply.
+    - If lut.ndim in (1,2) treat as 1D LUT (per-channel if shape (N,3)).
+    - If lut.ndim == 4 treat as 3D LUT (SxSxSx3) in [0,1].
+    """
+    lut = np.array(lut)
+    if lut.ndim == 4 and lut.shape[3] == 3:
+        # 3D LUT (assumed normalized [0..1])
+        # If lut is in 0..255, normalize
+        if lut.dtype != np.float32 and lut.max() > 1.0:
+            lut = lut.astype(np.float32) / 255.0
+        return apply_3d_lut(img_arr, lut, strength=strength)
+    elif lut.ndim in (1, 2):
+        return apply_1d_lut(img_arr, lut, strength=strength)
+    else:
+        raise ValueError("Unsupported LUT shape: {}".format(lut.shape))
+
+def load_cube_lut(path: str) -> np.ndarray:
+    """
+    Parse a .cube file and return a 3D LUT array of shape (S,S,S,3) with float values in [0,1].
+    Note: .cube file order sometimes varies; this function assumes standard ordering
+    where data lines are triples of floats and LUT_3D_SIZE specifies S.
+    """
+    with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+        lines = [ln.strip() for ln in f if ln.strip() and not ln.strip().startswith('#')]
+
+    size = None
+    data = []
+    domain_min = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+    domain_max = np.array([1.0, 1.0, 1.0], dtype=np.float32)
+
+    for ln in lines:
+        if ln.upper().startswith('LUT_3D_SIZE'):
+            parts = ln.split()
+            if len(parts) >= 2:
+                size = int(parts[1])
+        elif ln.upper().startswith('DOMAIN_MIN'):
+            parts = ln.split()
+            domain_min = np.array([float(p) for p in parts[1:4]], dtype=np.float32)
+        elif ln.upper().startswith('DOMAIN_MAX'):
+            parts = ln.split()
+            domain_max = np.array([float(p) for p in parts[1:4]], dtype=np.float32)
+        elif re.match(r'^-?\d+(\.\d+)?\s+-?\d+(\.\d+)?\s+-?\d+(\.\d+)?$', ln):
+            parts = [float(x) for x in ln.split()]
+            data.append(parts)
+
+    if size is None:
+        raise ValueError("LUT_3D_SIZE not found in .cube file: {}".format(path))
+
+    data = np.array(data, dtype=np.float32)
+    if data.shape[0] != size**3:
+        raise ValueError("Cube LUT data length does not match size^3 (got {}, expected {})".format(data.shape[0], size**3))
+
+    # Data ordering in many .cube files is: for r in 0..S-1: for g in 0..S-1: for b in 0..S-1: write RGB
+    # We'll reshape into (S,S,S,3) with indices [r,g,b]
+    lut = data.reshape((size, size, size, 3))
+    # Map domain_min..domain_max to 0..1 if domain specified (rare)
+    if not np.allclose(domain_min, [0.0, 0.0, 0.0]) or not np.allclose(domain_max, [1.0, 1.0, 1.0]):
+        # scale lut values from domain range into 0..1
+        lut = (lut - domain_min) / (domain_max - domain_min + 1e-12)
+        lut = np.clip(lut, 0.0, 1.0)
+    else:
+        # ensure LUT is in [0,1] if not already
+        if lut.max() > 1.0 + 1e-6:
+            lut = lut / 255.0
+    return lut.astype(np.float32)
+
+def load_lut(path: str) -> np.ndarray:
+    """
+    Load a LUT from:
+     - .npy (numpy saved array)
+     - .cube (3D LUT)
+     - image (PNG/JPG) that is a 1D LUT strip (common 256x1 or 1x256)
+    Returns numpy array (1D, 2D, or 4D LUT).
+    """
+    ext = os.path.splitext(path)[1].lower()
+    if ext == '.npy':
+        return np.load(path)
+    elif ext == '.cube':
+        return load_cube_lut(path)
+    else:
+        # try interpreting as image-based 1D LUT
+        try:
+            im = Image.open(path).convert('RGB')
+            arr = np.array(im)
+            h, w = arr.shape[:2]
+            # 256x1 or 1x256 typical 1D LUT
+            if (w == 256 and h == 1) or (h == 256 and w == 1):
+                if h == 1:
+                    lut = arr[0, :, :].astype(np.float32)
+                else:
+                    lut = arr[:, 0, :].astype(np.float32)
+                return lut  # shape (256,3)
+            # sometimes embedded as 512x16 or other tile layouts; attempt to flatten
+            # fallback: flatten and try to build (N,3)
+            flat = arr.reshape(-1, 3).astype(np.float32)
+            # if length is perfect power-of-two and <= 1024, assume 1D
+            L = flat.shape[0]
+            if L <= 4096:
+                return flat  # (L,3)
+            raise ValueError("Image LUT not recognized size")
+        except Exception as e:
+            raise ValueError(f"Unsupported LUT file or parse error for {path}: {e}")

image_postprocess/utils/exif.py

@@ -0,0 +1,6 @@
+from PIL import Image
+
+def remove_exif_pil(img: Image.Image) -> Image.Image:
+    data = img.tobytes()
+    new = Image.frombytes(img.mode, img.size, data)
+    return new

image_postprocess/utils/fourier_pipeline.py

@@ -0,0 +1,152 @@
+import numpy as np
+from scipy.ndimage import gaussian_filter1d
+from PIL import Image
+
+def radial_profile(mag: np.ndarray, center=None, nbins=None):
+    h, w = mag.shape
+    if center is None:
+        cy, cx = h // 2, w // 2
+    else:
+        cy, cx = center
+
+    if nbins is None:
+        nbins = int(max(h, w) / 2)
+    nbins = max(1, int(nbins))
+
+    y = np.arange(h) - cy
+    x = np.arange(w) - cx
+    X, Y = np.meshgrid(x, y)
+    R = np.sqrt(X * X + Y * Y)
+
+    Rmax = R.max()
+    if Rmax <= 0:
+        Rnorm = R
+    else:
+        Rnorm = R / (Rmax + 1e-12)
+        Rnorm = np.minimum(Rnorm, 1.0 - 1e-12)
+
+    bin_edges = np.linspace(0.0, 1.0, nbins + 1)
+    bin_idx = np.digitize(Rnorm.ravel(), bin_edges) - 1
+    bin_idx = np.clip(bin_idx, 0, nbins - 1)
+
+    sums = np.bincount(bin_idx, weights=mag.ravel(), minlength=nbins)
+    counts = np.bincount(bin_idx, minlength=nbins)
+
+    radial_mean = np.zeros(nbins, dtype=np.float64)
+    nonzero = counts > 0
+    radial_mean[nonzero] = sums[nonzero] / counts[nonzero]
+
+    bin_centers = 0.5 * (bin_edges[:-1] + bin_edges[1:])
+    return bin_centers, radial_mean
+
+def fourier_match_spectrum(img_arr: np.ndarray,
+                           ref_img_arr: np.ndarray = None,
+                           mode='auto',
+                           alpha=1.0,
+                           cutoff=0.25,
+                           strength=0.9,
+                           randomness=0.05,
+                           phase_perturb=0.08,
+                           radial_smooth=5,
+                           seed=None):
+    if seed is not None:
+        rng = np.random.default_rng(seed)
+    else:
+        rng = np.random.default_rng()
+
+    h, w = img_arr.shape[:2]
+    cy, cx = h // 2, w // 2
+    nbins = max(8, int(max(h, w) / 2))
+
+    if mode == 'auto':
+        mode = 'ref' if ref_img_arr is not None else 'model'
+
+    bin_centers_src = np.linspace(0.0, 1.0, nbins)
+
+    model_radial = None
+    if mode == 'model':
+        eps = 1e-8
+        model_radial = (1.0 / (bin_centers_src + eps)) ** (alpha / 2.0)
+        lf = max(1, nbins // 8)
+        model_radial = model_radial / (np.median(model_radial[:lf]) + 1e-12)
+        model_radial = gaussian_filter1d(model_radial, sigma=max(1, radial_smooth))
+
+    ref_radial = None
+    ref_bin_centers = None
+    if mode == 'ref' and ref_img_arr is not None:
+        if ref_img_arr.shape[0] != h or ref_img_arr.shape[1] != w:
+            ref_img = Image.fromarray(ref_img_arr).resize((w, h), resample=Image.BICUBIC)
+            ref_img_arr = np.array(ref_img)
+        ref_gray = np.mean(ref_img_arr.astype(np.float32), axis=2) if ref_img_arr.ndim == 3 else ref_img_arr.astype(np.float32)
+        Fref = np.fft.fftshift(np.fft.fft2(ref_gray))
+        Mref = np.abs(Fref)
+        ref_bin_centers, ref_radial = radial_profile(Mref, center=(h // 2, w // 2), nbins=nbins)
+        ref_radial = gaussian_filter1d(ref_radial, sigma=max(1, radial_smooth))
+
+    out = np.zeros_like(img_arr, dtype=np.float32)
+
+    y = np.linspace(-1, 1, h, endpoint=False)[:, None]
+    x = np.linspace(-1, 1, w, endpoint=False)[None, :]
+    r = np.sqrt(x * x + y * y)
+    r = np.clip(r, 0.0, 1.0 - 1e-6)
+
+    for c in range(img_arr.shape[2]):
+        channel = img_arr[:, :, c].astype(np.float32)
+        F = np.fft.fft2(channel)
+        Fshift = np.fft.fftshift(F)
+        mag = np.abs(Fshift)
+        phase = np.angle(Fshift)
+
+        bin_centers_src_calc, src_radial = radial_profile(mag, center=(h // 2, w // 2), nbins=nbins)
+        src_radial = gaussian_filter1d(src_radial, sigma=max(1, radial_smooth))
+        bin_centers_src = bin_centers_src_calc
+
+        if mode == 'ref' and ref_radial is not None:
+            ref_interp = np.interp(bin_centers_src, ref_bin_centers, ref_radial)
+            eps = 1e-8
+            ratio = (ref_interp + eps) / (src_radial + eps)
+            desired_radial = src_radial * ratio
+        elif mode == 'model' and model_radial is not None:
+            lf = max(1, nbins // 8)
+            scale = (np.median(src_radial[:lf]) + 1e-12) / (np.median(model_radial[:lf]) + 1e-12)
+            desired_radial = model_radial * scale
+        else:
+            desired_radial = src_radial.copy()
+
+        eps = 1e-8
+        multiplier_1d = (desired_radial + eps) / (src_radial + eps)
+        multiplier_1d = np.clip(multiplier_1d, 0.2, 5.0)
+        mult_2d = np.interp(r.ravel(), bin_centers_src, multiplier_1d).reshape(h, w)
+
+        edge = 0.05 + 0.02 * (1.0 - cutoff) if 'cutoff' in globals() else 0.05
+        edge = max(edge, 1e-6)
+        weight = np.where(r <= 0.25, 1.0,
+                         np.where(r <= 0.25 + edge,
+                                  0.5 * (1 + np.cos(np.pi * (r - 0.25) / edge)),
+                                  0.0))
+
+        final_multiplier = 1.0 + (mult_2d - 1.0) * (weight * strength)
+
+        if randomness and randomness > 0.0:
+            noise = rng.normal(loc=1.0, scale=randomness, size=final_multiplier.shape)
+            final_multiplier *= (1.0 + (noise - 1.0) * weight)
+
+        mag2 = mag * final_multiplier
+
+        if phase_perturb and phase_perturb > 0.0:
+            phase_sigma = phase_perturb * np.clip((r - 0.25) / (1.0 - 0.25 + 1e-6), 0.0, 1.0)
+            phase_noise = rng.standard_normal(size=phase_sigma.shape) * phase_sigma
+            phase2 = phase + phase_noise
+        else:
+            phase2 = phase
+
+        Fshift2 = mag2 * np.exp(1j * phase2)
+        F_ishift = np.fft.ifftshift(Fshift2)
+        img_back = np.fft.ifft2(F_ishift)
+        img_back = np.real(img_back)
+
+        blended = (1.0 - strength) * channel + strength * img_back
+        out[:, :, c] = blended
+
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out

image_postprocess/utils/gaussian_noise.py

@@ -0,0 +1,10 @@
+import numpy as np
+
+def add_gaussian_noise(img_arr: np.ndarray, std_frac=0.02, seed=None) -> np.ndarray:
+    if seed is not None:
+        np.random.seed(seed)
+    std = std_frac * 255.0
+    noise = np.random.normal(loc=0.0, scale=std, size=img_arr.shape)
+    out = img_arr.astype(np.float32) + noise
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out

image_postprocess/utils/perturbation.py

@@ -0,0 +1,10 @@
+import numpy as np
+
+def randomized_perturbation(img_arr: np.ndarray, magnitude_frac=0.008, seed=None) -> np.ndarray:
+    if seed is not None:
+        np.random.seed(seed)
+    mag = magnitude_frac * 255.0
+    perturb = np.random.uniform(low=-mag, high=mag, size=img_arr.shape)
+    out = img_arr.astype(np.float32) + perturb
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out

image_postprocess/utils_deprecated.py

@@ -0,0 +1,456 @@
+"""
+utils.py
+
+Helper functions for image postprocessing, including EXIF removal, noise addition,
+color correction, and Fourier spectrum matching.
+"""
+import os
+import re
+from PIL import Image, ImageOps
+import numpy as np
+try:
+    import cv2
+    _HAS_CV2 = True
+except Exception:
+    cv2 = None
+    _HAS_CV2 = False
+from scipy.ndimage import gaussian_filter1d
+
+def remove_exif_pil(img: Image.Image) -> Image.Image:
+    data = img.tobytes()
+    new = Image.frombytes(img.mode, img.size, data)
+    return new
+
+def add_gaussian_noise(img_arr: np.ndarray, std_frac=0.02, seed=None) -> np.ndarray:
+    if seed is not None:
+        np.random.seed(seed)
+    std = std_frac * 255.0
+    noise = np.random.normal(loc=0.0, scale=std, size=img_arr.shape)
+    out = img_arr.astype(np.float32) + noise
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out
+
+def clahe_color_correction(img_arr: np.ndarray, clip_limit=2.0, tile_grid_size=(8,8)) -> np.ndarray:
+    if _HAS_CV2:
+        lab = cv2.cvtColor(img_arr, cv2.COLOR_RGB2LAB)
+        l, a, b = cv2.split(lab)
+        clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)
+        l2 = clahe.apply(l)
+        lab2 = cv2.merge((l2, a, b))
+        out = cv2.cvtColor(lab2, cv2.COLOR_LAB2RGB)
+        return out
+    else:
+        pil = Image.fromarray(img_arr)
+        channels = pil.split()
+        new_ch = []
+        for ch in channels:
+            eq = ImageOps.equalize(ch)
+            new_ch.append(eq)
+        merged = Image.merge('RGB', new_ch)
+        return np.array(merged)
+
+def randomized_perturbation(img_arr: np.ndarray, magnitude_frac=0.008, seed=None) -> np.ndarray:
+    if seed is not None:
+        np.random.seed(seed)
+    mag = magnitude_frac * 255.0
+    perturb = np.random.uniform(low=-mag, high=mag, size=img_arr.shape)
+    out = img_arr.astype(np.float32) + perturb
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out
+
+def radial_profile(mag: np.ndarray, center=None, nbins=None):
+    h, w = mag.shape
+    if center is None:
+        cy, cx = h // 2, w // 2
+    else:
+        cy, cx = center
+
+    if nbins is None:
+        nbins = int(max(h, w) / 2)
+    nbins = max(1, int(nbins))
+
+    y = np.arange(h) - cy
+    x = np.arange(w) - cx
+    X, Y = np.meshgrid(x, y)
+    R = np.sqrt(X * X + Y * Y)
+
+    Rmax = R.max()
+    if Rmax <= 0:
+        Rnorm = R
+    else:
+        Rnorm = R / (Rmax + 1e-12)
+        Rnorm = np.minimum(Rnorm, 1.0 - 1e-12)
+
+    bin_edges = np.linspace(0.0, 1.0, nbins + 1)
+    bin_idx = np.digitize(Rnorm.ravel(), bin_edges) - 1
+    bin_idx = np.clip(bin_idx, 0, nbins - 1)
+
+    sums = np.bincount(bin_idx, weights=mag.ravel(), minlength=nbins)
+    counts = np.bincount(bin_idx, minlength=nbins)
+
+    radial_mean = np.zeros(nbins, dtype=np.float64)
+    nonzero = counts > 0
+    radial_mean[nonzero] = sums[nonzero] / counts[nonzero]
+
+    bin_centers = 0.5 * (bin_edges[:-1] + bin_edges[1:])
+    return bin_centers, radial_mean
+
+def fourier_match_spectrum(img_arr: np.ndarray,
+                           ref_img_arr: np.ndarray = None,
+                           mode='auto',
+                           alpha=1.0,
+                           cutoff=0.25,
+                           strength=0.9,
+                           randomness=0.05,
+                           phase_perturb=0.08,
+                           radial_smooth=5,
+                           seed=None):
+    if seed is not None:
+        rng = np.random.default_rng(seed)
+    else:
+        rng = np.random.default_rng()
+
+    h, w = img_arr.shape[:2]
+    cy, cx = h // 2, w // 2
+    nbins = max(8, int(max(h, w) / 2))
+
+    if mode == 'auto':
+        mode = 'ref' if ref_img_arr is not None else 'model'
+
+    bin_centers_src = np.linspace(0.0, 1.0, nbins)
+
+    model_radial = None
+    if mode == 'model':
+        eps = 1e-8
+        model_radial = (1.0 / (bin_centers_src + eps)) ** (alpha / 2.0)
+        lf = max(1, nbins // 8)
+        model_radial = model_radial / (np.median(model_radial[:lf]) + 1e-12)
+        model_radial = gaussian_filter1d(model_radial, sigma=max(1, radial_smooth))
+
+    ref_radial = None
+    ref_bin_centers = None
+    if mode == 'ref' and ref_img_arr is not None:
+        if ref_img_arr.shape[0] != h or ref_img_arr.shape[1] != w:
+            ref_img = Image.fromarray(ref_img_arr).resize((w, h), resample=Image.BICUBIC)
+            ref_img_arr = np.array(ref_img)
+        ref_gray = np.mean(ref_img_arr.astype(np.float32), axis=2) if ref_img_arr.ndim == 3 else ref_img_arr.astype(np.float32)
+        Fref = np.fft.fftshift(np.fft.fft2(ref_gray))
+        Mref = np.abs(Fref)
+        ref_bin_centers, ref_radial = radial_profile(Mref, center=(h // 2, w // 2), nbins=nbins)
+        ref_radial = gaussian_filter1d(ref_radial, sigma=max(1, radial_smooth))
+
+    out = np.zeros_like(img_arr, dtype=np.float32)
+
+    y = np.linspace(-1, 1, h, endpoint=False)[:, None]
+    x = np.linspace(-1, 1, w, endpoint=False)[None, :]
+    r = np.sqrt(x * x + y * y)
+    r = np.clip(r, 0.0, 1.0 - 1e-6)
+
+    for c in range(img_arr.shape[2]):
+        channel = img_arr[:, :, c].astype(np.float32)
+        F = np.fft.fft2(channel)
+        Fshift = np.fft.fftshift(F)
+        mag = np.abs(Fshift)
+        phase = np.angle(Fshift)
+
+        bin_centers_src_calc, src_radial = radial_profile(mag, center=(h // 2, w // 2), nbins=nbins)
+        src_radial = gaussian_filter1d(src_radial, sigma=max(1, radial_smooth))
+        bin_centers_src = bin_centers_src_calc
+
+        if mode == 'ref' and ref_radial is not None:
+            ref_interp = np.interp(bin_centers_src, ref_bin_centers, ref_radial)
+            eps = 1e-8
+            ratio = (ref_interp + eps) / (src_radial + eps)
+            desired_radial = src_radial * ratio
+        elif mode == 'model' and model_radial is not None:
+            lf = max(1, nbins // 8)
+            scale = (np.median(src_radial[:lf]) + 1e-12) / (np.median(model_radial[:lf]) + 1e-12)
+            desired_radial = model_radial * scale
+        else:
+            desired_radial = src_radial.copy()
+
+        eps = 1e-8
+        multiplier_1d = (desired_radial + eps) / (src_radial + eps)
+        multiplier_1d = np.clip(multiplier_1d, 0.2, 5.0)
+        mult_2d = np.interp(r.ravel(), bin_centers_src, multiplier_1d).reshape(h, w)
+
+        edge = 0.05 + 0.02 * (1.0 - cutoff) if 'cutoff' in globals() else 0.05
+        edge = max(edge, 1e-6)
+        weight = np.where(r <= 0.25, 1.0,
+                         np.where(r <= 0.25 + edge,
+                                  0.5 * (1 + np.cos(np.pi * (r - 0.25) / edge)),
+                                  0.0))
+
+        final_multiplier = 1.0 + (mult_2d - 1.0) * (weight * strength)
+
+        if randomness and randomness > 0.0:
+            noise = rng.normal(loc=1.0, scale=randomness, size=final_multiplier.shape)
+            final_multiplier *= (1.0 + (noise - 1.0) * weight)
+
+        mag2 = mag * final_multiplier
+
+        if phase_perturb and phase_perturb > 0.0:
+            phase_sigma = phase_perturb * np.clip((r - 0.25) / (1.0 - 0.25 + 1e-6), 0.0, 1.0)
+            phase_noise = rng.standard_normal(size=phase_sigma.shape) * phase_sigma
+            phase2 = phase + phase_noise
+        else:
+            phase2 = phase
+
+        Fshift2 = mag2 * np.exp(1j * phase2)
+        F_ishift = np.fft.ifftshift(Fshift2)
+        img_back = np.fft.ifft2(F_ishift)
+        img_back = np.real(img_back)
+
+        blended = (1.0 - strength) * channel + strength * img_back
+        out[:, :, c] = blended
+
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out
+
+def auto_white_balance_ref(img_arr: np.ndarray, ref_img_arr: np.ndarray = None) -> np.ndarray:
+    """
+    Auto white-balance correction using a reference image.
+    If ref_img_arr is None, uses a gray-world assumption instead.
+    """
+    img = img_arr.astype(np.float32)
+
+    if ref_img_arr is not None:
+        ref = ref_img_arr.astype(np.float32)
+        ref_mean = ref.reshape(-1, 3).mean(axis=0)
+    else:
+        # Gray-world assumption: target is neutral gray
+        ref_mean = np.array([128.0, 128.0, 128.0], dtype=np.float32)
+
+    img_mean = img.reshape(-1, 3).mean(axis=0)
+
+    # Avoid divide-by-zero
+    eps = 1e-6
+    scale = (ref_mean + eps) / (img_mean + eps)
+
+    corrected = img * scale
+    corrected = np.clip(corrected, 0, 255).astype(np.uint8)
+
+    return corrected
+
+def apply_1d_lut(img_arr: np.ndarray, lut: np.ndarray, strength: float = 1.0) -> np.ndarray:
+    """
+    Apply a 1D LUT to an image.
+    - img_arr: HxWx3 uint8
+    - lut: either shape (256,) (applied equally to all channels), (256,3) (per-channel),
+           or (N,) / (N,3) (interpolated across [0..255])
+    - strength: 0..1 blending between original and LUT result
+    Returns uint8 array.
+    """
+    if img_arr.ndim != 3 or img_arr.shape[2] != 3:
+        raise ValueError("apply_1d_lut expects an HxWx3 image array")
+
+    # Normalize indices 0..255
+    arr = img_arr.astype(np.float32)
+    # Prepare LUT as float in 0..255 range if necessary
+    lut_arr = np.array(lut, dtype=np.float32)
+
+    # If single channel LUT (N,) expand to three channels
+    if lut_arr.ndim == 1:
+        lut_arr = np.stack([lut_arr, lut_arr, lut_arr], axis=1)  # (N,3)
+
+    if lut_arr.shape[1] != 3:
+        raise ValueError("1D LUT must have shape (N,) or (N,3)")
+
+    # Build index positions in source LUT space (0..255)
+    N = lut_arr.shape[0]
+    src_positions = np.linspace(0, 255, N)
+
+    # Flatten and interpolate per channel
+    out = np.empty_like(arr)
+    for c in range(3):
+        channel = arr[..., c].ravel()
+        mapped = np.interp(channel, src_positions, lut_arr[:, c])
+        out[..., c] = mapped.reshape(arr.shape[0], arr.shape[1])
+
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    if strength >= 1.0:
+        return out
+    else:
+        blended = ((1.0 - strength) * img_arr.astype(np.float32) + strength * out.astype(np.float32))
+        return np.clip(blended, 0, 255).astype(np.uint8)
+
+def _trilinear_sample_lut(img_float: np.ndarray, lut: np.ndarray) -> np.ndarray:
+    """
+    Vectorized trilinear sampling of 3D LUT.
+    - img_float: HxWx3 floats in [0,1]
+    - lut: SxSxS x 3 floats in [0,1]
+    Returns HxWx3 floats in [0,1]
+    """
+    S = lut.shape[0]
+    if lut.shape[0] != lut.shape[1] or lut.shape[1] != lut.shape[2]:
+        raise ValueError("3D LUT must be cubic (SxSxSx3)")
+
+    # map [0,1] -> [0, S-1]
+    idx = img_float * (S - 1)
+    r_idx = idx[..., 0]
+    g_idx = idx[..., 1]
+    b_idx = idx[..., 2]
+
+    r0 = np.floor(r_idx).astype(np.int32)
+    g0 = np.floor(g_idx).astype(np.int32)
+    b0 = np.floor(b_idx).astype(np.int32)
+
+    r1 = np.clip(r0 + 1, 0, S - 1)
+    g1 = np.clip(g0 + 1, 0, S - 1)
+    b1 = np.clip(b0 + 1, 0, S - 1)
+
+    dr = (r_idx - r0)[..., None]
+    dg = (g_idx - g0)[..., None]
+    db = (b_idx - b0)[..., None]
+
+    # gather 8 corners: c000 ... c111
+    c000 = lut[r0, g0, b0]
+    c001 = lut[r0, g0, b1]
+    c010 = lut[r0, g1, b0]
+    c011 = lut[r0, g1, b1]
+    c100 = lut[r1, g0, b0]
+    c101 = lut[r1, g0, b1]
+    c110 = lut[r1, g1, b0]
+    c111 = lut[r1, g1, b1]
+
+    # interpolate along b
+    c00 = c000 * (1 - db) + c001 * db
+    c01 = c010 * (1 - db) + c011 * db
+    c10 = c100 * (1 - db) + c101 * db
+    c11 = c110 * (1 - db) + c111 * db
+
+    # interpolate along g
+    c0 = c00 * (1 - dg) + c01 * dg
+    c1 = c10 * (1 - dg) + c11 * dg
+
+    # interpolate along r
+    c = c0 * (1 - dr) + c1 * dr
+
+    return c  # float in same range as lut (expected [0,1])
+
+def apply_3d_lut(img_arr: np.ndarray, lut3d: np.ndarray, strength: float = 1.0) -> np.ndarray:
+    """
+    Apply a 3D LUT to the image.
+    - img_arr: HxWx3 uint8
+    - lut3d: SxSxSx3 float (expected range 0..1)
+    - strength: blending 0..1
+    Returns uint8 image.
+    """
+    if img_arr.ndim != 3 or img_arr.shape[2] != 3:
+        raise ValueError("apply_3d_lut expects an HxWx3 image array")
+
+    img_float = img_arr.astype(np.float32) / 255.0
+    sampled = _trilinear_sample_lut(img_float, lut3d)  # HxWx3 floats in [0,1]
+    out = np.clip(sampled * 255.0, 0, 255).astype(np.uint8)
+    if strength >= 1.0:
+        return out
+    else:
+        blended = ((1.0 - strength) * img_arr.astype(np.float32) + strength * out.astype(np.float32))
+        return np.clip(blended, 0, 255).astype(np.uint8)
+
+def apply_lut(img_arr: np.ndarray, lut: np.ndarray, strength: float = 1.0) -> np.ndarray:
+    """
+    Auto-detect LUT type and apply.
+    - If lut.ndim in (1,2) treat as 1D LUT (per-channel if shape (N,3)).
+    - If lut.ndim == 4 treat as 3D LUT (SxSxSx3) in [0,1].
+    """
+    lut = np.array(lut)
+    if lut.ndim == 4 and lut.shape[3] == 3:
+        # 3D LUT (assumed normalized [0..1])
+        # If lut is in 0..255, normalize
+        if lut.dtype != np.float32 and lut.max() > 1.0:
+            lut = lut.astype(np.float32) / 255.0
+        return apply_3d_lut(img_arr, lut, strength=strength)
+    elif lut.ndim in (1, 2):
+        return apply_1d_lut(img_arr, lut, strength=strength)
+    else:
+        raise ValueError("Unsupported LUT shape: {}".format(lut.shape))
+
+def load_cube_lut(path: str) -> np.ndarray:
+    """
+    Parse a .cube file and return a 3D LUT array of shape (S,S,S,3) with float values in [0,1].
+    Note: .cube file order sometimes varies; this function assumes standard ordering
+    where data lines are triples of floats and LUT_3D_SIZE specifies S.
+    """
+    with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+        lines = [ln.strip() for ln in f if ln.strip() and not ln.strip().startswith('#')]
+
+    size = None
+    data = []
+    domain_min = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+    domain_max = np.array([1.0, 1.0, 1.0], dtype=np.float32)
+
+    for ln in lines:
+        if ln.upper().startswith('LUT_3D_SIZE'):
+            parts = ln.split()
+            if len(parts) >= 2:
+                size = int(parts[1])
+        elif ln.upper().startswith('DOMAIN_MIN'):
+            parts = ln.split()
+            domain_min = np.array([float(p) for p in parts[1:4]], dtype=np.float32)
+        elif ln.upper().startswith('DOMAIN_MAX'):
+            parts = ln.split()
+            domain_max = np.array([float(p) for p in parts[1:4]], dtype=np.float32)
+        elif re.match(r'^-?\d+(\.\d+)?\s+-?\d+(\.\d+)?\s+-?\d+(\.\d+)?$', ln):
+            parts = [float(x) for x in ln.split()]
+            data.append(parts)
+
+    if size is None:
+        raise ValueError("LUT_3D_SIZE not found in .cube file: {}".format(path))
+
+    data = np.array(data, dtype=np.float32)
+    if data.shape[0] != size**3:
+        raise ValueError("Cube LUT data length does not match size^3 (got {}, expected {})".format(data.shape[0], size**3))
+
+    # Data ordering in many .cube files is: for r in 0..S-1: for g in 0..S-1: for b in 0..S-1: write RGB
+    # We'll reshape into (S,S,S,3) with indices [r,g,b]
+    lut = data.reshape((size, size, size, 3))
+    # Map domain_min..domain_max to 0..1 if domain specified (rare)
+    if not np.allclose(domain_min, [0.0, 0.0, 0.0]) or not np.allclose(domain_max, [1.0, 1.0, 1.0]):
+        # scale lut values from domain range into 0..1
+        lut = (lut - domain_min) / (domain_max - domain_min + 1e-12)
+        lut = np.clip(lut, 0.0, 1.0)
+    else:
+        # ensure LUT is in [0,1] if not already
+        if lut.max() > 1.0 + 1e-6:
+            lut = lut / 255.0
+    return lut.astype(np.float32)
+
+def load_lut(path: str) -> np.ndarray:
+    """
+    Load a LUT from:
+     - .npy (numpy saved array)
+     - .cube (3D LUT)
+     - image (PNG/JPG) that is a 1D LUT strip (common 256x1 or 1x256)
+    Returns numpy array (1D, 2D, or 4D LUT).
+    """
+    ext = os.path.splitext(path)[1].lower()
+    if ext == '.npy':
+        return np.load(path)
+    elif ext == '.cube':
+        return load_cube_lut(path)
+    else:
+        # try interpreting as image-based 1D LUT
+        try:
+            im = Image.open(path).convert('RGB')
+            arr = np.array(im)
+            h, w = arr.shape[:2]
+            # 256x1 or 1x256 typical 1D LUT
+            if (w == 256 and h == 1) or (h == 256 and w == 1):
+                if h == 1:
+                    lut = arr[0, :, :].astype(np.float32)
+                else:
+                    lut = arr[:, 0, :].astype(np.float32)
+                return lut  # shape (256,3)
+            # sometimes embedded as 512x16 or other tile layouts; attempt to flatten
+            # fallback: flatten and try to build (N,3)
+            flat = arr.reshape(-1, 3).astype(np.float32)
+            # if length is perfect power-of-two and <= 1024, assume 1D
+            L = flat.shape[0]
+            if L <= 4096:
+                return flat  # (L,3)
+            raise ValueError("Image LUT not recognized size")
+        except Exception as e:
+            raise ValueError(f"Unsupported LUT file or parse error for {path}: {e}")
+
+# --- end appended LUT helpers

main_window.py

@@ -0,0 +1,592 @@
+#!/usr/bin/env python3
+"""
+MainWindow definition extracted from the original single-file GUI.
+All GUI wiring, widgets, and the MainWindow class live here.
+"""
+
+import sys
+import os
+from pathlib import Path
+from PyQt5.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QLabel, QPushButton, QFileDialog,
+    QHBoxLayout, QVBoxLayout, QFormLayout, QSlider, QSpinBox, QDoubleSpinBox,
+    QProgressBar, QMessageBox, QLineEdit, QComboBox, QCheckBox, QToolButton, QScrollArea
+)
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QPixmap
+from worker import Worker
+from analysis_panel import AnalysisPanel
+from utils import qpixmap_from_path
+from collapsible_box import CollapsibleBox
+from theme import apply_dark_palette
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Image Postprocess — GUI (Camera Simulator)")
+        self.setMinimumSize(1200, 760)
+
+        central = QWidget()
+        self.setCentralWidget(central)
+        main_h = QHBoxLayout(central)
+
+        # Left: previews & file selection
+        left_v = QVBoxLayout()
+        main_h.addLayout(left_v, 2)
+
+        # Input/Output collapsible
+        io_box = CollapsibleBox("Input / Output")
+        left_v.addWidget(io_box)
+        in_layout = QFormLayout()
+        io_container = QWidget()
+        io_container.setLayout(in_layout)
+        io_box.content_layout.addWidget(io_container)
+
+        self.input_line = QLineEdit()
+        self.input_btn = QPushButton("Choose Input")
+        self.input_btn.clicked.connect(self.choose_input)
+
+        self.ref_line = QLineEdit()
+        self.ref_btn = QPushButton("Choose AWB Reference (optional)")
+        self.ref_btn.clicked.connect(self.choose_ref)
+
+        self.fft_ref_line = QLineEdit()
+        self.fft_ref_btn = QPushButton("Choose FFT Reference (optional)")
+        self.fft_ref_btn.clicked.connect(self.choose_fft_ref)
+
+        self.output_line = QLineEdit()
+        self.output_btn = QPushButton("Choose Output")
+        self.output_btn.clicked.connect(self.choose_output)
+
+        in_layout.addRow(self.input_btn, self.input_line)
+        in_layout.addRow(self.ref_btn, self.ref_line)
+        in_layout.addRow(self.fft_ref_btn, self.fft_ref_line)
+        in_layout.addRow(self.output_btn, self.output_line)
+
+        # Previews
+        self.preview_in = QLabel(alignment=Qt.AlignCenter)
+        self.preview_in.setFixedSize(480, 300)
+        self.preview_in.setStyleSheet("background:#121213; border:1px solid #2b2b2b; color:#ddd; border-radius:6px")
+        self.preview_in.setText("Input preview")
+
+        self.preview_out = QLabel(alignment=Qt.AlignCenter)
+        self.preview_out.setFixedSize(480, 300)
+        self.preview_out.setStyleSheet("background:#121213; border:1px solid #2b2b2b; color:#ddd; border-radius:6px")
+        self.preview_out.setText("Output preview")
+
+        left_v.addWidget(self.preview_in)
+        left_v.addWidget(self.preview_out)
+
+        # Actions
+        actions_h = QHBoxLayout()
+        self.run_btn = QPushButton("Run — Process Image")
+        self.run_btn.clicked.connect(self.on_run)
+        self.open_out_btn = QPushButton("Open Output Folder")
+        self.open_out_btn.clicked.connect(self.open_output_folder)
+        actions_h.addWidget(self.run_btn)
+        actions_h.addWidget(self.open_out_btn)
+        left_v.addLayout(actions_h)
+
+        self.progress = QProgressBar()
+        self.progress.setTextVisible(True)
+        self.progress.setRange(0, 100)
+        self.progress.setValue(0)
+        left_v.addWidget(self.progress)
+
+        # Right: controls + analysis panels (with scroll area)
+        scroll_area = QScrollArea()
+        scroll_area.setWidgetResizable(True)
+        scroll_area.setStyleSheet("QScrollArea { border: none; }")
+        main_h.addWidget(scroll_area, 3)
+
+        scroll_widget = QWidget()
+        right_v = QVBoxLayout(scroll_widget)
+        scroll_area.setWidget(scroll_widget)
+
+        # Auto Mode toggle (keeps top-level quick switch visible)
+        self.auto_mode_chk = QCheckBox("Enable Auto Mode")
+        self.auto_mode_chk.setChecked(False)
+        self.auto_mode_chk.stateChanged.connect(self._on_auto_mode_toggled)
+        right_v.addWidget(self.auto_mode_chk)
+
+        # Make Auto Mode section collapsible
+        self.auto_box = CollapsibleBox("Auto Mode")
+        right_v.addWidget(self.auto_box)
+        auto_layout = QFormLayout()
+        auto_container = QWidget()
+        auto_container.setLayout(auto_layout)
+        self.auto_box.content_layout.addWidget(auto_container)
+
+        strength_layout = QHBoxLayout()
+        self.strength_slider = QSlider(Qt.Horizontal)
+        self.strength_slider.setRange(0, 100)
+        self.strength_slider.setValue(25)
+        self.strength_slider.valueChanged.connect(self._update_strength_label)
+        self.strength_label = QLabel("25")
+        self.strength_label.setFixedWidth(30)
+        strength_layout.addWidget(self.strength_slider)
+        strength_layout.addWidget(self.strength_label)
+
+        auto_layout.addRow("Aberration Strength", strength_layout)
+
+        # Parameters (Manual Mode) collapsible
+        self.params_box = CollapsibleBox("Parameters (Manual Mode)")
+        right_v.addWidget(self.params_box)
+        params_layout = QFormLayout()
+        params_container = QWidget()
+        params_container.setLayout(params_layout)
+        self.params_box.content_layout.addWidget(params_container)
+
+        # Noise-std
+        self.noise_spin = QDoubleSpinBox()
+        self.noise_spin.setRange(0.0, 0.1)
+        self.noise_spin.setSingleStep(0.001)
+        self.noise_spin.setValue(0.02)
+        self.noise_spin.setToolTip("Gaussian noise std fraction of 255")
+        params_layout.addRow("Noise std (0-0.1)", self.noise_spin)
+
+        # CLAHE-clip
+        self.clahe_spin = QDoubleSpinBox()
+        self.clahe_spin.setRange(0.1, 10.0)
+        self.clahe_spin.setSingleStep(0.1)
+        self.clahe_spin.setValue(2.0)
+        params_layout.addRow("CLAHE clip", self.clahe_spin)
+
+        # Tile
+        self.tile_spin = QSpinBox()
+        self.tile_spin.setRange(1, 64)
+        self.tile_spin.setValue(8)
+        params_layout.addRow("CLAHE tile", self.tile_spin)
+
+        # Cutoff
+        self.cutoff_spin = QDoubleSpinBox()
+        self.cutoff_spin.setRange(0.01, 1.0)
+        self.cutoff_spin.setSingleStep(0.01)
+        self.cutoff_spin.setValue(0.25)
+        params_layout.addRow("Fourier cutoff (0-1)", self.cutoff_spin)
+
+        # Fstrength
+        self.fstrength_spin = QDoubleSpinBox()
+        self.fstrength_spin.setRange(0.0, 1.0)
+        self.fstrength_spin.setSingleStep(0.01)
+        self.fstrength_spin.setValue(0.9)
+        params_layout.addRow("Fourier strength (0-1)", self.fstrength_spin)
+
+        # Randomness
+        self.randomness_spin = QDoubleSpinBox()
+        self.randomness_spin.setRange(0.0, 1.0)
+        self.randomness_spin.setSingleStep(0.01)
+        self.randomness_spin.setValue(0.05)
+        params_layout.addRow("Fourier randomness", self.randomness_spin)
+
+        # Phase_perturb
+        self.phase_perturb_spin = QDoubleSpinBox()
+        self.phase_perturb_spin.setRange(0.0, 1.0)
+        self.phase_perturb_spin.setSingleStep(0.001)
+        self.phase_perturb_spin.setValue(0.08)
+        self.phase_perturb_spin.setToolTip("Phase perturbation std (radians)")
+        params_layout.addRow("Phase perturb (rad)", self.phase_perturb_spin)
+
+        # Radial_smooth
+        self.radial_smooth_spin = QSpinBox()
+        self.radial_smooth_spin.setRange(0, 50)
+        self.radial_smooth_spin.setValue(5)
+        params_layout.addRow("Radial smooth (bins)", self.radial_smooth_spin)
+
+        # FFT_mode
+        self.fft_mode_combo = QComboBox()
+        self.fft_mode_combo.addItems(["auto", "ref", "model"])
+        self.fft_mode_combo.setCurrentText("auto")
+        params_layout.addRow("FFT mode", self.fft_mode_combo)
+
+        # FFT_alpha
+        self.fft_alpha_spin = QDoubleSpinBox()
+        self.fft_alpha_spin.setRange(0.1, 4.0)
+        self.fft_alpha_spin.setSingleStep(0.1)
+        self.fft_alpha_spin.setValue(1.0)
+        self.fft_alpha_spin.setToolTip("Alpha exponent for 1/f model when using model mode")
+        params_layout.addRow("FFT alpha (model)", self.fft_alpha_spin)
+
+        # Perturb
+        self.perturb_spin = QDoubleSpinBox()
+        self.perturb_spin.setRange(0.0, 0.05)
+        self.perturb_spin.setSingleStep(0.001)
+        self.perturb_spin.setValue(0.008)
+        params_layout.addRow("Pixel perturb", self.perturb_spin)
+
+        # Seed
+        self.seed_spin = QSpinBox()
+        self.seed_spin.setRange(0, 2 ** 31 - 1)
+        self.seed_spin.setValue(0)
+        params_layout.addRow("Seed (0=none)", self.seed_spin)
+
+        # AWB checkbox
+        self.awb_chk = QCheckBox("Enable auto white-balance (AWB)")
+        self.awb_chk.setChecked(False)
+        self.awb_chk.setToolTip("If checked, AWB is applied. If a reference image is chosen, it will be used; otherwise gray-world AWB is applied.")
+        params_layout.addRow(self.awb_chk)
+
+        # Camera simulator toggle
+        self.sim_camera_chk = QCheckBox("Enable camera pipeline simulation")
+        self.sim_camera_chk.setChecked(False)
+        self.sim_camera_chk.stateChanged.connect(self._on_sim_camera_toggled)
+        params_layout.addRow(self.sim_camera_chk)
+
+        # --- LUT support UI ---
+        self.lut_chk = QCheckBox("Enable LUT")
+        self.lut_chk.setChecked(False)
+        self.lut_chk.setToolTip("Enable applying a 1D/.npy/.cube LUT to the output image")
+        self.lut_chk.stateChanged.connect(self._on_lut_toggled)
+        params_layout.addRow(self.lut_chk)
+
+        # LUT chooser (hidden until checkbox checked)
+        self.lut_line = QLineEdit()
+        self.lut_btn = QPushButton("Choose LUT")
+        self.lut_btn.clicked.connect(self.choose_lut)
+        lut_box = QWidget()
+        lut_box_layout = QHBoxLayout()
+        lut_box_layout.setContentsMargins(0, 0, 0, 0)
+        lut_box.setLayout(lut_box_layout)
+        lut_box_layout.addWidget(self.lut_line)
+        lut_box_layout.addWidget(self.lut_btn)
+        self.lut_file_label = QLabel("LUT file (png/.npy/.cube)")
+        params_layout.addRow(self.lut_file_label, lut_box)
+
+        self.lut_strength_spin = QDoubleSpinBox()
+        self.lut_strength_spin.setRange(0.0, 1.0)
+        self.lut_strength_spin.setSingleStep(0.01)
+        self.lut_strength_spin.setValue(1.0)
+        self.lut_strength_spin.setToolTip("Blend strength for LUT (0.0 = no effect, 1.0 = full LUT)")
+        self.lut_strength_label = QLabel("LUT strength")
+        params_layout.addRow(self.lut_strength_label, self.lut_strength_spin)
+
+        # Initially hide LUT controls and their labels
+        self.lut_file_label.setVisible(False)
+        lut_box.setVisible(False)
+        self.lut_strength_label.setVisible(False)
+        self.lut_strength_spin.setVisible(False)
+
+        # Store all widgets that need their visibility toggled
+        self._lut_controls = (self.lut_file_label, lut_box, self.lut_strength_label, self.lut_strength_spin)
+
+        # Camera simulator collapsible group
+        self.camera_box = CollapsibleBox("Camera simulator options")
+        right_v.addWidget(self.camera_box)
+        cam_layout = QFormLayout()
+        cam_container = QWidget()
+        cam_container.setLayout(cam_layout)
+        self.camera_box.content_layout.addWidget(cam_container)
+
+        # Enable bayer
+        self.bayer_chk = QCheckBox("Enable Bayer / demosaic (RGGB)")
+        self.bayer_chk.setChecked(True)
+        cam_layout.addRow(self.bayer_chk)
+
+        # JPEG cycles
+        self.jpeg_cycles_spin = QSpinBox()
+        self.jpeg_cycles_spin.setRange(0, 10)
+        self.jpeg_cycles_spin.setValue(1)
+        cam_layout.addRow("JPEG cycles", self.jpeg_cycles_spin)
+
+        # JPEG quality min/max
+        self.jpeg_qmin_spin = QSpinBox()
+        self.jpeg_qmin_spin.setRange(1, 100)
+        self.jpeg_qmin_spin.setValue(88)
+        self.jpeg_qmax_spin = QSpinBox()
+        self.jpeg_qmax_spin.setRange(1, 100)
+        self.jpeg_qmax_spin.setValue(96)
+        qbox = QHBoxLayout()
+        qbox.addWidget(self.jpeg_qmin_spin)
+        qbox.addWidget(QLabel("to"))
+        qbox.addWidget(self.jpeg_qmax_spin)
+        cam_layout.addRow("JPEG quality (min to max)", qbox)
+
+        # Vignette strength
+        self.vignette_spin = QDoubleSpinBox()
+        self.vignette_spin.setRange(0.0, 1.0)
+        self.vignette_spin.setSingleStep(0.01)
+        self.vignette_spin.setValue(0.35)
+        cam_layout.addRow("Vignette strength", self.vignette_spin)
+
+        # Chromatic aberration strength
+        self.chroma_spin = QDoubleSpinBox()
+        self.chroma_spin.setRange(0.0, 10.0)
+        self.chroma_spin.setSingleStep(0.1)
+        self.chroma_spin.setValue(1.2)
+        cam_layout.addRow("Chromatic aberration (px)", self.chroma_spin)
+
+        # ISO scale
+        self.iso_spin = QDoubleSpinBox()
+        self.iso_spin.setRange(0.1, 16.0)
+        self.iso_spin.setSingleStep(0.1)
+        self.iso_spin.setValue(1.0)
+        cam_layout.addRow("ISO/exposure scale", self.iso_spin)
+
+        # Read noise
+        self.read_noise_spin = QDoubleSpinBox()
+        self.read_noise_spin.setRange(0.0, 50.0)
+        self.read_noise_spin.setSingleStep(0.1)
+        self.read_noise_spin.setValue(2.0)
+        cam_layout.addRow("Read noise (DN)", self.read_noise_spin)
+
+        # Hot pixel prob
+        self.hot_pixel_spin = QDoubleSpinBox()
+        self.hot_pixel_spin.setDecimals(9)
+        self.hot_pixel_spin.setRange(0.0, 1.0)
+        self.hot_pixel_spin.setSingleStep(1e-6)
+        self.hot_pixel_spin.setValue(1e-6)
+        cam_layout.addRow("Hot pixel prob", self.hot_pixel_spin)
+
+        # Banding strength
+        self.banding_spin = QDoubleSpinBox()
+        self.banding_spin.setRange(0.0, 1.0)
+        self.banding_spin.setSingleStep(0.01)
+        self.banding_spin.setValue(0.0)
+        cam_layout.addRow("Banding strength", self.banding_spin)
+
+        # Motion blur kernel
+        self.motion_blur_spin = QSpinBox()
+        self.motion_blur_spin.setRange(1, 51)
+        self.motion_blur_spin.setValue(1)
+        cam_layout.addRow("Motion blur kernel", self.motion_blur_spin)
+
+        self.camera_box.setVisible(False)
+
+        self.ref_hint = QLabel("AWB uses the 'AWB reference' chooser. FFT spectral matching uses the 'FFT Reference' chooser.")
+        right_v.addWidget(self.ref_hint)
+
+        self.analysis_input = AnalysisPanel(title="Input analysis")
+        self.analysis_output = AnalysisPanel(title="Output analysis")
+        right_v.addWidget(self.analysis_input)
+        right_v.addWidget(self.analysis_output)
+
+        right_v.addStretch(1)
+
+        # Status bar
+        self.status = QLabel("Ready")
+        self.status.setStyleSheet("color:#bdbdbd;padding:6px")
+        self.status.setAlignment(Qt.AlignLeft)
+        self.status.setFixedHeight(28)
+        self.status.setContentsMargins(6, 6, 6, 6)
+        self.statusBar().addWidget(self.status)
+
+        self.worker = None
+        self._on_auto_mode_toggled(self.auto_mode_chk.checkState())
+
+    def _on_sim_camera_toggled(self, state):
+        enabled = state == Qt.Checked
+        self.camera_box.setVisible(enabled)
+
+    def _on_auto_mode_toggled(self, state):
+        is_auto = (state == Qt.Checked)
+        self.auto_box.setVisible(is_auto)
+        self.params_box.setVisible(not is_auto)
+
+    def _update_strength_label(self, value):
+        self.strength_label.setText(str(value))
+
+    def choose_input(self):
+        path, _ = QFileDialog.getOpenFileName(self, "Choose input image", str(Path.home()), "Images (*.png *.jpg *.jpeg *.bmp *.tif)")
+        if path:
+            self.input_line.setText(path)
+            self.load_preview(self.preview_in, path)
+            self.analysis_input.update_from_path(path)
+            out_suggest = str(Path(path).with_name(Path(path).stem + "_out" + Path(path).suffix))
+            if not self.output_line.text():
+                self.output_line.setText(out_suggest)
+
+    def choose_ref(self):
+        path, _ = QFileDialog.getOpenFileName(self, "Choose AWB reference image", str(Path.home()), "Images (*.png *.jpg *.jpeg *.bmp *.tif)")
+        if path:
+            self.ref_line.setText(path)
+
+    def choose_fft_ref(self):
+        path, _ = QFileDialog.getOpenFileName(self, "Choose FFT reference image", str(Path.home()), "Images (*.png *.jpg *.jpeg *.bmp *.tif)")
+        if path:
+            self.fft_ref_line.setText(path)
+
+    def choose_output(self):
+        path, _ = QFileDialog.getSaveFileName(self, "Choose output path", str(Path.home()), "JPEG (*.jpg *.jpeg);;PNG (*.png);;TIFF (*.tif)")
+        if path:
+            self.output_line.setText(path)
+
+    def choose_lut(self):
+        path, _ = QFileDialog.getOpenFileName(self, "Choose LUT file", str(Path.home()), "LUTs (*.png *.npy *.cube);;All files (*)")
+        if path:
+            self.lut_line.setText(path)
+
+    def _on_lut_toggled(self, state):
+        visible = (state == Qt.Checked)
+        for w in self._lut_controls:
+            w.setVisible(visible)
+
+    def load_preview(self, widget: QLabel, path: str):
+        if not path or not os.path.exists(path):
+            widget.setText("No image")
+            widget.setPixmap(QPixmap())
+            return
+        pix = qpixmap_from_path(path, max_size=(widget.width(), widget.height()))
+        widget.setPixmap(pix)
+
+    def set_enabled_all(self, enabled: bool):
+        for w in self.findChildren((QPushButton, QDoubleSpinBox, QSpinBox, QLineEdit, QComboBox, QCheckBox, QSlider, QToolButton)):
+            w.setEnabled(enabled)
+
+    def on_run(self):
+        from types import SimpleNamespace
+        inpath = self.input_line.text().strip()
+        outpath = self.output_line.text().strip()
+        if not inpath or not os.path.exists(inpath):
+            QMessageBox.warning(self, "Missing input", "Please choose a valid input image.")
+            return
+        if not outpath:
+            QMessageBox.warning(self, "Missing output", "Please choose an output path.")
+            return
+
+        awb_ref_val = self.ref_line.text() or None
+        fft_ref_val = self.fft_ref_line.text() or None
+        args = SimpleNamespace()
+
+        if self.auto_mode_chk.isChecked():
+            strength = self.strength_slider.value() / 100.0
+            args.noise_std = strength * 0.04
+            args.clahe_clip = 1.0 + strength * 3.0
+            args.cutoff = max(0.01, 0.4 - strength * 0.3)
+            args.fstrength = strength * 0.95
+            args.phase_perturb = strength * 0.1
+            args.perturb = strength * 0.015
+            args.jpeg_cycles = int(strength * 2)
+            args.jpeg_qmin = max(1, int(95 - strength * 35))
+            args.jpeg_qmax = max(1, int(99 - strength * 25))
+            args.vignette_strength = strength * 0.6
+            args.chroma_strength = strength * 4.0
+            args.motion_blur_kernel = 1 + 2 * int(strength * 6)
+            args.banding_strength = strength * 0.1
+            args.tile = 8
+            args.randomness = 0.05
+            args.radial_smooth = 5
+            args.fft_mode = "auto"
+            args.fft_alpha = 1.0
+            args.alpha = 1.0
+            seed_val = int(self.seed_spin.value())
+            args.seed = None if seed_val == 0 else seed_val
+            args.sim_camera = bool(self.sim_camera_chk.isChecked())
+            args.no_no_bayer = True
+            args.iso_scale = 1.0
+            args.read_noise = 2.0
+            args.hot_pixel_prob = 1e-6
+        else:
+            seed_val = int(self.seed_spin.value())
+            args.seed = None if seed_val == 0 else seed_val
+            sim_camera = bool(self.sim_camera_chk.isChecked())
+            enable_bayer = bool(self.bayer_chk.isChecked())
+            args.noise_std = float(self.noise_spin.value())
+            args.clahe_clip = float(self.clahe_spin.value())
+            args.tile = int(self.tile_spin.value())
+            args.cutoff = float(self.cutoff_spin.value())
+            args.fstrength = float(self.fstrength_spin.value())
+            args.strength = float(self.fstrength_spin.value())
+            args.randomness = float(self.randomness_spin.value())
+            args.phase_perturb = float(self.phase_perturb_spin.value())
+            args.perturb = float(self.perturb_spin.value())
+            args.fft_mode = self.fft_mode_combo.currentText()
+            args.fft_alpha = float(self.fft_alpha_spin.value())
+            args.alpha = float(self.fft_alpha_spin.value())
+            args.radial_smooth = int(self.radial_smooth_spin.value())
+            args.sim_camera = sim_camera
+            args.no_no_bayer = bool(enable_bayer)
+            args.jpeg_cycles = int(self.jpeg_cycles_spin.value())
+            args.jpeg_qmin = int(self.jpeg_qmin_spin.value())
+            args.jpeg_qmax = int(self.jpeg_qmax_spin.value())
+            args.vignette_strength = float(self.vignette_spin.value())
+            args.chroma_strength = float(self.chroma_spin.value())
+            args.iso_scale = float(self.iso_spin.value())
+            args.read_noise = float(self.read_noise_spin.value())
+            args.hot_pixel_prob = float(self.hot_pixel_spin.value())
+            args.banding_strength = float(self.banding_spin.value())
+            args.motion_blur_kernel = int(self.motion_blur_spin.value())
+
+        # AWB handling to match the new --awb flag in the backend
+        if self.awb_chk.isChecked():
+            args.awb = True
+            args.ref = awb_ref_val  # This can be the path or None (for grey-world)
+        else:
+            args.awb = False
+            args.ref = None
+
+        # FFT spectral matching reference
+        args.fft_ref = fft_ref_val
+
+        # LUT handling: only include if LUT checkbox is checked and a path is provided
+        if self.lut_chk.isChecked():
+            lut_path = self.lut_line.text().strip()
+            args.lut = lut_path if lut_path else None
+            args.lut_strength = float(self.lut_strength_spin.value())
+        else:
+            args.lut = None
+            args.lut_strength = 1.0
+
+        self.worker = Worker(inpath, outpath, args)
+        self.worker.finished.connect(self.on_finished)
+        self.worker.error.connect(self.on_error)
+        self.worker.started.connect(lambda: self.on_worker_started())
+        self.worker.start()
+
+        self.progress.setRange(0, 0)
+        self.status.setText("Processing...")
+        self.set_enabled_all(False)
+
+    def on_worker_started(self):
+        pass
+
+    def on_finished(self, outpath):
+        self.progress.setRange(0, 100)
+        self.progress.setValue(100)
+        self.status.setText("Done — saved to: " + outpath)
+        self.load_preview(self.preview_out, outpath)
+        self.analysis_output.update_from_path(outpath)
+        self.set_enabled_all(True)
+
+    def on_error(self, msg, traceback_text):
+        from PyQt5.QtWidgets import QDialog, QTextEdit
+        self.progress.setRange(0, 100)
+        self.progress.setValue(0)
+        self.status.setText("Error")
+
+        dialog = QDialog(self)
+        dialog.setWindowTitle("Processing Error")
+        dialog.setMinimumSize(700, 480)
+        layout = QVBoxLayout(dialog)
+
+        error_label = QLabel(f"Error: {msg}")
+        error_label.setWordWrap(True)
+        layout.addWidget(error_label)
+
+        traceback_edit = QTextEdit()
+        traceback_edit.setReadOnly(True)
+        traceback_edit.setText(traceback_text)
+        traceback_edit.setStyleSheet("font-family: monospace; font-size: 12px;")
+        layout.addWidget(traceback_edit)
+
+        ok_button = QPushButton("OK")
+        ok_button.clicked.connect(dialog.accept)
+        layout.addWidget(ok_button)
+
+        dialog.exec_()
+        self.set_enabled_all(True)
+
+    def open_output_folder(self):
+        out = self.output_line.text().strip()
+        if not out:
+            QMessageBox.information(self, "No output", "No output path set yet.")
+            return
+        folder = os.path.dirname(os.path.abspath(out))
+        if not os.path.exists(folder):
+            QMessageBox.warning(self, "Not found", "Output folder does not exist: " + folder)
+            return
+        if sys.platform.startswith('darwin'):
+            os.system(f'open "{folder}"')
+        elif os.name == 'nt':
+            os.startfile(folder)
+        else:
+            os.system(f'xdg-open "{folder}"')