Add files

README.md

@@ -0,0 +1 @@
+# Image-Detection-Bypass-Utility

analysis_panel.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+Analysis panel for histogram, FFT, and radial profile plots.
+"""
+
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QSizePolicy
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+import numpy as np
+import os
+from utils import compute_gray_array, compute_fft_magnitude, radial_profile, make_canvas
+
+class AnalysisPanel(QWidget):
+    def __init__(self, title="Analysis", parent=None):
+        super().__init__(parent)
+        v = QVBoxLayout(self)
+        box = QGroupBox(title)
+        vbox = QVBoxLayout()
+        box.setLayout(vbox)
+
+        row = QHBoxLayout()
+        self.hist_canvas, self.hist_ax = make_canvas(width=3, height=2)
+        self.fft_canvas, self.fft_ax = make_canvas(width=3, height=2)
+        self.radial_canvas, self.radial_ax = make_canvas(width=3, height=2)
+
+        for c in (self.hist_canvas, self.fft_canvas, self.radial_canvas):
+            c.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+
+        row.addWidget(self.hist_canvas)
+        row.addWidget(self.fft_canvas)
+        row.addWidget(self.radial_canvas)
+
+        vbox.addLayout(row)
+        v.addWidget(box)
+
+    def update_from_path(self, path):
+        if not path or not os.path.exists(path):
+            self.clear_plots()
+            return
+        try:
+            gray = compute_gray_array(path)
+        except Exception:
+            self.clear_plots()
+            return
+
+        # Histogram
+        self.hist_ax.cla()
+        self.hist_ax.set_title('Grayscale histogram')
+        self.hist_ax.set_xlabel('Intensity')
+        self.hist_ax.set_ylabel('Count')
+        self.hist_ax.hist(gray.ravel(), bins=256)
+        self.hist_canvas.draw()
+
+        # FFT magnitude
+        mag, mag_log = compute_fft_magnitude(gray)
+        self.fft_ax.cla()
+        self.fft_ax.set_title('FFT magnitude (log)')
+        self.fft_ax.imshow(mag_log, origin='lower', aspect='auto')
+        self.fft_canvas.figure.subplots_adjust(right=0.85)
+        self.fft_canvas.draw()
+
+        # Radial profile
+        centers, radial = radial_profile(mag)
+        self.radial_ax.cla()
+        self.radial_ax.set_title('Radial freq profile')
+        self.radial_ax.set_xlabel('Normalized radius')
+        self.radial_ax.set_ylabel('Mean magnitude')
+        self.radial_ax.plot(centers, radial)
+        self.radial_canvas.draw()
+
+    def clear_plots(self):
+        for ax, canvas in ((self.hist_ax, self.hist_canvas), (self.fft_ax, self.fft_canvas), (self.radial_ax, self.radial_canvas)):
+            ax.cla()
+            canvas.draw()

image_postprocess/__init__.py

@@ -0,0 +1,3 @@
+from .image_postprocess_with_camera_pipeline import process_image
+
+__all__ = ['process_image']

image_postprocess/camera_pipeline.py

@@ -0,0 +1,255 @@
+"""
+camera_pipeline.py
+
+Functions for simulating a realistic camera pipeline, including Bayer mosaic/demosaic,
+chromatic aberration, vignette, sensor noise, hot pixels, banding, motion blur, and JPEG recompression.
+"""
+
+from io import BytesIO
+from PIL import Image
+import numpy as np
+try:
+    import cv2
+    _HAS_CV2 = True
+except Exception:
+    cv2 = None
+    _HAS_CV2 = False
+from scipy.ndimage import convolve
+
+def _bayer_mosaic(img: np.ndarray, pattern='RGGB') -> np.ndarray:
+    """Create a single-channel Bayer mosaic from an RGB image.
+
+    pattern currently supports 'RGGB' (most common). Returns uint8 2D array.
+    """
+    h, w = img.shape[:2]
+    mosaic = np.zeros((h, w), dtype=np.uint8)
+
+    # pattern mapping for RGGB:
+    # (0,0) R, (0,1) G
+    # (1,0) G, (1,1) B
+    R = img[:, :, 0]
+    G = img[:, :, 1]
+    B = img[:, :, 2]
+
+    # fill mosaic according to RGGB
+    mosaic[0::2, 0::2] = R[0::2, 0::2]
+    mosaic[0::2, 1::2] = G[0::2, 1::2]
+    mosaic[1::2, 0::2] = G[1::2, 0::2]
+    mosaic[1::2, 1::2] = B[1::2, 1::2]
+    return mosaic
+
+def _demosaic_bilinear(mosaic: np.ndarray) -> np.ndarray:
+    """Simple bilinear demosaic fallback (no cv2). Outputs RGB uint8 image.
+
+    Not perfect but good enough to add demosaic artifacts.
+    """
+    h, w = mosaic.shape
+    # Work in float to avoid overflow
+    m = mosaic.astype(np.float32)
+
+    # We'll compute each channel by averaging available mosaic samples
+    R = np.zeros_like(m)
+    G = np.zeros_like(m)
+    B = np.zeros_like(m)
+
+    # RGGB pattern
+    R[0::2, 0::2] = m[0::2, 0::2]
+    G[0::2, 1::2] = m[0::2, 1::2]
+    G[1::2, 0::2] = m[1::2, 0::2]
+    B[1::2, 1::2] = m[1::2, 1::2]
+
+    # Convolution kernels for interpolation (simple)
+    k_cross = np.array([[0, 1, 0], [1, 4, 1], [0, 1, 0]], dtype=np.float32) / 8.0
+    k_diag = np.array([[1, 0, 1], [0, 0, 0], [1, 0, 1]], dtype=np.float32) / 4.0
+
+    # convolve using scipy.ndimage.convolve
+    R_interp = convolve(R, k_cross, mode='mirror')
+    G_interp = convolve(G, k_cross, mode='mirror')
+    B_interp = convolve(B, k_cross, mode='mirror')
+
+    out = np.stack((R_interp, G_interp, B_interp), axis=2)
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out
+
+def _apply_chromatic_aberration(img: np.ndarray, strength=1.0, seed=None):
+    """Shift R and B channels slightly in opposite directions to emulate CA.
+
+    strength is in pixels (float). Uses cv2.warpAffine if available; integer
+    fallback uses np.roll.
+    """
+    if seed is not None:
+        rng = np.random.default_rng(seed)
+    else:
+        rng = np.random.default_rng()
+
+    h, w = img.shape[:2]
+    max_shift = max(1.0, strength)
+    # small random subpixel shift sampled from normal distribution
+    shift_r = rng.normal(loc=0.0, scale=max_shift * 0.6)
+    shift_b = rng.normal(loc=0.0, scale=max_shift * 0.6)
+    # apply opposite horizontal shifts to R and B for lateral CA
+    r_x = shift_r
+    r_y = rng.normal(scale=0.3 * abs(shift_r))
+    b_x = -shift_b
+    b_y = rng.normal(scale=0.3 * abs(shift_b))
+
+    out = img.copy().astype(np.float32)
+    if _HAS_CV2:
+        def warp_channel(ch, tx, ty):
+            M = np.array([[1, 0, tx], [0, 1, ty]], dtype=np.float32)
+            return cv2.warpAffine(ch, M, (w, h), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT)
+        out[:, :, 0] = warp_channel(out[:, :, 0], r_x, r_y)
+        out[:, :, 2] = warp_channel(out[:, :, 2], b_x, b_y)
+    else:
+        # integer fallback
+        ix_r = int(round(r_x))
+        iy_r = int(round(r_y))
+        ix_b = int(round(b_x))
+        iy_b = int(round(b_y))
+        out[:, :, 0] = np.roll(out[:, :, 0], shift=(iy_r, ix_r), axis=(0, 1))
+        out[:, :, 2] = np.roll(out[:, :, 2], shift=(iy_b, ix_b), axis=(0, 1))
+
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out
+
+def _apply_vignette(img: np.ndarray, strength=0.4):
+    h, w = img.shape[:2]
+    y = np.linspace(-1, 1, h)[:, None]
+    x = np.linspace(-1, 1, w)[None, :]
+    r = np.sqrt(x * x + y * y)
+    mask = 1.0 - (r ** 2) * strength
+    mask = np.clip(mask, 0.0, 1.0)
+    out = (img.astype(np.float32) * mask[:, :, None])
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out
+
+def _add_poisson_gaussian_noise(img: np.ndarray, iso_scale=1.0, read_noise_std=2.0, seed=None):
+    """Poisson-Gaussian sensor noise model.
+
+    iso_scale scales the signal before Poisson sampling (higher -> more Poisson),
+    read_noise_std is the sigma (in DN) of additive Gaussian read noise.
+    """
+    if seed is not None:
+        rng = np.random.default_rng(seed)
+    else:
+        rng = np.random.default_rng()
+
+    img_f = img.astype(np.float32)
+    # scale to simulate exposure/iso
+    scaled = img_f * iso_scale
+    # Poisson: we need integer counts; scale to a reasonable photon budget
+    # choose scale so that typical pixel values map to ~[0..2000] photons
+    photon_scale = 4.0
+    lam = np.clip(scaled * photon_scale, 0, 1e6)
+    noisy = rng.poisson(lam).astype(np.float32) / photon_scale
+    # add read noise
+    noisy += rng.normal(loc=0.0, scale=read_noise_std, size=noisy.shape)
+    noisy = np.clip(noisy, 0, 255).astype(np.uint8)
+    return noisy
+
+def _add_hot_pixels_and_banding(img: np.ndarray, hot_pixel_prob=1e-6, banding_strength=0.0, seed=None):
+    if seed is not None:
+        rng = np.random.default_rng(seed)
+    else:
+        rng = np.random.default_rng()
+
+    h, w = img.shape[:2]
+    out = img.copy().astype(np.float32)
+    # hot pixels
+    n_pixels = int(h * w * hot_pixel_prob)
+    if n_pixels > 0:
+        ys = rng.integers(0, h, size=n_pixels)
+        xs = rng.integers(0, w, size=n_pixels)
+        vals = rng.integers(200, 256, size=n_pixels)
+        for y, x, v in zip(ys, xs, vals):
+            out[y, x, :] = v
+    # banding: add low-amplitude sinusoidal horizontal banding
+    if banding_strength > 0.0:
+        rows = np.arange(h)[:, None]
+        band = (np.sin(rows * 0.5) * 255.0 * banding_strength)
+        out += band[:, :, None]
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out
+
+def _motion_blur(img: np.ndarray, kernel_size=5):
+    if kernel_size <= 1:
+        return img
+    # simple linear motion kernel horizontally
+    kernel = np.zeros((kernel_size, kernel_size), dtype=np.float32)
+    kernel[kernel_size // 2, :] = 1.0 / kernel_size
+    out = np.zeros_like(img)
+    for c in range(3):
+        out[:, :, c] = convolve(img[:, :, c].astype(np.float32), kernel, mode='mirror')
+    out = np.clip(out, 0, 255).astype(np.uint8)
+    return out
+
+def _jpeg_recompress(img: np.ndarray, quality=90) -> np.ndarray:
+    pil = Image.fromarray(img)
+    buf = BytesIO()
+    pil.save(buf, format='JPEG', quality=int(quality), optimize=False)
+    buf.seek(0)
+    rec = Image.open(buf).convert('RGB')
+    return np.array(rec)
+
+def simulate_camera_pipeline(img_arr: np.ndarray,
+                             bayer=True,
+                             jpeg_cycles=1,
+                             jpeg_quality_range=(88, 96),
+                             vignette_strength=0.35,
+                             chroma_aberr_strength=1.2,
+                             iso_scale=1.0,
+                             read_noise_std=2.0,
+                             hot_pixel_prob=1e-6,
+                             banding_strength=0.0,
+                             motion_blur_kernel=1,
+                             seed=None):
+    """Apply a set of realistic camera/capture artifacts to img_arr (RGB uint8).
+
+    Returns an RGB uint8 image.
+    """
+    if seed is not None:
+        rng = np.random.default_rng(seed)
+    else:
+        rng = np.random.default_rng()
+
+    out = img_arr.copy()
+
+    # 1) Bayer mosaic + demosaic (if enabled)
+    if bayer:
+        try:
+            mosaic = _bayer_mosaic(out[:, :, ::-1])  # we built mosaic assuming R,G,B order; send RGB
+            if _HAS_CV2:
+                # cv2 expects a single-channel Bayer and provides demosaicing codes
+                # We'll use RGGB code (COLOR_BAYER_RG2BGR) so convert back to RGB after
+                dem = cv2.demosaicing(mosaic, cv2.COLOR_BAYER_RG2BGR)
+                # cv2 returns BGR
+                dem = dem[:, :, ::-1]
+                out = dem
+            else:
+                out = _demosaic_bilinear(mosaic)
+        except Exception:
+            # if anything fails, keep original
+            out = img_arr.copy()
+
+    # 2) chromatic aberration
+    out = _apply_chromatic_aberration(out, strength=chroma_aberr_strength, seed=seed)
+
+    # 3) vignette
+    out = _apply_vignette(out, strength=vignette_strength)
+
+    # 4) noise (Poisson-Gaussian)
+    out = _add_poisson_gaussian_noise(out, iso_scale=iso_scale, read_noise_std=read_noise_std, seed=seed)
+
+    # 5) hot pixels and banding
+    out = _add_hot_pixels_and_banding(out, hot_pixel_prob=hot_pixel_prob, banding_strength=banding_strength, seed=seed)
+
+    # 6) motion blur
+    if motion_blur_kernel and motion_blur_kernel > 1:
+        out = _motion_blur(out, kernel_size=motion_blur_kernel)
+
+    # 7) JPEG recompression cycles
+    for i in range(max(1, int(jpeg_cycles))):
+        q = int(rng.integers(jpeg_quality_range[0], jpeg_quality_range[1] + 1))
+        out = _jpeg_recompress(out, quality=q)
+
+    return out

image_postprocess/image_postprocess_with_camera_pipeline.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+image_postprocess_with_camera_pipeline.py
+
+Main pipeline for image postprocessing with an optional realistic camera-pipeline simulator.
+This file retains the original interface for CLI and imports, ensuring compatibility with existing code.
+Imports helper functions and camera pipeline simulation from separate modules.
+"""
+
+import argparse
+import os
+from PIL import Image
+import numpy as np
+
+from .utils import remove_exif_pil, add_gaussian_noise, clahe_color_correction, randomized_perturbation, fourier_match_spectrum
+from .camera_pipeline import simulate_camera_pipeline
+
+def process_image(path_in, path_out, args):
+    img = Image.open(path_in).convert('RGB')
+    img = remove_exif_pil(img)
+    arr = np.array(img)
+
+    arr = clahe_color_correction(arr, clip_limit=args.clahe_clip, tile_grid_size=(args.tile, args.tile))
+
+    ref_arr = None
+    if args.fft_ref:
+        ref_img = Image.open(args.fft_ref).convert('RGB')
+        ref_arr = np.array(ref_img)
+
+    arr = fourier_match_spectrum(arr, ref_img_arr=ref_arr, mode=args.fft_mode,
+                                 alpha=args.fft_alpha, cutoff=args.cutoff,
+                                 strength=args.fstrength, randomness=args.randomness,
+                                 phase_perturb=args.phase_perturb, radial_smooth=args.radial_smooth,
+                                 seed=args.seed)
+
+    arr = add_gaussian_noise(arr, std_frac=args.noise_std, seed=args.seed)
+    arr = randomized_perturbation(arr, magnitude_frac=args.perturb, seed=args.seed)
+
+    # call the camera simulator if requested
+    if args.sim_camera:
+        arr = simulate_camera_pipeline(arr,
+                                       bayer=not args.no_no_bayer,
+                                       jpeg_cycles=args.jpeg_cycles,
+                                       jpeg_quality_range=(args.jpeg_qmin, args.jpeg_qmax),
+                                       vignette_strength=args.vignette_strength,
+                                       chroma_aberr_strength=args.chroma_strength,
+                                       iso_scale=args.iso_scale,
+                                       read_noise_std=args.read_noise,
+                                       hot_pixel_prob=args.hot_pixel_prob,
+                                       banding_strength=args.banding_strength,
+                                       motion_blur_kernel=args.motion_blur_kernel,
+                                       seed=args.seed)
+
+    out_img = Image.fromarray(arr)
+    out_img.save(path_out)
+
+def build_argparser():
+    p = argparse.ArgumentParser(description="Image postprocessing pipeline with camera simulation")
+    p.add_argument('input', help='Input image path')
+    p.add_argument('output', help='Output image path')
+    p.add_argument('--ref', help='Optional reference image for color matching (not implemented)', default=None)
+    p.add_argument('--noise-std', type=float, default=0.02, help='Gaussian noise std fraction of 255 (0-0.1)')
+    p.add_argument('--clahe-clip', type=float, default=2.0, help='CLAHE clip limit')
+    p.add_argument('--tile', type=int, default=8, help='CLAHE tile grid size')
+    p.add_argument('--cutoff', type=float, default=0.25, help='Fourier cutoff (0..1)')
+    p.add_argument('--fstrength', type=float, default=0.9, help='Fourier blend strength (0..1)')
+    p.add_argument('--randomness', type=float, default=0.05, help='Randomness for Fourier mask modulation')
+    p.add_argument('--perturb', type=float, default=0.008, help='Randomized perturb magnitude fraction (0..0.05)')
+    p.add_argument('--seed', type=int, default=None, help='Random seed for reproducibility')
+
+    # FFT-matching options
+    p.add_argument('--fft-ref', help='Optional reference image for FFT spectral matching', default=None)
+    p.add_argument('--fft-mode', choices=('auto','ref','model'), default='auto', help='FFT mode: auto picks ref if available')
+    p.add_argument('--fft-alpha', type=float, default=1.0, help='Alpha for 1/f model (spectrum slope)')
+    p.add_argument('--phase-perturb', type=float, default=0.08, help='Phase perturbation strength (radians)')
+    p.add_argument('--radial-smooth', type=int, default=5, help='Radial smoothing (bins) for spectrum profiles')
+
+    # Camera-simulator options
+    p.add_argument('--sim-camera', action='store_true', help='Enable camera-pipeline simulation (Bayer, CA, vignette, JPEG cycles)')
+    p.add_argument('--no-no-bayer', dest='no_no_bayer', action='store_false', help='Disable Bayer/demosaic step (double negative kept for backward compat)')
+    p.set_defaults(no_no_bayer=True)
+    p.add_argument('--jpeg-cycles', type=int, default=1, help='Number of JPEG recompression cycles to apply')
+    p.add_argument('--jpeg-qmin', type=int, default=88, help='Min JPEG quality for recompression')
+    p.add_argument('--jpeg-qmax', type=int, default=96, help='Max JPEG quality for recompression')
+    p.add_argument('--vignette-strength', type=float, default=0.35, help='Vignette strength (0..1)')
+    p.add_argument('--chroma-strength', type=float, default=1.2, help='Chromatic aberration strength (pixels)')
+    p.add_argument('--iso-scale', type=float, default=1.0, help='ISO/exposure scale for Poisson noise')
+    p.add_argument('--read-noise', type=float, default=2.0, help='Read noise sigma for sensor noise')
+    p.add_argument('--hot-pixel-prob', type=float, default=1e-6, help='Per-pixel probability of hot pixel')
+    p.add_argument('--banding-strength', type=float, default=0.0, help='Horizontal banding amplitude (0..1)')
+    p.add_argument('--motion-blur-kernel', type=int, default=1, help='Motion blur kernel size (1 = none)')
+
+    return p
+
+if __name__ == "__main__":
+    args = build_argparser().parse_args()
+    if not os.path.exists(args.input):
+        print("Input not found:", args.input)
+        raise SystemExit(2)
+    process_image(args.input, args.output, args)
+    print("Saved:", args.output)

image_postprocess/utils.py

@@ -0,0 +1,207 @@
+"""
+utils.py
+
+Helper functions for image postprocessing, including EXIF removal, noise addition,
+color correction, and Fourier spectrum matching.
+"""
+
+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

image_postprocess_gui.py

@@ -0,0 +1,510 @@
+#!/usr/bin/env python3
+"""
+Main GUI application for image_postprocess pipeline with camera-simulator controls.
+"""
+
+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, QGroupBox, QLineEdit, QComboBox, QCheckBox
+)
+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
+
+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 (with 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)
+
+        in_group = QGroupBox("Input / Output")
+        left_v.addWidget(in_group)
+        in_layout = QFormLayout()
+        in_group.setLayout(in_layout)
+
+        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 Reference (optional)")
+        self.ref_btn.clicked.connect(self.choose_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.output_btn, self.output_line)
+
+        # Previews
+        self.preview_in = QLabel(alignment=Qt.AlignCenter)
+        self.preview_in.setFixedSize(480, 300)
+        self.preview_in.setStyleSheet("background:#111; border:1px solid #444; color:#ddd")
+        self.preview_in.setText("Input preview")
+
+        self.preview_out = QLabel(alignment=Qt.AlignCenter)
+        self.preview_out.setFixedSize(480, 300)
+        self.preview_out.setStyleSheet("background:#111; border:1px solid #444; color:#ddd")
+        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
+        right_v = QVBoxLayout()
+        main_h.addLayout(right_v, 3)
+
+        # Auto Mode controls
+        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)
+
+        self.auto_group = QGroupBox("Auto Mode")
+        auto_layout = QFormLayout()
+        self.auto_group.setLayout(auto_layout)
+        
+        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)
+        right_v.addWidget(self.auto_group)
+
+        self.params_group = QGroupBox("Parameters (Manual Mode)")
+        right_v.addWidget(self.params_group)
+        params_layout = QFormLayout()
+        self.params_group.setLayout(params_layout)
+
+        # 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)
+
+        # 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)
+
+        # Camera simulator group
+        self.camera_group = QGroupBox("Camera simulator options")
+        cam_layout = QFormLayout()
+        self.camera_group.setLayout(cam_layout)
+
+        # 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_group.setVisible(False)
+        right_v.addWidget(self.camera_group)
+
+        params_layout.addRow(self.camera_group)
+
+        self.ref_hint = QLabel("Reference color matching supported by OpenCV only.")
+        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_group.setVisible(enabled)
+
+    def _on_auto_mode_toggled(self, state):
+        is_auto = (state == Qt.Checked)
+        self.auto_group.setVisible(is_auto)
+        self.params_group.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 reference image", str(Path.home()), "Images (*.png *.jpg *.jpeg *.bmp *.tif)")
+        if path:
+            self.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 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)):
+            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
+
+        ref_val = self.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())
+
+        args.ref = None
+        args.fft_ref = ref_val
+
+        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, QVBoxLayout
+        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}"')
+
+def main():
+    app = QApplication([])
+    if 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()

utils.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""
+Utility functions for image processing GUI.
+"""
+
+from PyQt5.QtGui import QPixmap
+from PyQt5.QtCore import Qt
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+from PIL import Image
+import numpy as np
+
+def qpixmap_from_path(p: str, max_size=(480, 360)) -> QPixmap:
+    pix = QPixmap(p)
+    if pix.isNull():
+        return QPixmap()
+    w, h = max_size
+    return pix.scaled(w, h, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+
+def make_canvas(width=4, height=3, dpi=100):
+    fig = Figure(figsize=(width, height), dpi=dpi)
+    canvas = FigureCanvas(fig)
+    ax = fig.add_subplot(111)
+    fig.tight_layout()
+    return canvas, ax
+
+def compute_gray_array(path):
+    img = Image.open(path).convert('RGB')
+    arr = np.array(img)
+    gray = (0.299 * arr[:, :, 0] + 0.587 * arr[:, :, 1] + 0.114 * arr[:, :, 2]).astype(np.float32)
+    return gray
+
+def compute_fft_magnitude(gray_arr, eps=1e-8):
+    f = np.fft.fft2(gray_arr)
+    fshift = np.fft.fftshift(f)
+    mag = np.abs(fshift)
+    mag_log = np.log1p(mag)
+    return mag, mag_log
+
+def radial_profile(mag, center=None, nbins=100):
+    h, w = mag.shape
+    if center is None:
+        center = (int(h / 2), int(w / 2))
+    y, x = np.indices((h, w))
+    r = np.sqrt((x - center[1]) ** 2 + (y - center[0]) ** 2)
+    r_flat = r.ravel()
+    mag_flat = mag.ravel()
+    max_r = np.max(r_flat)
+    if max_r <= 0:
+        return np.linspace(0, 1, nbins), np.zeros(nbins)
+    bins = np.linspace(0, max_r, nbins + 1)
+    inds = np.digitize(r_flat, bins) - 1
+    radial_mean = np.zeros(nbins)
+    for i in range(nbins):
+        sel = inds == i
+        if np.any(sel):
+            radial_mean[i] = mag_flat[sel].mean()
+        else:
+            radial_mean[i] = 0.0
+    centers = 0.5 * (bins[:-1] + bins[1:]) / max_r
+    return centers, radial_mean

worker.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""
+Worker thread for image processing.
+"""
+
+from PyQt5.QtCore import QThread, pyqtSignal
+import traceback
+
+try:
+    from image_postprocess import process_image
+except Exception:
+    process_image = None
+    IMPORT_ERROR = "Could not import process_image module"
+else:
+    IMPORT_ERROR = None
+
+class Worker(QThread):
+    finished = pyqtSignal(str)
+    error = pyqtSignal(str, str)  # error message + traceback
+
+    def __init__(self, inpath, outpath, args):
+        super().__init__()
+        self.inpath = inpath
+        self.outpath = outpath
+        self.args = args
+
+    def run(self):
+        try:
+            if process_image is None:
+                raise RuntimeError("Could not import process_image: " + (IMPORT_ERROR or "unknown"))
+            process_image(self.inpath, self.outpath, self.args)
+            self.finished.emit(self.outpath)
+        except Exception as e:
+            tb = traceback.format_exc()
+            self.error.emit(str(e), tb)