File modularization

image_postprocess/processor.py

@@ -172,7 +172,7 @@ def build_argparser():
 
     # LUT options
     p.add_argument('--lut', type=str, default=None, help='Path to a 1D PNG (256x1) or .npy LUT, or a .cube 3D LUT')
-    p.add_argument('--lut-strength', type=float, default=1.0, help='Strength to blend LUT (0.0 = no effect, 1.0 = full LUT)')
+    p.add_argument('--lut-strength', type=float, default=0.1, help='Strength to blend LUT (0.0 = no effect, 1.0 = full LUT)')
 
     return p
 

image_postprocess/utils.py

@@ -1,456 +0,0 @@
-"""
-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

run.py

@@ -1,613 +1,34 @@
 #!/usr/bin/env python3
 """
-Main GUI application for image_postprocess pipeline with camera-simulator controls.
-
-Updated: added LUT support UI (enable checkbox, file chooser, strength) and wiring to on_run.
+Entry point for Image Postprocess GUI (camera simulator).
+Handles the import check for image_postprocess and launches the MainWindow.
 """
 
 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 PyQt5.QtWidgets import QApplication, QMessageBox
 from theme import apply_dark_palette
 
 try:
     from image_postprocess import process_image
 except Exception as e:
-    process_image = None
     IMPORT_ERROR = str(e)
 else:
     IMPORT_ERROR = None
 
-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 # Not strictly necessary as backend ignores it, but good practice
-
-        # 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}"')
+from main_window import MainWindow
 
 def main():
     app = QApplication([])
     apply_dark_palette(app)
+
     if IMPORT_ERROR:
-        QMessageBox.critical(None, "Import error", "Could not import image_postprocess module:\n" + IMPORT_ERROR)
+        QMessageBox.critical(None, "Import error",
+                             "Could not import image_postprocess module:\n" + IMPORT_ERROR)
+
     w = MainWindow()
     w.show()
     sys.exit(app.exec_())
 
 if __name__ == '__main__':
-    main()
+    main()