Added LUT

analysis_panel.py

@@ -1,74 +1,169 @@
 #!/usr/bin/env python3
 """
 Analysis panel for histogram, FFT, and radial profile plots.
+Designed to plug straight into the provided run.py / MainWindow.
+
+Exposes AnalysisPanel(title: str) with method update_from_path(path)
+and clear_plots(). Uses helpers from utils:
+- compute_gray_array(path) -> 2D numpy.ndarray (grayscale 0-255)
+- compute_fft_magnitude(gray) -> (mag, mag_log)
+- radial_profile(mag) -> (centers, radial)
+- make_canvas(width, height) -> (FigureCanvas, Axes)
+
+This module is intentionally defensive (catches errors) and keeps
+its own layout compact so it will fit in the scrollable right-hand
+panel in MainWindow.
 """
 
-from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QSizePolicy
+from PyQt5.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QSizePolicy, QLabel
 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):
+    def __init__(self, title: str = "Analysis", parent=None):
         super().__init__(parent)
+        self.setMinimumHeight(220)
+
+        # Top-level layout + framed group
         v = QVBoxLayout(self)
         box = QGroupBox(title)
         vbox = QVBoxLayout()
         box.setLayout(vbox)
 
+        # Row of three matplotlib canvases
         row = QHBoxLayout()
+
+        # create canvases using project's make_canvas helper so styles match
         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)
+            # give figures a consistent, compact margin so they sit well inside the GroupBox
+            try:
+                c.figure.subplots_adjust(top=0.88, bottom=0.12, left=0.12, right=0.96)
+            except Exception:
+                pass
 
         row.addWidget(self.hist_canvas)
         row.addWidget(self.fft_canvas)
         row.addWidget(self.radial_canvas)
 
         vbox.addLayout(row)
+
+        # small status label below canvases for quick diagnostics
+        self.status_label = QLabel("")
+        self.status_label.setWordWrap(True)
+        self.status_label.setVisible(False)
+        vbox.addWidget(self.status_label)
+
         v.addWidget(box)
 
-    def update_from_path(self, path):
+    def update_from_path(self, path: str):
+        """Update all three plots using the image at `path`.
+
+        If path is invalid or an error occurs while loading/processing,
+        plots are cleared and a status message is shown.
+        """
         if not path or not os.path.exists(path):
+            self.status_label.setText(f"No image: {path}")
+            self.status_label.setVisible(True)
             self.clear_plots()
             return
+
         try:
             gray = compute_gray_array(path)
-        except Exception:
+            if gray is None:
+                raise ValueError("compute_gray_array returned None")
+            # ensure grayscale array is 2D and finite
+            gray = np.asarray(gray)
+            if gray.ndim != 2:
+                raise ValueError("expected 2D grayscale array")
+
+        except Exception as e:
+            self.status_label.setText(f"Failed to load image: {e}")
+            self.status_label.setVisible(True)
             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()
+        # Good: hide status
+        self.status_label.setVisible(False)
+
+        # -------------------- Histogram --------------------
+        try:
+            self.hist_ax.cla()
+            self.hist_ax.set_title('Grayscale histogram')
+            self.hist_ax.set_xlabel('Intensity')
+            self.hist_ax.set_ylabel('Count')
+            # ensure int range 0..255
+            flat = gray.ravel()
+            # handle float data by scaling if necessary
+            if flat.dtype.kind == 'f' and flat.max() <= 1.0:
+                flat = (flat * 255.0).astype(np.uint8)
+            self.hist_ax.hist(flat, bins=256, range=(0, 255))
+            self.hist_canvas.draw()
+        except Exception as e:
+            self.hist_ax.cla()
+            self.hist_canvas.draw()
+            self.status_label.setText(f"Histogram error: {e}")
+            self.status_label.setVisible(True)
+
+        # -------------------- FFT magnitude --------------------
+        try:
+            mag, mag_log = compute_fft_magnitude(gray)
+            if mag_log is None:
+                raise ValueError("compute_fft_magnitude returned None")
+
+            self.fft_ax.cla()
+            self.fft_ax.set_title('FFT magnitude (log)')
+            # use imshow with origin='lower' so low-frequencies sit near the centre visually
+            self.fft_ax.imshow(mag_log, origin='lower', aspect='auto')
+            self.fft_ax.set_xticks([])
+            self.fft_ax.set_yticks([])
+            # leave some room for colorbar in wider layouts (MainWindow adjusts overall sizes)
+            try:
+                self.fft_canvas.figure.subplots_adjust(right=0.92)
+            except Exception:
+                pass
+            self.fft_canvas.draw()
+        except Exception as e:
+            self.fft_ax.cla()
+            self.fft_canvas.draw()
+            self.status_label.setText(f"FFT error: {e}")
+            self.status_label.setVisible(True)
+
+        # -------------------- Radial profile --------------------
+        try:
+            centers, radial = radial_profile(mag)
+            if centers is None or radial is None:
+                raise ValueError("radial_profile returned invalid data")
+
+            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()
+        except Exception as e:
+            self.radial_ax.cla()
+            self.radial_canvas.draw()
+            self.status_label.setText(f"Radial profile error: {e}")
+            self.status_label.setVisible(True)
 
     def clear_plots(self):
+        """Clear all axes and redraw empty canvases."""
         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()
+            try:
+                ax.cla()
+                # give an empty centered message on histogram axis only
+                if ax is self.hist_ax:
+                    ax.text(0.5, 0.5, 'No image', horizontalalignment='center', verticalalignment='center', transform=ax.transAxes)
+                canvas.draw()
+            except Exception:
+                pass

image_postprocess/__init__.py

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

image_postprocess/{image_postprocess_with_camera_pipeline.py → processor.py}

@@ -1,10 +1,9 @@
 #!/usr/bin/env python3
 """
-image_postprocess_with_camera_pipeline.py
+processor.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.
+Added support for applying 1D PNG/.npy LUTs and .cube 3D LUTs via --lut.
 """
 
 import argparse
@@ -20,20 +19,21 @@ from .utils import (
     randomized_perturbation,
     fourier_match_spectrum,
     auto_white_balance_ref,
+    load_lut,
+    apply_lut,
 )
 from .camera_pipeline import simulate_camera_pipeline
 
+
 def add_fake_exif():
     """
     Generates a plausible set of fake EXIF data.
     Returns:
         bytes: The EXIF data as a byte string, ready for insertion.
     """
-    # Get current time for timestamp
     now = datetime.now()
     datestamp = now.strftime("%Y:%m:%d %H:%M:%S")
 
-    # Define some plausible fake EXIF tags
     zeroth_ifd = {
         piexif.ImageIFD.Make: b"PurinCamera",
         piexif.ImageIFD.Model: b"Model420X",
@@ -46,17 +46,17 @@ def add_fake_exif():
         piexif.ExifIFD.ExposureTime: (1, 125),  # 1/125s
         piexif.ExifIFD.FNumber: (28, 10),      # F/2.8
         piexif.ExifIFD.ISOSpeedRatings: 200,
-        piexif.ExifIFD.FocalLength: (50, 1),      # 50mm
+        piexif.ExifIFD.FocalLength: (50, 1),    # 50mm
     }
-    gps_ifd = {} # Empty GPS info
+    gps_ifd = {}
 
     exif_dict = {"0th": zeroth_ifd, "Exif": exif_ifd, "GPS": gps_ifd, "1st": {}, "thumbnail": None}
     exif_bytes = piexif.dump(exif_dict)
     return exif_bytes
 
+
 def process_image(path_in, path_out, args):
     img = Image.open(path_in).convert('RGB')
-    # input -> numpy array
     arr = np.array(img)
 
     # --- Auto white-balance using reference (if provided) ---
@@ -105,14 +105,27 @@ def process_image(path_in, path_out, args):
                                        motion_blur_kernel=args.motion_blur_kernel,
                                        seed=args.seed)
 
+    # --- LUT application (optional) ---
+    if args.lut:
+        try:
+            lut = load_lut(args.lut)
+            # Ensure array is uint8 for LUT application
+            arr_uint8 = np.clip(arr, 0, 255).astype(np.uint8)
+            arr_lut = apply_lut(arr_uint8, lut, strength=args.lut_strength)
+            # Ensure output is uint8
+            arr = np.clip(arr_lut, 0, 255).astype(np.uint8)
+        except Exception as e:
+            print(f"Warning: failed to load/apply LUT '{args.lut}': {e}. Skipping LUT.")
+
     out_img = Image.fromarray(arr)
-    
+
     # Generate fake EXIF data and save it with the image
     fake_exif_bytes = add_fake_exif()
     out_img.save(path_out, exif=fake_exif_bytes)
 
+
 def build_argparser():
-    p = argparse.ArgumentParser(description="Image postprocessing pipeline with camera simulation")
+    p = argparse.ArgumentParser(description="Image postprocessing pipeline with camera simulation and LUT support")
     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 auto white-balance (applied before CLAHE)', default=None)
@@ -147,8 +160,13 @@ def build_argparser():
     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)')
 
+    # 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)')
+
     return p
 
+
 if __name__ == "__main__":
     args = build_argparser().parse_args()
     if not os.path.exists(args.input):

image_postprocess/utils.py

@@ -4,7 +4,8 @@ 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:
@@ -229,4 +230,227 @@ def auto_white_balance_ref(img_arr: np.ndarray, ref_img_arr: np.ndarray = None)
     corrected = img * scale
     corrected = np.clip(corrected, 0, 255).astype(np.uint8)
 
-    return corrected
+    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,6 +1,8 @@
 #!/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.
 """
 
 import sys
@@ -9,7 +11,7 @@ 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
+    QProgressBar, QMessageBox, QLineEdit, QComboBox, QCheckBox, QToolButton, QScrollArea
 )
 from PyQt5.QtCore import Qt
 from PyQt5.QtGui import QPixmap
@@ -100,9 +102,15 @@ class MainWindow(QMainWindow):
         self.progress.setValue(0)
         left_v.addWidget(self.progress)
 
-        # Right: controls + analysis panels
-        right_v = QVBoxLayout()
-        main_h.addLayout(right_v, 3)
+        # 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")
@@ -233,6 +241,37 @@ class MainWindow(QMainWindow):
         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)
+        params_layout.addRow("LUT file (png/.npy/.cube)", 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)")
+        params_layout.addRow("LUT strength", self.lut_strength_spin)
+
+        # Initially hide LUT controls
+        lut_box.setVisible(False)
+        self.lut_strength_spin.setVisible(False)
+        self._lut_controls = (lut_box, self.lut_strength_spin)
+
         # Camera simulator collapsible group
         self.camera_box = CollapsibleBox("Camera simulator options")
         right_v.addWidget(self.camera_box)
@@ -374,6 +413,16 @@ class MainWindow(QMainWindow):
         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")
@@ -469,6 +518,15 @@ class MainWindow(QMainWindow):
         # 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)
@@ -544,4 +602,4 @@ def main():
     sys.exit(app.exec_())
 
 if __name__ == '__main__':
-    main()
+    main()