Refactored for Gradio / HF Spaces usage.

- Introduced `app_gradio.py` for a lightweight Gradio front-end to the image processing pipeline.
- Updated README.md with instructions for running the Gradio app locally and deploying to Hugging Face Spaces.
- Fixed channel reversal issue in camera pipeline simulation.
- Updated requirements.txt to include Gradio and removed PyQt5.
- Added test scripts for Gradio functionality and processing validation.

README.md

@@ -151,6 +151,50 @@ def process_image(inpath: str, outpath: str, args):
 - PRs welcome. If you modify UI layout or parameter names, keep the `args` mapping consistent or update `README` and `worker.py` accordingly.  
 - Add unit tests for `worker.py` and the parameter serialization if you intend to refactor.
 
+## Gradio / Hugging Face Spaces (Web UI)
+
+This repository includes a lightweight Gradio front-end (`app_gradio.py`) that wraps the existing
+`process_image(inpath, outpath, args)` pipeline. The Gradio app is suitable for local testing and
+for deployment to Hugging Face Spaces (Gradio-backed web apps).
+
+### Quick local run
+
+1. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+2. Launch the Gradio app:
+
+```bash
+python3 app_gradio.py
+```
+
+Open http://localhost:7860 in your browser. The UI saves the uploaded image to a temporary file,
+calls the existing `process_image` pipeline, and returns the processed image.
+
+### Deploying to Hugging Face Spaces
+
+1. Ensure the following are present at the repository root:
+     - `app_gradio.py` (the Gradio entrypoint)
+     - `requirements.txt` (must include `gradio` and any other runtime deps)
+
+2. Push the repository to a new Space on Hugging Face (create a new Space and connect this repo or
+     push to the Space's Git remote). Spaces will automatically run the Gradio app.
+
+Notes & tips for Spaces:
+- Keep default upload/processing sizes modest to avoid long CPU usage in the free tier.
+- If your pipeline uses optional packages (OpenCV, piexif, etc.), make sure they are listed in
+    `requirements.txt` so Spaces installs them.
+- If processing is slow, consider reducing default image size or exposing fewer parameters to the
+    main UI and keeping advanced controls hidden in an "Advanced" section.
+
+### Troubleshooting
+- If Gradio is not installed, `app_gradio.py` will raise an error; add `gradio` to `requirements.txt`.
+- Any import errors from `image_postprocess` will surface when calling the app; run the smoke test
+    (`python3 test_smoke_gradio.py`) locally to validate imports and pipeline execution before pushing.
+
 ---
 
 ## License

app_gradio.py

@@ -0,0 +1,661 @@
+"""
+Gradio web UI wrapper for the Image Postprocess pipeline.
+
+This lightweight wrapper saves the uploaded image to a temporary file,
+constructs a minimal args namespace expected by `process_image`, runs the
+processing pipeline, and returns the result to the browser.
+
+Designed for quick deployment on Huggingface Spaces.
+"""
+from pathlib import Path
+import tempfile
+import os
+from types import SimpleNamespace
+from typing import Optional
+from PIL import Image
+import io
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+# Preset persistence file (in repo root)
+PRESETS_FILE = Path(__file__).parent / "presets.json"
+
+# Builtin presets
+BUILTIN_PRESETS = {
+    "Default": {},
+    "NovaNodes (reference)": {
+    "noise_std": 0.02,
+    "clahe_clip": 2.0,
+    "tile": 8,
+    "cutoff": 0.25,
+    "fstrength": 0.9,
+    "randomness": 0.05,
+    # align perturb with NovaNodes default
+    "perturb": 0.01,
+    "phase_perturb": 0.08,
+    "radial_smooth": 5,
+    "jpeg_cycles": 1,
+    "jpeg_qmin": 88,
+    # camera simulation enabled by default for 'reference'
+    "sim_camera": True,
+    "vignette_strength": 0.35,
+    "chroma_strength": 1.2,
+    "iso_scale": 1.0,
+    "read_noise": 2.0,
+    # align hot pixel probability with NovaNodes default
+    "hot_pixel_prob": 1e-7,
+    "no_no_bayer": False,
+    # align LUT strength to node default (1.0)
+    "lut_strength": 1.0,
+    },
+    "High JPEG cycles": {"jpeg_cycles": 3, "jpeg_qmin": 70},
+    "Aggressive": {"noise_std": 0.06, "fstrength": 1.0, "perturb": 0.02, "jpeg_cycles": 2},
+    "Subtle": {"noise_std": 0.01, "fstrength": 0.6},
+
+    # Conservative preview preset (closer to input image): disables camera simulation
+    "Preview (no camera sim)": {"sim_camera": False, "noise_std": 0.01, "fstrength": 0.6},
+}
+
+
+def load_custom_presets():
+    if PRESETS_FILE.exists():
+        try:
+            return json.loads(PRESETS_FILE.read_text())
+        except Exception:
+            return {}
+    return {}
+
+
+def save_custom_preset(name: str, data: dict):
+    presets = load_custom_presets()
+    presets[name] = data
+    PRESETS_FILE.write_text(json.dumps(presets, indent=2))
+
+
+def get_preset_overrides(name: str):
+    if name in BUILTIN_PRESETS:
+        return BUILTIN_PRESETS[name].copy()
+    customs = load_custom_presets()
+    return customs.get(name, {}).copy()
+
+
+def preset_summary(name: str):
+    overrides = get_preset_overrides(name)
+    if not overrides:
+        return "(no overrides)"
+    return json.dumps(overrides, indent=2)
+
+gr = None
+
+try:
+    from image_postprocess import process_image
+except Exception as e:
+    process_image = None
+    IMPORT_ERROR = str(e)
+else:
+    IMPORT_ERROR = None
+
+
+def _mk_temp_file(suffix: str = ".png") -> str:
+    f = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
+    f.close()
+    return f.name
+
+
+def run_process(
+    img: Image.Image,
+    noise_std: float = 0.02,
+    clahe_clip: float = 2.0,
+    tile: int = 8,
+    cutoff: float = 0.25,
+    fstrength: float = 0.9,
+    awb: bool = True,
+    sim_camera: bool = True,
+    lut_file: Optional[Path] = None,
+    lut_strength: float = 0.1,
+):
+    """Run the repository's processing pipeline on a PIL image and return a PIL image.
+
+    Returns (pil.Image or None, status string).
+    """
+    if process_image is None:
+        return None, f"Backend import error: {IMPORT_ERROR}"
+
+    tmp_files = []
+    try:
+        in_path = _mk_temp_file(suffix=".png")
+        img.save(in_path)
+        tmp_files.append(in_path)
+
+        out_path = _mk_temp_file(suffix=".jpg")
+        tmp_files.append(out_path)
+
+        lut_path = None
+        if lut_file is not None:
+            # gr.File gives a pathlib.Path-like object; accept either str or Path
+            lut_path = str(lut_file)
+
+        args = SimpleNamespace(
+            input=in_path,
+            output=out_path,
+            awb=bool(awb),
+            ref=None,
+            noise_std=float(noise_std),
+            clahe_clip=float(clahe_clip),
+            tile=int(tile),
+            cutoff=float(cutoff),
+            fstrength=float(fstrength),
+            randomness=0.05,
+            perturb=0.008,
+            seed=None,
+            fft_ref=None,
+            fft_mode="auto",
+            fft_alpha=1.0,
+            phase_perturb=0.08,
+            radial_smooth=5,
+            sim_camera=bool(sim_camera),
+            no_no_bayer=False,
+            jpeg_cycles=1,
+            jpeg_qmin=88,
+            jpeg_qmax=96,
+            vignette_strength=0.35,
+            chroma_strength=1.2,
+            iso_scale=1.0,
+            read_noise=2.0,
+            hot_pixel_prob=1e-6,
+            banding_strength=0.0,
+            motion_blur_kernel=1,
+            lut=(lut_path if lut_path else None),
+            lut_strength=float(lut_strength),
+        )
+
+        # Debug: print args passed to process_image for tracing
+        try:
+            print("process_image called with args:")
+            for k, v in vars(args).items():
+                print(f"  {k}: {v}")
+        except Exception:
+            pass
+
+        try:
+            process_image(in_path, out_path, args)
+        except Exception as e:
+            return None, f"Processing error: {e}"
+
+        out_img = Image.open(out_path).convert("RGB")
+        return out_img, "OK"
+
+    finally:
+        for p in tmp_files:
+            try:
+                os.unlink(p)
+            except Exception:
+                pass
+
+
+def run_process_with_exif(
+    img: Image.Image,
+    noise_std: float = 0.02,
+    clahe_clip: float = 2.0,
+    tile: int = 8,
+    cutoff: float = 0.25,
+    fstrength: float = 0.9,
+    awb: bool = True,
+    sim_camera: bool = True,
+    lut_file: Optional[Path] = None,
+    lut_strength: float = 0.1,
+    awb_ref: Optional[Image.Image] = None,
+    fft_ref: Optional[Image.Image] = None,
+    seed: Optional[int] = None,
+    jpeg_cycles: int = 1,
+    jpeg_qmin: int = 88,
+    jpeg_qmax: int = 96,
+    vignette_strength: float = 0.35,
+    chroma_strength: float = 1.2,
+    iso_scale: float = 1.0,
+    read_noise: float = 2.0,
+    no_no_bayer: bool = False,
+    randomness: float = 0.05,
+    perturb: float = 0.008,
+    phase_perturb: float = 0.08,
+    radial_smooth: int = 5,
+    fft_mode: str = "auto",
+    fft_alpha: float = 1.0,
+    apply_exif: bool = True,
+    hot_pixel_prob: float = 1e-6,
+    banding_strength: float = 0.0,
+    motion_blur_kernel: int = 1,
+):
+    """Run pipeline like `run_process` but return (pil_img, status, exif_hex_or_empty).
+
+    This function is used by the Gradio UI to expose EXIF metadata.
+    """
+    if process_image is None:
+        return None, f"Backend import error: {IMPORT_ERROR}", ""
+
+    tmp_files = []
+    try:
+        in_path = _mk_temp_file(suffix=".png")
+        img.save(in_path)
+        tmp_files.append(in_path)
+
+        # optional refs
+        awb_ref_path = None
+        if awb_ref is not None:
+            p = _mk_temp_file(suffix=".png")
+            awb_ref.save(p)
+            awb_ref_path = p
+            tmp_files.append(p)
+
+        fft_ref_path = None
+        if fft_ref is not None:
+            p = _mk_temp_file(suffix=".png")
+            fft_ref.save(p)
+            fft_ref_path = p
+            tmp_files.append(p)
+
+        out_path = _mk_temp_file(suffix=".jpg")
+        tmp_files.append(out_path)
+
+        lut_path = None
+        if lut_file is not None:
+            lut_path = str(lut_file)
+
+        args = SimpleNamespace(
+            input=in_path,
+            output=out_path,
+            awb=bool(awb),
+            ref=awb_ref_path,
+            noise_std=float(noise_std),
+            clahe_clip=float(clahe_clip),
+            tile=int(tile),
+            cutoff=float(cutoff),
+            fstrength=float(fstrength),
+            randomness=float(randomness),
+            perturb=float(perturb),
+            seed=seed,
+            fft_ref=fft_ref_path,
+            fft_mode=fft_mode,
+            fft_alpha=float(fft_alpha),
+            phase_perturb=float(phase_perturb),
+            radial_smooth=int(radial_smooth),
+            sim_camera=bool(sim_camera),
+            no_no_bayer=bool(no_no_bayer),
+            jpeg_cycles=int(jpeg_cycles),
+            jpeg_qmin=int(jpeg_qmin),
+            jpeg_qmax=int(jpeg_qmax),
+            vignette_strength=float(vignette_strength),
+            chroma_strength=float(chroma_strength),
+            iso_scale=float(iso_scale),
+            read_noise=float(read_noise),
+            hot_pixel_prob=float(hot_pixel_prob),
+            banding_strength=float(banding_strength),
+            motion_blur_kernel=int(motion_blur_kernel),
+            lut=(lut_path if lut_path else None),
+            lut_strength=float(lut_strength),
+        )
+
+        # Debug: print args passed to process_image for tracing
+        try:
+            print("process_image called with args:")
+            for k, v in vars(args).items():
+                print(f"  {k}: {v}")
+        except Exception:
+            pass
+
+        try:
+            process_image(in_path, out_path, args)
+        except Exception as e:
+            return None, f"Processing error: {e}", ""
+
+        out_img = Image.open(out_path).convert("RGB")
+
+        # try to extract EXIF bytes
+        exif_hex = ""
+        try:
+            info = Image.open(out_path).info
+            exif_bytes = info.get('exif')
+            if exif_bytes:
+                exif_hex = exif_bytes.hex()
+        except Exception:
+            exif_hex = ""
+
+        return out_img, "OK", exif_hex
+
+    finally:
+        for p in tmp_files:
+            try:
+                os.unlink(p)
+            except Exception:
+                pass
+
+# ------------------ Headless analysis helpers (from AnalysisPanel) ------------------
+def pil_to_gray_array(pil_img: Image.Image):
+    arr = np.array(pil_img.convert('RGB'))
+    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
+
+
+def fig_to_pil(fig):
+    buf = io.BytesIO()
+    fig.savefig(buf, format='png', bbox_inches='tight')
+    plt.close(fig)
+    buf.seek(0)
+    return Image.open(buf).convert('RGB')
+
+
+def make_analysis_images(pil_img: Image.Image):
+    """Return (hist_img, fft_img, radial_img) as PIL Images for the provided PIL image."""
+    gray = pil_to_gray_array(pil_img)
+
+    # Histogram
+    fig1 = plt.figure(figsize=(3, 2), dpi=100)
+    ax1 = fig1.add_subplot(111)
+    flat = gray.ravel()
+    if flat.dtype.kind == 'f' and flat.max() <= 1.0:
+        flat = (flat * 255.0).astype(np.uint8)
+    ax1.hist(flat, bins=256, range=(0, 255))
+    ax1.set_title('Grayscale histogram')
+    ax1.set_xlabel('Intensity')
+    ax1.set_ylabel('Count')
+    hist_img = fig_to_pil(fig1)
+
+    # FFT magnitude (log)
+    mag, mag_log = compute_fft_magnitude(gray)
+    fig2 = plt.figure(figsize=(3, 2), dpi=100)
+    ax2 = fig2.add_subplot(111)
+    ax2.imshow(mag_log, origin='lower', aspect='auto')
+    ax2.set_title('FFT magnitude (log)')
+    ax2.set_xticks([])
+    ax2.set_yticks([])
+    fft_img = fig_to_pil(fig2)
+
+    # Radial profile
+    centers, radial = radial_profile(mag)
+    fig3 = plt.figure(figsize=(3, 2), dpi=100)
+    ax3 = fig3.add_subplot(111)
+    ax3.plot(centers, radial)
+    ax3.set_title('Radial freq profile')
+    ax3.set_xlabel('Normalized radius')
+    ax3.set_ylabel('Mean magnitude')
+    radial_img = fig_to_pil(fig3)
+
+    return hist_img, fft_img, radial_img
+
+
+def make_delta_image(orig: Image.Image, proc: Image.Image, max_size: int = 256):
+    """Return (diff_pil, mse, norm_diff) comparing orig vs proc.
+
+    - diff_pil: absolute-difference thumbnail (RGB)
+    - mse: mean squared error (float)
+    - norm_diff: mean absolute difference normalized to [0..1]
+    """
+    try:
+        # Downscale to reasonable size for cheap diffing
+        orig_small = orig.copy()
+        proc_small = proc.copy()
+        orig_small.thumbnail((max_size, max_size))
+        proc_small.thumbnail((max_size, max_size))
+
+        a = np.asarray(orig_small).astype(np.float32)
+        b = np.asarray(proc_small).astype(np.float32)
+        # Ensure same shape
+        if a.shape != b.shape:
+            # try to convert proc to orig shape via resize
+            proc_small = proc_small.resize(orig_small.size)
+            b = np.asarray(proc_small).astype(np.float32)
+
+        diff = np.abs(a - b)
+        mse = float(((a - b) ** 2).mean())
+        norm_diff = float(diff.mean() / 255.0)
+
+        # Scale diff for visibility
+        diff_vis = np.clip(diff * 4.0, 0, 255).astype(np.uint8)
+        diff_img = Image.fromarray(diff_vis)
+        metrics = f"MSE: {mse:.2f}\nMean abs diff (norm): {norm_diff:.4f}"
+        return diff_img, mse, metrics
+    except Exception as e:
+        return None, 0.0, f"delta error: {e}"
+
+
+def build_interface():
+    try:
+        import gradio as gr
+    except Exception:
+        raise RuntimeError("Gradio is not installed. Add 'gradio' to requirements.txt and install it.")
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# Image Postprocess — Gradio frontend\nWraps the repository's `process_image` pipeline.")
+
+        with gr.Row():
+            inp = gr.Image(type="pil", label="Input image")
+            out = gr.Image(type="pil", label="Processed image")
+
+        # Preset selector + save/load
+        customs = list(load_custom_presets().keys())
+        preset_choices = [*BUILTIN_PRESETS.keys(), *customs]
+        with gr.Row():
+            preset = gr.Dropdown(choices=preset_choices, value="Preview (no camera sim)", label="Preset")
+            preset_name = gr.Textbox(label="Save preset as (name)")
+            save_preset_btn = gr.Button("Save preset")
+        preset_summary_box = gr.Textbox(value=preset_summary("Default"), label="Preset summary", interactive=False)
+
+        with gr.Row():
+            hist_out = gr.Image(type="pil", label="Processed hist")
+            fft_out = gr.Image(type="pil", label="Processed FFT")
+            radial_out = gr.Image(type="pil", label="Processed radial")
+            delta_out = gr.Image(type="pil", label="Diff (abs) thumb")
+            delta_metrics = gr.Textbox(label="Delta metrics", interactive=False)
+
+        # Reference images and EXIF output
+        with gr.Row():
+            awb_ref = gr.Image(type="pil", label="AWB reference (optional)")
+            fft_ref = gr.Image(type="pil", label="FFT reference (optional)")
+            exif_out = gr.Textbox(label="EXIF (hex)")
+
+        with gr.Row():
+            noise_std = gr.Slider(0.0, 0.1, value=0.02, step=0.001, label="Noise STD (fraction)")
+            clahe_clip = gr.Slider(0.5, 10.0, value=2.0, step=0.1, label="CLAHE clip")
+            tile = gr.Slider(2, 32, value=8, step=1, label="CLAHE tile")
+
+        with gr.Row():
+            cutoff = gr.Slider(0.0, 1.0, value=0.25, step=0.01, label="Fourier cutoff")
+            fstrength = gr.Slider(0.0, 1.0, value=0.9, step=0.01, label="Fourier strength")
+            awb = gr.Checkbox(label="Apply AWB (auto white balance)", value=True)
+
+        with gr.Row():
+            sim_camera = gr.Checkbox(label="Simulate camera pipeline", value=False)
+            lut_file = gr.File(label="Optional LUT (png/npy/cube)")
+            lut_strength = gr.Slider(0.0, 1.0, value=0.1, step=0.01, label="LUT strength")
+
+        with gr.Row():
+            seed = gr.Number(value=None, label="Seed (integer, optional)")
+            jpeg_cycles = gr.Slider(1, 5, value=1, step=1, label="JPEG cycles")
+            jpeg_qmin = gr.Slider(30, 100, value=88, step=1, label="JPEG quality (min)")
+
+        with gr.Row():
+            vignette_strength = gr.Slider(0.0, 1.0, value=0.35, step=0.01, label="Vignette strength")
+            chroma_strength = gr.Slider(0.0, 5.0, value=1.2, step=0.1, label="Chroma strength")
+            iso_scale = gr.Slider(0.1, 16.0, value=1.0, step=0.1, label="ISO scale")
+
+        with gr.Row():
+            read_noise = gr.Slider(0.0, 50.0, value=2.0, step=0.1, label="Read noise")
+            no_no_bayer = gr.Checkbox(label="Disable Bayer (no demosaic)", value=False)
+
+        # Advanced panel for expert parameters
+        with gr.Accordion("Advanced parameters (expert)", open=False):
+            randomness = gr.Slider(0.0, 0.5, value=0.05, step=0.001, label="Fourier randomness")
+            perturb = gr.Slider(0.0, 0.05, value=0.008, step=0.001, label="Perturb magnitude")
+            phase_perturb = gr.Slider(0.0, 0.5, value=0.08, step=0.001, label="Phase perturb")
+            radial_smooth = gr.Slider(0, 50, value=5, step=1, label="Radial smooth")
+            fft_mode = gr.Dropdown(["auto", "ref", "model"], value="auto", label="FFT mode")
+            fft_alpha = gr.Slider(0.1, 4.0, value=1.0, step=0.1, label="FFT alpha (1/f)")
+
+        status = gr.Textbox(label="Status", interactive=False)
+
+        def _wrap(preset, inp_img, noise_std, clahe_clip, tile, cutoff, fstrength, awb, sim_camera, lut_file, lut_strength, awb_ref, fft_ref, seed, jpeg_cycles, jpeg_qmin, vignette_strength, chroma_strength, iso_scale, read_noise, no_no_bayer, randomness, perturb, phase_perturb, radial_smooth, fft_mode, fft_alpha):
+            jpeg_qmax = 96
+            lut_path = lut_file.name if getattr(lut_file, 'name', None) else None
+
+            # Build effective parameters mapping from UI inputs
+            params = {
+                "noise_std": float(noise_std),
+                "clahe_clip": float(clahe_clip),
+                "tile": int(tile),
+                "cutoff": float(cutoff),
+                "fstrength": float(fstrength),
+                "awb": bool(awb),
+                "sim_camera": bool(sim_camera),
+                "lut_file": lut_path,
+                "lut_strength": float(lut_strength),
+                "awb_ref": awb_ref,
+                "fft_ref": fft_ref,
+                "seed": int(seed) if (seed is not None and str(seed) != "") else None,
+                "jpeg_cycles": int(jpeg_cycles),
+                "jpeg_qmin": int(jpeg_qmin),
+                "jpeg_qmax": int(jpeg_qmax),
+                "vignette_strength": float(vignette_strength),
+                "chroma_strength": float(chroma_strength),
+                "iso_scale": float(iso_scale),
+                "read_noise": float(read_noise),
+                "no_no_bayer": bool(no_no_bayer),
+                "randomness": float(randomness),
+                "perturb": float(perturb),
+                "phase_perturb": float(phase_perturb),
+                "radial_smooth": int(radial_smooth),
+                "fft_mode": fft_mode,
+                "fft_alpha": float(fft_alpha),
+            }
+
+            # Overlay preset overrides (builtin or custom)
+            overrides = get_preset_overrides(preset)
+            for k, v in overrides.items():
+                params[k] = v
+
+            # Call the pipeline with explicit params
+            try:
+                result, msg, exif = run_process_with_exif(
+                    inp_img,
+                    noise_std=params.get("noise_std"),
+                    clahe_clip=params.get("clahe_clip"),
+                    tile=params.get("tile"),
+                    cutoff=params.get("cutoff"),
+                    fstrength=params.get("fstrength"),
+                    awb=params.get("awb"),
+                    sim_camera=params.get("sim_camera"),
+                    lut_file=params.get("lut_file"),
+                    lut_strength=params.get("lut_strength"),
+                    awb_ref=params.get("awb_ref"),
+                    fft_ref=params.get("fft_ref"),
+                    seed=params.get("seed"),
+                    jpeg_cycles=params.get("jpeg_cycles"),
+                    jpeg_qmin=params.get("jpeg_qmin"),
+                    jpeg_qmax=params.get("jpeg_qmax"),
+                    vignette_strength=params.get("vignette_strength"),
+                    chroma_strength=params.get("chroma_strength"),
+                    iso_scale=params.get("iso_scale"),
+                    read_noise=params.get("read_noise"),
+                    no_no_bayer=params.get("no_no_bayer"),
+                    randomness=params.get("randomness"),
+                    perturb=params.get("perturb"),
+                    phase_perturb=params.get("phase_perturb"),
+                    radial_smooth=params.get("radial_smooth"),
+                    fft_mode=params.get("fft_mode"),
+                    fft_alpha=params.get("fft_alpha"),
+                )
+            except Exception as e:
+                return None, None, None, None, None, "", f"Processing error: {e}"
+
+            if result is None:
+                return None, None, None, None, None, "", msg
+
+            try:
+                hist_img, fft_img, radial_img = make_analysis_images(result)
+            except Exception as e:
+                return result, None, None, None, None, exif, f"Analysis error: {e}"
+
+            # Delta preview
+            try:
+                diff_img, mse_val, metrics = make_delta_image(inp_img, result)
+            except Exception as e:
+                diff_img, mse_val, metrics = None, 0.0, f"delta error: {e}"
+
+            return result, hist_img, fft_img, radial_img, diff_img, metrics, exif, msg
+
+        btn = gr.Button("Run")
+        btn.click(
+            _wrap,
+            inputs=[preset, inp, noise_std, clahe_clip, tile, cutoff, fstrength, awb, sim_camera, lut_file, lut_strength, awb_ref, fft_ref, seed, jpeg_cycles, jpeg_qmin, vignette_strength, chroma_strength, iso_scale, read_noise, no_no_bayer, randomness, perturb, phase_perturb, radial_smooth, fft_mode, fft_alpha],
+            outputs=[out, hist_out, fft_out, radial_out, delta_out, delta_metrics, exif_out, status],
+        )
+
+        def _save_preset(name, preset, noise_std, clahe_clip, tile, cutoff, fstrength, awb, sim_camera, lut_strength, seed, jpeg_cycles, jpeg_qmin, vignette_strength, chroma_strength, iso_scale, read_noise, no_no_bayer, randomness, perturb, phase_perturb, radial_smooth, fft_mode, fft_alpha):
+            if not name:
+                return "Provide a name to save the preset"
+            data = {
+                "noise_std": float(noise_std),
+                "clahe_clip": float(clahe_clip),
+                "tile": int(tile),
+                "cutoff": float(cutoff),
+                "fstrength": float(fstrength),
+                "randomness": float(randomness),
+                "perturb": float(perturb),
+                "phase_perturb": float(phase_perturb),
+                "radial_smooth": int(radial_smooth),
+                "jpeg_cycles": int(jpeg_cycles),
+                "jpeg_qmin": int(jpeg_qmin),
+                "vignette_strength": float(vignette_strength),
+                "chroma_strength": float(chroma_strength),
+                "iso_scale": float(iso_scale),
+                "read_noise": float(read_noise),
+                "no_no_bayer": bool(no_no_bayer),
+            }
+            save_custom_preset(name, data)
+            return f"Saved preset: {name}"
+
+        save_preset_btn.click(_save_preset, inputs=[preset_name, preset, noise_std, clahe_clip, tile, cutoff, fstrength, awb, sim_camera, lut_strength, seed, jpeg_cycles, jpeg_qmin, vignette_strength, chroma_strength, iso_scale, read_noise, no_no_bayer, randomness, perturb, phase_perturb, radial_smooth, fft_mode, fft_alpha], outputs=[preset_summary_box])
+
+        def _update_summary(selected):
+            return preset_summary(selected)
+
+        preset.change(_update_summary, inputs=[preset], outputs=[preset_summary_box])
+
+    return demo
+
+
+if __name__ == "__main__":
+    iface = build_interface()
+    iface.launch(server_name="0.0.0.0", server_port=7860)

image_postprocess/camera_pipeline.py

@@ -217,7 +217,9 @@ def simulate_camera_pipeline(img_arr: np.ndarray,
     # 1) Bayer mosaic + demosaic (if enabled)
     if bayer:
         try:
-            mosaic = _bayer_mosaic(out[:, :, ::-1])  # we built mosaic assuming R,G,B order; send RGB
+            # Build mosaic from the RGB image (no channel reversal). Previously the code
+            # reversed channels here which caused R/B swapping and strong green tint.
+            mosaic = _bayer_mosaic(out)
             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

requirements.txt

@@ -1,4 +1,4 @@
-pyqt5
+gradio
 pillow
 numpy
 matplotlib

test_isolate_stages.py

@@ -0,0 +1,39 @@
+from PIL import Image
+import numpy as np
+from app_gradio import run_process_with_exif
+
+
+def mse(a, b):
+    a = np.array(a).astype(np.float32)
+    b = np.array(b).astype(np.float32)
+    return float(((a - b) ** 2).mean())
+
+
+def make_input():
+    img = Image.new('RGB', (256, 256))
+    for y in range(256):
+        for x in range(256):
+            img.putpixel((x, y), (x % 256, y % 256, (x + y) % 256))
+    return img
+
+
+def run_variant(name, **kwargs):
+    inp = make_input()
+    out, status, exif = run_process_with_exif(inp, **kwargs)
+    import os
+    os.makedirs('test', exist_ok=True)
+    path = os.path.join('test', f"test_out_{name}.jpg")
+    if out is not None:
+        out.save(path)
+    print(f"{name}: status={status}, exif_len={len(exif) if exif else 0}, mse={mse(inp, out) if out is not None else 'NA'}, saved={path if out is not None else 'no'}")
+
+
+if __name__ == '__main__':
+    # Default
+    run_variant('default', noise_std=0.02, clahe_clip=2.0, tile=8, cutoff=0.25, fstrength=0.9, awb=True, sim_camera=True, seed=0)
+    # AWB disabled
+    run_variant('no_awb', noise_std=0.02, clahe_clip=2.0, tile=8, cutoff=0.25, fstrength=0.9, awb=False, sim_camera=True, seed=0)
+    # camera sim disabled
+    run_variant('no_cam', noise_std=0.02, clahe_clip=2.0, tile=8, cutoff=0.25, fstrength=0.9, awb=True, sim_camera=False, seed=0)
+    # both disabled
+    run_variant('no_awb_no_cam', noise_std=0.02, clahe_clip=2.0, tile=8, cutoff=0.25, fstrength=0.9, awb=False, sim_camera=False, seed=0)

test_smoke_gradio.py

@@ -0,0 +1,21 @@
+from PIL import Image
+import io
+import os
+
+# Import the run_process function from the Gradio wrapper
+from app_gradio import run_process
+
+# Create a small synthetic test image (RGB gradient)
+img = Image.new('RGB', (128, 128))
+for y in range(128):
+    for x in range(128):
+        img.putpixel((x, y), (int(x*2), int(y*2), int((x+y)/2)))
+
+out_img, status = run_process(img)
+print('Status:', status)
+if out_img is not None:
+    out_path = '/tmp/test_gradio_output.jpg'
+    out_img.save(out_path)
+    print('Wrote output to', out_path)
+else:
+    print('No output image generated')

test_smoke_gradio_debug.py

@@ -0,0 +1,55 @@
+from PIL import Image
+import os
+
+# Import the richer runner (with EXIF) from the Gradio wrapper
+from app_gradio import run_process_with_exif
+
+# Create a small synthetic test image (RGB gradient)
+img = Image.new('RGB', (128, 128))
+for y in range(128):
+    for x in range(128):
+        img.putpixel((x, y), (int(x*2), int(y*2), int((x+y)/2)))
+
+# Call with explicit parameters to exercise many code paths
+out_img, status, exif = run_process_with_exif(
+    img,
+    noise_std=0.02,
+    clahe_clip=2.0,
+    tile=8,
+    cutoff=0.25,
+    fstrength=0.9,
+    awb=True,
+    sim_camera=True,
+    lut_file=None,
+    lut_strength=0.1,
+    awb_ref=None,
+    fft_ref=None,
+    seed=0,
+    jpeg_cycles=1,
+    jpeg_qmin=88,
+    jpeg_qmax=96,
+    vignette_strength=0.35,
+    chroma_strength=1.2,
+    iso_scale=1.0,
+    read_noise=2.0,
+    no_no_bayer=False,
+    randomness=0.05,
+    perturb=0.008,
+    phase_perturb=0.08,
+    radial_smooth=5,
+    fft_mode="auto",
+    fft_alpha=1.0,
+    hot_pixel_prob=1e-6,
+    banding_strength=0.0,
+    motion_blur_kernel=1,
+)
+
+print('Status:', status)
+print('EXIF (hex length):', len(exif) if exif else 0)
+if out_img is not None:
+    os.makedirs('test', exist_ok=True)
+    out_path = os.path.join('test', 'test_gradio_output_debug.jpg')
+    out_img.save(out_path)
+    print('Wrote output to', out_path)
+else:
+    print('No output image generated')