Update app.py

app.py

@@ -9,10 +9,8 @@ from typing import Dict, Generator, List, Optional, Tuple, Union
 
 import cv2
 import gradio as gr
-import imageio.v2 as imageio
 import numpy as np
 from PIL import Image, ImageDraw
-from scipy import ndimage
 from skimage.restoration import richardson_lucy
 
 try:
@@ -33,19 +31,18 @@ class FrameMeta:
     idx: int
     path: Path
     sharpness: float
-    dm_score: float
 
 
 @dataclass
-class CropResult:
+class DetectionResult:
     frame_idx: int
     bbox: Tuple[int, int, int, int]
     crop: np.ndarray
+    decode_text: Optional[str]
     score: float
-    decoded_text: Optional[str] = None
 
 
-# --------------------- utility ---------------------
+# ---------- helpers ----------
 
 def ensure_dir(path: Path) -> Path:
     path.mkdir(parents=True, exist_ok=True)
@@ -65,13 +62,6 @@ def resolve_video_path(video_input: Union[str, Dict, None]) -> str:
     raise ValueError("Unsupported video input format from Gradio.")
 
 
-def load_frame(path: Path) -> np.ndarray:
-    frame = cv2.imread(str(path), cv2.IMREAD_COLOR)
-    if frame is None:
-        raise RuntimeError(f"Could not read frame: {path}")
-    return frame
-
-
 def get_video_info(video_path: str) -> Dict[str, float]:
     cap = cv2.VideoCapture(video_path)
     if not cap.isOpened():
@@ -88,118 +78,95 @@ def get_video_info(video_path: str) -> Dict[str, float]:
     return info
 
 
-def gray(img_bgr: np.ndarray) -> np.ndarray:
-    return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
-
-
-def lap_var(img_bgr: np.ndarray) -> float:
-    return float(cv2.Laplacian(gray(img_bgr), cv2.CV_32F).var())
+def load_frame(path: Path) -> np.ndarray:
+    frame = cv2.imread(str(path), cv2.IMREAD_COLOR)
+    if frame is None:
+        raise RuntimeError(f"Could not read frame: {path}")
+    return frame
 
 
-def clahe_gray(g: np.ndarray) -> np.ndarray:
-    clahe = cv2.createCLAHE(clipLimit=2.2, tileGridSize=(8, 8))
-    return clahe.apply(g)
+def laplacian_sharpness(frame_bgr: np.ndarray) -> float:
+    gray = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2GRAY)
+    return float(cv2.Laplacian(gray, cv2.CV_32F).var())
 
 
-def clahe_bgr(img_bgr: np.ndarray) -> np.ndarray:
+def clahe_l_channel(img_bgr: np.ndarray) -> np.ndarray:
     lab = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2LAB)
     l, a, b = cv2.split(lab)
-    l = clahe_gray(l)
-    return cv2.cvtColor(cv2.merge([l, a, b]), cv2.COLOR_LAB2BGR)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    l2 = clahe.apply(l)
+    return cv2.cvtColor(cv2.merge([l2, a, b]), cv2.COLOR_LAB2BGR)
 
 
-def unsharp(img_bgr: np.ndarray, sigma: float = 1.0, amount: float = 1.2) -> np.ndarray:
+def unsharp_mask(img_bgr: np.ndarray, sigma: float = 1.0, amount: float = 1.2) -> np.ndarray:
     blur = cv2.GaussianBlur(img_bgr, (0, 0), sigmaX=sigma, sigmaY=sigma)
     out = cv2.addWeighted(img_bgr, 1.0 + amount, blur, -amount, 0)
     return np.clip(out, 0, 255).astype(np.uint8)
 
 
-def upscale(img_bgr: np.ndarray, scale: int) -> np.ndarray:
+def upscale(img_bgr: np.ndarray, scale: int = 3) -> np.ndarray:
     return cv2.resize(img_bgr, None, fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
 
 
-def pad_bbox(bbox: Tuple[int, int, int, int], pad: int, shape_hw: Tuple[int, int]) -> Tuple[int, int, int, int]:
-    x1, y1, x2, y2 = bbox
-    h, w = shape_hw
-    return max(0, x1 - pad), max(0, y1 - pad), min(w, x2 + pad), min(h, y2 + pad)
-
-
-def crop_img(img: np.ndarray, bbox: Tuple[int, int, int, int]) -> np.ndarray:
-    x1, y1, x2, y2 = bbox
-    return img[y1:y2, x1:x2]
-
-
-def bbox_center(bbox: Tuple[int, int, int, int]) -> Tuple[float, float]:
-    x1, y1, x2, y2 = bbox
-    return 0.5 * (x1 + x2), 0.5 * (y1 + y2)
-
-
-# --------------------- candidate search ---------------------
-
-def detect_datamatrix_candidates(frame_bgr: np.ndarray) -> List[Tuple[int, int, int, int, float]]:
-    h, w = frame_bgr.shape[:2]
-    g = gray(frame_bgr)
-
-    # Restrict to plausible lower-central region where tool labels appear.
-    x1 = int(0.15 * w)
-    x2 = int(0.92 * w)
-    y1 = int(0.16 * h)
-    y2 = int(0.92 * h)
-    roi = g[y1:y2, x1:x2]
-
-    blackhat = cv2.morphologyEx(roi, cv2.MORPH_BLACKHAT, np.ones((11, 11), np.uint8))
-    thr = cv2.adaptiveThreshold(
-        blackhat,
-        255,
-        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-        cv2.THRESH_BINARY,
-        35,
-        -4,
-    )
-    mask = cv2.morphologyEx(thr, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8), iterations=2)
-    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8), iterations=1)
-
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    out: List[Tuple[int, int, int, int, float]] = []
-    roi_area = float(roi.shape[0] * roi.shape[1])
-    for cnt in contours:
-        x, y, bw, bh = cv2.boundingRect(cnt)
-        area = bw * bh
-        if area < 120 or area > 0.08 * roi_area:
-            continue
-        aspect = bw / max(1.0, float(bh))
-        if not (0.65 <= aspect <= 1.45):
-            continue
+def motion_kernel(length: int, angle_deg: float) -> np.ndarray:
+    length = max(1, int(length))
+    size = max(9, length * 2 + 1)
+    kernel = np.zeros((size, size), np.float32)
+    c = size // 2
+    angle = math.radians(angle_deg)
+    dx = math.cos(angle)
+    dy = math.sin(angle)
+    for i in range(length):
+        t = i - (length - 1) / 2.0
+        x = int(round(c + t * dx))
+        y = int(round(c + t * dy))
+        if 0 <= x < size and 0 <= y < size:
+            kernel[y, x] = 1.0
+    s = float(kernel.sum())
+    if s <= 0:
+        kernel[c, c] = 1.0
+        s = 1.0
+    return kernel / s
 
-        patch = roi[y:y + bh, x:x + bw]
-        if patch.size == 0:
-            continue
 
-        gx = cv2.Sobel(patch, cv2.CV_32F, 1, 0, ksize=3)
-        gy = cv2.Sobel(patch, cv2.CV_32F, 0, 1, ksize=3)
-        edge_balance = float(min(np.mean(np.abs(gx)), np.mean(np.abs(gy))))
-        contrast = float(patch.std())
-        sharp = float(cv2.Laplacian(patch, cv2.CV_32F).var())
-        darkness = float(255.0 - np.mean(patch))
-        score = 0.8 * contrast + 0.8 * sharp + 0.6 * edge_balance + 0.2 * darkness
+def wiener_deconv_gray(gray: np.ndarray, kernel: np.ndarray, balance: float = 0.02) -> np.ndarray:
+    gray_f = gray.astype(np.float32) / 255.0
+    kh, kw = kernel.shape
+    ih, iw = gray_f.shape
+    psf = np.zeros_like(gray_f, dtype=np.float32)
+    y0 = (ih - kh) // 2
+    x0 = (iw - kw) // 2
+    psf[y0:y0 + kh, x0:x0 + kw] = kernel
+    psf = np.fft.ifftshift(psf)
+    G = np.fft.fft2(gray_f)
+    H = np.fft.fft2(psf)
+    F_hat = (np.conj(H) / (np.abs(H) ** 2 + balance)) * G
+    out = np.real(np.fft.ifft2(F_hat))
+    out = np.clip(out, 0.0, 1.0)
+    return (out * 255.0).astype(np.uint8)
 
-        pad = int(max(bw, bh) * 0.45)
-        xx1 = max(0, x1 + x - pad)
-        yy1 = max(0, y1 + y - pad)
-        xx2 = min(w, x1 + x + bw + pad)
-        yy2 = min(h, y1 + y + bh + pad)
-        out.append((xx1, yy1, xx2, yy2, score))
 
-    out.sort(key=lambda t: t[4], reverse=True)
-    return out[:12]
+def richardson_lucy_gray(gray: np.ndarray, kernel: np.ndarray, iterations: int = 15) -> np.ndarray:
+    arr = gray.astype(np.float32) / 255.0
+    out = richardson_lucy(arr, kernel, num_iter=iterations, clip=False)
+    out = np.clip(out, 0.0, 1.0)
+    return (out * 255.0).astype(np.uint8)
 
 
-def frame_dm_score(frame_bgr: np.ndarray) -> float:
-    cands = detect_datamatrix_candidates(frame_bgr)
-    return float(cands[0][4]) if cands else 0.0
+def try_decode_datamatrix(img_bgr: np.ndarray) -> Optional[str]:
+    if zxingcpp is None:
+        return None
+    rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+    try:
+        result = zxingcpp.read_barcode(rgb)
+        if result is not None and getattr(result, "text", None):
+            return str(result.text)
+    except Exception:
+        return None
+    return None
 
 
-# --------------------- extraction ---------------------
+# ---------- frame extraction ----------
 
 def extract_frames(video_path: str, out_dir: Path, stride: int = 1, max_frames: int = 0) -> List[FrameMeta]:
     cap = cv2.VideoCapture(video_path)
@@ -213,11 +180,10 @@ def extract_frames(video_path: str, out_dir: Path, stride: int = 1, max_frames:
         if not ok:
             break
         if idx % max(1, stride) == 0:
-            sharp = lap_var(frame)
-            dm = frame_dm_score(frame)
+            sharp = laplacian_sharpness(frame)
             frame_path = out_dir / f"frame_{idx:06d}.jpg"
             cv2.imwrite(str(frame_path), frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
-            records.append(FrameMeta(idx=idx, path=frame_path, sharpness=sharp, dm_score=dm))
+            records.append(FrameMeta(idx=idx, path=frame_path, sharpness=sharp))
             saved += 1
             if max_frames and saved >= max_frames:
                 break
@@ -228,309 +194,275 @@ def extract_frames(video_path: str, out_dir: Path, stride: int = 1, max_frames:
     return records
 
 
-def choose_reference_frame(records: List[FrameMeta]) -> int:
-    # Prefer frames with both candidate code texture and high sharpness.
-    sharp = np.array([r.sharpness for r in records], np.float32)
-    dm = np.array([r.dm_score for r in records], np.float32)
-    sharp_n = (sharp - sharp.min()) / max(1e-6, float(sharp.max() - sharp.min()))
-    dm_n = (dm - dm.min()) / max(1e-6, float(dm.max() - dm.min())) if float(dm.max()) > 0 else np.zeros_like(dm)
-    combo = 0.55 * sharp_n + 0.45 * dm_n
-    return int(np.argmax(combo))
+# ---------- alignment / fusion ----------
 
+def estimate_affine_to_ref(ref_bgr: np.ndarray, img_bgr: np.ndarray, scale: float = 0.5) -> np.ndarray:
+    ref_gray = cv2.cvtColor(ref_bgr, cv2.COLOR_BGR2GRAY)
+    img_gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+    if scale != 1.0:
+        ref_gray = cv2.resize(ref_gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA)
+        img_gray = cv2.resize(img_gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA)
+    ref_gray = cv2.equalizeHist(ref_gray)
+    img_gray = cv2.equalizeHist(img_gray)
+    warp = np.eye(2, 3, dtype=np.float32)
+    criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 80, 1e-4)
+    try:
+        cv2.findTransformECC(ref_gray, img_gray, warp, cv2.MOTION_EUCLIDEAN, criteria, None, 1)
+        if scale != 1.0:
+            warp[:, 2] /= scale
+        return warp
+    except Exception:
+        return np.eye(2, 3, dtype=np.float32)
 
-# --------------------- tracking and local fusion ---------------------
 
-def phase_shift(ref_gray: np.ndarray, mov_gray: np.ndarray) -> Tuple[float, float]:
-    ref32 = np.float32(ref_gray)
-    mov32 = np.float32(mov_gray)
-    (shift_x, shift_y), _ = cv2.phaseCorrelate(ref32, mov32)
-    return float(shift_x), float(shift_y)
+def warp_to_ref(img_bgr: np.ndarray, warp: np.ndarray, out_shape: Tuple[int, int]) -> np.ndarray:
+    h, w = out_shape
+    return cv2.warpAffine(
+        img_bgr,
+        warp,
+        (w, h),
+        flags=cv2.INTER_LINEAR + cv2.WARP_INVERSE_MAP,
+        borderMode=cv2.BORDER_REPLICATE,
+    )
 
 
-def align_local_crop(
-    ref_frame: np.ndarray,
-    frame: np.ndarray,
-    bbox: Tuple[int, int, int, int],
-    search_margin: int = 36,
-) -> Optional[Tuple[np.ndarray, Tuple[float, float]]]:
-    h, w = ref_frame.shape[:2]
-    x1, y1, x2, y2 = bbox
-    ref_crop = crop_img(ref_frame, bbox)
-    if ref_crop.size == 0:
-        return None
+def choose_reference_index(records: List[FrameMeta]) -> int:
+    ranked = sorted(enumerate(records), key=lambda t: t[1].sharpness, reverse=True)
+    return ranked[0][0]
 
-    sx1, sy1, sx2, sy2 = pad_bbox(bbox, search_margin, (h, w))
-    search = crop_img(frame, (sx1, sy1, sx2, sy2))
-    if search.shape[0] < ref_crop.shape[0] or search.shape[1] < ref_crop.shape[1]:
-        return None
 
-    ref_g = clahe_gray(gray(ref_crop))
-    search_g = clahe_gray(gray(search))
-
-    # Match on a central template to reduce border influence.
-    rx1 = int(0.15 * ref_g.shape[1])
-    ry1 = int(0.15 * ref_g.shape[0])
-    rx2 = max(rx1 + 8, int(0.85 * ref_g.shape[1]))
-    ry2 = max(ry1 + 8, int(0.85 * ref_g.shape[0]))
-    templ = ref_g[ry1:ry2, rx1:rx2]
-    res = cv2.matchTemplate(search_g, templ, cv2.TM_CCOEFF_NORMED)
-    _, maxv, _, maxloc = cv2.minMaxLoc(res)
-    if maxv < 0.15:
-        return None
+def fuse_global_burst(records: List[FrameMeta], ref_pos: int, radius: int = 5) -> Tuple[np.ndarray, List[int]]:
+    left = max(0, ref_pos - radius)
+    right = min(len(records), ref_pos + radius + 1)
+    selected = records[left:right]
+    ref_record = records[ref_pos]
+    ref = load_frame(ref_record.path)
+    h, w = ref.shape[:2]
 
-    top_left = (maxloc[0] - rx1, maxloc[1] - ry1)
-    cx1 = sx1 + top_left[0]
-    cy1 = sy1 + top_left[1]
-    cx2 = cx1 + (x2 - x1)
-    cy2 = cy1 + (y2 - y1)
-    if cx1 < 0 or cy1 < 0 or cx2 > w or cy2 > h:
-        return None
+    aligned: List[np.ndarray] = []
+    weights: List[float] = []
+    used: List[int] = []
+    for record in selected:
+        img = load_frame(record.path)
+        warp = estimate_affine_to_ref(ref, img)
+        aligned_img = warp_to_ref(img, warp, (h, w)).astype(np.float32)
+        aligned.append(aligned_img)
+        weights.append(max(1e-3, record.sharpness))
+        used.append(record.idx)
+
+    w_arr = np.array(weights, dtype=np.float32)
+    w_arr /= np.sum(w_arr)
+    fused = np.zeros_like(aligned[0], dtype=np.float32)
+    for arr, wgt in zip(aligned, w_arr):
+        fused += arr * wgt
+    fused = np.clip(fused, 0, 255).astype(np.uint8)
+    fused = unsharp_mask(clahe_l_channel(fused), sigma=1.0, amount=1.0)
+    return fused, used
 
-    coarse = crop_img(frame, (cx1, cy1, cx2, cy2))
-    if coarse.shape[:2] != ref_crop.shape[:2]:
-        return None
 
-    try:
-        dx, dy = phase_shift(ref_g, clahe_gray(gray(coarse)))
-    except Exception:
-        dx, dy = 0.0, 0.0
-
-    M = np.array([[1.0, 0.0, -dx], [0.0, 1.0, -dy]], dtype=np.float32)
-    aligned = cv2.warpAffine(coarse, M, (coarse.shape[1], coarse.shape[0]), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REFLECT)
-    return aligned, (top_left[0] + dx, top_left[1] + dy)
-
-
-def sharpness_map(img_bgr: np.ndarray) -> np.ndarray:
-    g = gray(img_bgr)
-    lap = cv2.Laplacian(g, cv2.CV_32F, ksize=3)
-    s = cv2.GaussianBlur(np.abs(lap), (0, 0), 1.0)
-    return s + 1e-3
-
-
-def local_sharp_fusion(aligned_crops: List[np.ndarray]) -> np.ndarray:
-    if len(aligned_crops) == 1:
-        return aligned_crops[0]
-    imgs = [x.astype(np.float32) for x in aligned_crops]
-    maps = [sharpness_map(x) for x in aligned_crops]
-    W = np.stack(maps, axis=0)
-    W /= np.sum(W, axis=0, keepdims=True)
-    I = np.stack(imgs, axis=0)
-    fused = np.sum(I * W[..., None], axis=0)
-    # blend slightly with pixelwise median for robustness.
-    med = np.median(I, axis=0)
-    out = 0.75 * fused + 0.25 * med
-    return np.clip(out, 0, 255).astype(np.uint8)
+def fuse_local_crop(records: List[FrameMeta], ref_pos: int, bbox: Tuple[int, int, int, int], radius: int = 6) -> np.ndarray:
+    x1, y1, x2, y2 = bbox
+    ref = load_frame(records[ref_pos].path)
+    ref_crop = ref[y1:y2, x1:x2]
+    if ref_crop.size == 0:
+        return ref_crop
+    h, w = ref_crop.shape[:2]
 
+    left = max(0, ref_pos - radius)
+    right = min(len(records), ref_pos + radius + 1)
+    selected = records[left:right]
 
-def fuse_crop_burst(
-    records: List[FrameMeta],
-    ref_pos: int,
-    bbox: Tuple[int, int, int, int],
-    radius: int = 6,
-    max_neighbors: int = 11,
-) -> Tuple[np.ndarray, List[int]]:
-    ref_frame = load_frame(records[ref_pos].path)
-    positions = list(range(max(0, ref_pos - radius), min(len(records), ref_pos + radius + 1)))
-    positions = sorted(positions, key=lambda p: records[p].sharpness, reverse=True)[:max_neighbors]
-    positions = sorted(positions)
     aligned: List[np.ndarray] = []
-    used: List[int] = []
-    ref_crop = crop_img(ref_frame, bbox)
-    aligned.append(ref_crop)
-    used.append(records[ref_pos].idx)
-    for p in positions:
-        if p == ref_pos:
-            continue
-        frame = load_frame(records[p].path)
-        got = align_local_crop(ref_frame, frame, bbox)
-        if got is None:
+    weights: List[float] = []
+    for record in selected:
+        img = load_frame(record.path)
+        crop = img[y1:y2, x1:x2]
+        if crop.shape[:2] != (h, w):
             continue
-        crop_aligned, _ = got
-        aligned.append(crop_aligned)
-        used.append(records[p].idx)
-    fused = local_sharp_fusion(aligned)
-    return fused, used
+        warp = estimate_affine_to_ref(ref_crop, crop, scale=1.0)
+        aligned_crop = warp_to_ref(crop, warp, (h, w)).astype(np.float32)
+        aligned.append(aligned_crop)
+        weights.append(max(1e-3, record.sharpness))
 
+    if not aligned:
+        return ref_crop
+    w_arr = np.array(weights, dtype=np.float32)
+    w_arr /= np.sum(w_arr)
+    fused = np.zeros_like(aligned[0], dtype=np.float32)
+    for arr, wgt in zip(aligned, w_arr):
+        fused += arr * wgt
+    return np.clip(fused, 0, 255).astype(np.uint8)
 
-# --------------------- deblurring ---------------------
 
-def motion_kernel(length: int, angle_deg: float) -> np.ndarray:
-    length = max(1, int(length))
-    size = max(9, length * 2 + 1)
-    kernel = np.zeros((size, size), np.float32)
-    c = size // 2
-    angle = math.radians(angle_deg)
-    dx = math.cos(angle)
-    dy = math.sin(angle)
-    for i in range(length):
-        t = i - (length - 1) / 2.0
-        x = int(round(c + t * dx))
-        y = int(round(c + t * dy))
-        if 0 <= x < size and 0 <= y < size:
-            kernel[y, x] = 1.0
-    s = float(kernel.sum())
-    if s <= 0:
-        kernel[c, c] = 1.0
-        s = 1.0
-    return kernel / s
-
-
-def wiener_deconv_gray(gray_img: np.ndarray, kernel: np.ndarray, balance: float = 0.01) -> np.ndarray:
-    gray_f = gray_img.astype(np.float32) / 255.0
-    kh, kw = kernel.shape
-    ih, iw = gray_f.shape
-    psf = np.zeros_like(gray_f, dtype=np.float32)
-    y0 = (ih - kh) // 2
-    x0 = (iw - kw) // 2
-    psf[y0:y0 + kh, x0:x0 + kw] = kernel
-    psf = np.fft.ifftshift(psf)
-    G = np.fft.fft2(gray_f)
-    H = np.fft.fft2(psf)
-    F_hat = (np.conj(H) / (np.abs(H) ** 2 + balance)) * G
-    out = np.real(np.fft.ifft2(F_hat))
-    out = np.clip(out, 0.0, 1.0)
-    return (out * 255.0).astype(np.uint8)
+# ---------- detection ----------
 
+def ruler_bbox(frame_bgr: np.ndarray) -> Tuple[int, int, int, int]:
+    h, w = frame_bgr.shape[:2]
+    x1 = int(w * 0.02)
+    x2 = int(w * 0.98)
+    y1 = int(h * 0.08)
+    y2 = int(h * 0.24)
+    return x1, y1, x2, y2
 
-def try_decode(img_bgr: np.ndarray) -> Optional[str]:
-    if zxingcpp is None:
-        return None
-    rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
-    try:
-        result = zxingcpp.read_barcode(rgb)
-        if result is not None and getattr(result, "text", None):
-            return str(result.text)
-    except Exception:
-        return None
-    return None
 
+def detect_datamatrix_candidates(frame_bgr: np.ndarray) -> List[Tuple[int, int, int, int, float]]:
+    h, w = frame_bgr.shape[:2]
+    gray = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2GRAY)
+    x1 = int(w * 0.20)
+    x2 = int(w * 0.88)
+    y1 = int(h * 0.14)
+    y2 = int(h * 0.92)
+    roi = gray[y1:y2, x1:x2]
+
+    blackhat = cv2.morphologyEx(roi, cv2.MORPH_BLACKHAT, np.ones((9, 9), np.uint8))
+    thr = cv2.adaptiveThreshold(blackhat, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 35, -3)
+    mask = cv2.morphologyEx(thr, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8), iterations=2)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8), iterations=1)
 
-def variant_score(img_bgr: np.ndarray) -> float:
-    g = gray(img_bgr)
-    gx = cv2.Sobel(g, cv2.CV_32F, 1, 0, ksize=3)
-    gy = cv2.Sobel(g, cv2.CV_32F, 0, 1, ksize=3)
-    score = float(g.std() + 0.8 * cv2.Laplacian(g, cv2.CV_32F).var())
-    score += 0.8 * float(min(np.mean(np.abs(gx)), np.mean(np.abs(gy))))
-    return score
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    candidates: List[Tuple[int, int, int, int, float]] = []
+    for cnt in contours:
+        x, y, bw, bh = cv2.boundingRect(cnt)
+        area = bw * bh
+        if area < 160 or area > 0.10 * roi.shape[0] * roi.shape[1]:
+            continue
+        aspect = bw / max(1.0, float(bh))
+        if not (0.6 <= aspect <= 1.6):
+            continue
+        patch = gray[y1 + y:y1 + y + bh, x1 + x:x1 + x + bw]
+        if patch.size == 0:
+            continue
+        gx = cv2.Sobel(patch, cv2.CV_32F, 1, 0, ksize=3)
+        gy = cv2.Sobel(patch, cv2.CV_32F, 0, 1, ksize=3)
+        score = float(patch.std() + 0.5 * min(np.abs(gx).mean(), np.abs(gy).mean()))
+        pad = int(max(bw, bh) * 0.35)
+        xx1 = max(0, x1 + x - pad)
+        yy1 = max(0, y1 + y - pad)
+        xx2 = min(w, x1 + x + bw + pad)
+        yy2 = min(h, y1 + y + bh + pad)
+        candidates.append((xx1, yy1, xx2, yy2, score))
 
+    candidates.sort(key=lambda t: t[4], reverse=True)
+    return candidates[:12]
 
-def restore_code_crop(crop_bgr: np.ndarray) -> Tuple[np.ndarray, Optional[str], float]:
-    variants: List[np.ndarray] = []
-    base = crop_bgr
-    variants.append(base)
-    variants.append(unsharp(clahe_bgr(base), sigma=1.0, amount=1.1))
 
-    # Denoise first, then upscale.
-    den = cv2.fastNlMeansDenoisingColored(base, None, 4, 4, 7, 21)
-    variants.append(den)
+# ---------- restoration ----------
 
-    # Use the stronger path on 3x scale for tiny code cells.
-    for scale in (2, 3):
-        up = upscale(den, scale)
-        up = unsharp(clahe_bgr(up), sigma=1.0, amount=1.0)
-        variants.append(up)
+def restore_code_crop(crop_bgr: np.ndarray) -> Tuple[np.ndarray, Optional[str], List[str]]:
+    notes: List[str] = []
+    best_img = crop_bgr
+    best_text: Optional[str] = try_decode_datamatrix(crop_bgr)
+    if best_text:
+        return crop_bgr, best_text, ["Decoded directly from raw crop."]
 
-        g = gray(up)
-        for angle in range(0, 180, 15):
-            for length in (3, 5, 7, 9, 11, 13):
-                k = motion_kernel(length, angle)
-                try:
-                    rl = richardson_lucy(g.astype(np.float32) / 255.0, k, num_iter=12, clip=False)
-                    rl8 = np.clip(rl * 255.0, 0, 255).astype(np.uint8)
-                    variants.append(cv2.cvtColor(rl8, cv2.COLOR_GRAY2BGR))
-                except Exception:
-                    pass
+    base = clahe_l_channel(crop_bgr)
+    best_img = base
+    scales = [2, 3, 4]
+    balances = [0.01, 0.02, 0.04]
+    lengths = [3, 5, 7, 9]
+    angles = [0, 45, 90, 135]
+
+    for scale in scales:
+        up = upscale(base, scale=scale)
+        gray_up = cv2.cvtColor(up, cv2.COLOR_BGR2GRAY)
+
+        # Simple sharpen / threshold paths.
+        variants = [
+            cv2.cvtColor(gray_up, cv2.COLOR_GRAY2BGR),
+            unsharp_mask(up, sigma=0.8, amount=1.0),
+            cv2.cvtColor(cv2.adaptiveThreshold(gray_up, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 31, 5), cv2.COLOR_GRAY2BGR),
+            cv2.cvtColor(cv2.threshold(gray_up, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1], cv2.COLOR_GRAY2BGR),
+        ]
+        for variant in variants:
+            text = try_decode_datamatrix(variant)
+            if text:
+                notes.append(f"Decoded after upscale x{scale} and simple enhancement.")
+                return variant, text, notes
+            best_img = variant
+
+        # Deconvolution sweep.
+        for angle in angles:
+            for length in lengths:
+                kernel = motion_kernel(length, angle)
                 try:
-                    wd = wiener_deconv_gray(g, k, balance=0.005)
-                    variants.append(cv2.cvtColor(wd, cv2.COLOR_GRAY2BGR))
+                    rl = richardson_lucy_gray(gray_up, kernel, iterations=15)
+                    rl_bgr = cv2.cvtColor(rl, cv2.COLOR_GRAY2BGR)
+                    text = try_decode_datamatrix(rl_bgr)
+                    if text:
+                        notes.append(f"Decoded after Richardson-Lucy, scale={scale}, len={length}, angle={angle}.")
+                        return rl_bgr, text, notes
+                    best_img = rl_bgr
                 except Exception:
                     pass
+                for balance in balances:
+                    try:
+                        wd = wiener_deconv_gray(gray_up, kernel, balance=balance)
+                        wd_bgr = cv2.cvtColor(wd, cv2.COLOR_GRAY2BGR)
+                        text = try_decode_datamatrix(wd_bgr)
+                        if text:
+                            notes.append(f"Decoded after Wiener, scale={scale}, len={length}, angle={angle}, balance={balance}.")
+                            return wd_bgr, text, notes
+                        best_img = wd_bgr
+                    except Exception:
+                        pass
 
-        # Threshold families after sharpening/deconvolution.
-        for v in variants[-10:]:
-            vg = gray(v)
-            thr1 = cv2.adaptiveThreshold(vg, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 31, 5)
-            thr2 = cv2.threshold(vg, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
-            variants.append(cv2.cvtColor(thr1, cv2.COLOR_GRAY2BGR))
-            variants.append(cv2.cvtColor(thr2, cv2.COLOR_GRAY2BGR))
-
-    best_img = base
-    best_score = -1e18
-    best_text: Optional[str] = None
-    seen = set()
-    for v in variants:
-        key = (v.shape[0], v.shape[1], int(v.mean()), int(v.std()))
-        if key in seen:
-            continue
-        seen.add(key)
-        text = try_decode(v)
-        score = variant_score(v)
-        if text:
-            return v, text, score + 1e9
-        if score > best_score:
-            best_score = score
-            best_img = v
-    return best_img, best_text, best_score
-
-
-# --------------------- ruler and summary ---------------------
-
-def ruler_bbox(frame_bgr: np.ndarray) -> Tuple[int, int, int, int]:
-    h, w = frame_bgr.shape[:2]
-    return int(0.02 * w), int(0.08 * h), int(0.98 * w), int(0.26 * h)
+    notes.append("No decode achieved; best restored candidate saved for manual inspection.")
+    return best_img, None, notes
 
 
-def annotate_frame(frame_bgr: np.ndarray, code_bbox: Optional[Tuple[int, int, int, int]]) -> np.ndarray:
-    out = frame_bgr.copy()
-    rx1, ry1, rx2, ry2 = ruler_bbox(out)
-    cv2.rectangle(out, (rx1, ry1), (rx2, ry2), (0, 255, 255), 2)
-    cv2.putText(out, "Ruler ROI", (rx1, max(20, ry1 - 10)), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 255), 2, cv2.LINE_AA)
-    if code_bbox is not None:
-        x1, y1, x2, y2 = code_bbox
-        cv2.rectangle(out, (x1, y1), (x2, y2), (0, 200, 0), 2)
-        cv2.putText(out, "Best code ROI", (x1, max(20, y1 - 10)), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 200, 0), 2, cv2.LINE_AA)
-    return out
+# ---------- outputs ----------
 
+def bgr_to_pil(img_bgr: np.ndarray) -> Image.Image:
+    return Image.fromarray(cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB))
 
-def bgr_to_pil(img: np.ndarray) -> Image.Image:
-    return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
 
-
-def make_contact_sheet(items: List[Tuple[str, np.ndarray]], out_path: Path) -> Path:
-    tiles = []
-    for title, img in items:
+def make_contact_sheet(images: List[Tuple[str, np.ndarray]], out_path: Path) -> Path:
+    pil_images = []
+    for title, img in images:
         pil = bgr_to_pil(img)
         pil.thumbnail((520, 520))
-        canvas = Image.new("RGB", (pil.width, pil.height + 36), (255, 255, 255))
-        canvas.paste(pil, (0, 36))
+        canvas = Image.new("RGB", (pil.width, pil.height + 34), (255, 255, 255))
+        canvas.paste(pil, (0, 34))
         draw = ImageDraw.Draw(canvas)
         draw.text((8, 8), title, fill=(0, 0, 0))
-        tiles.append(canvas)
+        pil_images.append(canvas)
 
     cols = 2
-    rows = int(math.ceil(len(tiles) / cols))
-    cell_w = max(t.width for t in tiles)
-    cell_h = max(t.height for t in tiles)
+    rows = math.ceil(len(pil_images) / cols)
+    cell_w = max(im.width for im in pil_images)
+    cell_h = max(im.height for im in pil_images)
     sheet = Image.new("RGB", (cols * cell_w, rows * cell_h), (245, 245, 245))
-    for i, tile in enumerate(tiles):
+    for i, im in enumerate(pil_images):
         x = (i % cols) * cell_w
         y = (i // cols) * cell_h
-        sheet.paste(tile, (x, y))
+        sheet.paste(im, (x, y))
     sheet.save(out_path)
     return out_path
 
 
 def write_video(frames: List[np.ndarray], out_path: Path, fps: float) -> Path:
-    writer = imageio.get_writer(str(out_path), fps=max(1.0, fps), codec="libx264", quality=8)
+    if not frames:
+        raise ValueError("No frames provided for video writing.")
+
+    h, w = frames[0].shape[:2]
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(str(out_path), fourcc, float(max(1.0, fps)), (w, h))
+    if not writer.isOpened():
+        raise RuntimeError(f"Could not open video writer for {out_path}")
+
     try:
-        for fr in frames:
-            writer.append_data(cv2.cvtColor(fr, cv2.COLOR_BGR2RGB))
+        for frame in frames:
+            if frame.shape[:2] != (h, w):
+                frame = cv2.resize(frame, (w, h), interpolation=cv2.INTER_CUBIC)
+            if frame.dtype != np.uint8:
+                frame = np.clip(frame, 0, 255).astype(np.uint8)
+            writer.write(frame)
     finally:
-        writer.close()
+        writer.release()
     return out_path
 
 
-# --------------------- main pipeline ---------------------
+# ---------- main pipeline ----------
 
 def process_video(
     video_input: Union[str, Dict, None],
@@ -538,161 +470,146 @@ def process_video(
     stride: int,
     max_frames: int,
     burst_radius: int,
-) -> Generator[Tuple[Optional[str], Optional[str], Optional[str], str, str], None, None]:
+) -> Generator[Tuple[Optional[str], Optional[str], str], None, None]:
     logs: List[str] = []
 
-    def emit(msg: str) -> Tuple[Optional[str], Optional[str], Optional[str], str, str]:
+    def emit(msg: str) -> Tuple[Optional[str], Optional[str], str]:
         logs.append(msg)
-        return None, None, None, "", "\n".join(logs)
+        return None, None, "\n".join(logs)
 
     try:
         video_path = resolve_video_path(video_input)
-        work = ensure_dir(Path(tempfile.mkdtemp(prefix="motion_deblur_")))
-        frames_dir = ensure_dir(work / "frames")
-        outputs_dir = ensure_dir(work / "outputs")
+        yield emit(f"Workspace: creating temporary workspace ...")
+        work = Path(tempfile.mkdtemp(prefix="motion_deblur_"))
+        logs[-1] = f"Workspace: {work}"
+        yield None, None, "\n".join(logs)
 
-        yield emit(f"Workspace: {work}")
         info = get_video_info(video_path)
         yield emit("Input video info: " + json.dumps(info, indent=2))
 
+        raw_dir = ensure_dir(work / "frames_raw")
         yield emit("Starting frame extraction ...")
-        records = extract_frames(video_path, frames_dir, stride=max(1, int(stride)), max_frames=max(0, int(max_frames)))
+        records = extract_frames(video_path, raw_dir, stride=max(1, stride), max_frames=max_frames)
         yield emit(f"Extracted {len(records)} frame(s).")
 
-        ref_pos = choose_reference_frame(records)
+        ref_pos = choose_reference_index(records)
         ref_record = records[ref_pos]
-        ref_frame = load_frame(ref_record.path)
-        yield emit(f"Selected reference frame: {ref_record.idx} (sharpness={ref_record.sharpness:.1f}, dm_score={ref_record.dm_score:.1f})")
-
-        candidates = detect_datamatrix_candidates(ref_frame)
-        if not candidates:
-            yield emit("No strong code candidate in reference frame. Searching neighboring high-score frames ...")
-            ranked_positions = sorted(range(len(records)), key=lambda i: (records[i].dm_score, records[i].sharpness), reverse=True)[:12]
-            best_cands = []
-            for pos in ranked_positions:
-                fr = load_frame(records[pos].path)
-                cands = detect_datamatrix_candidates(fr)
-                if cands:
-                    best_cands = cands
-                    ref_pos = pos
-                    ref_record = records[pos]
-                    ref_frame = fr
-                    candidates = cands
-                    yield emit(f"Switched reference frame to: {ref_record.idx}")
-                    break
+        yield emit(f"Selected reference frame: index {ref_record.idx}.")
+
+        if mode == "Advanced stable":
+            yield emit("Starting global burst fusion ...")
+            fused_frame, used_indices = fuse_global_burst(records, ref_pos, radius=burst_radius)
+            yield emit(f"Global burst fusion completed using frames: {used_indices}")
+        else:
+            fused_frame = unsharp_mask(clahe_l_channel(load_frame(ref_record.path)), sigma=1.0, amount=1.0)
+            yield emit("Using single-frame enhancement mode.")
+
+        # Ruler crop
+        rx1, ry1, rx2, ry2 = ruler_bbox(fused_frame)
+        ruler_crop = fused_frame[ry1:ry2, rx1:rx2]
+        ruler_crop = unsharp_mask(clahe_l_channel(ruler_crop), sigma=0.8, amount=1.1)
+        yield emit("Ruler crop reconstructed.")
+
+        # Code candidate search on fused frame.
+        yield emit("Searching DataMatrix candidates ...")
+        candidates = detect_datamatrix_candidates(fused_frame)
         if not candidates:
-            raise RuntimeError("No plausible DataMatrix candidate was found in the video.")
-
-        best_overall: Optional[CropResult] = None
-        best_code_image: Optional[np.ndarray] = None
-
-        max_candidates = 3 if mode == "Advanced stable (recommended)" else 1
-        for ci, cand in enumerate(candidates[:max_candidates], start=1):
-            x1, y1, x2, y2, score = cand
-            bbox = (x1, y1, x2, y2)
-            yield emit(f"Processing code candidate {ci}/{min(max_candidates, len(candidates))} at bbox={bbox}")
-
-            crop_pad = max(12, int(0.35 * max(x2 - x1, y2 - y1)))
-            burst_bbox = pad_bbox(bbox, crop_pad, ref_frame.shape[:2])
-            fused_crop, used = fuse_crop_burst(records, ref_pos, burst_bbox, radius=max(1, int(burst_radius)), max_neighbors=11)
-            yield emit(f"Local burst fusion used {len(used)} frame(s): {used}")
-
-            if mode == "Fast stable":
-                restored = unsharp(clahe_bgr(fused_crop), sigma=1.0, amount=1.0)
-                decoded = try_decode(restored)
-                score2 = variant_score(restored) + (1e9 if decoded else 0.0)
+            code_crop = np.zeros((160, 160, 3), dtype=np.uint8)
+            decode_text = None
+            code_bbox = None
+            yield emit("No plausible DataMatrix candidate found.")
+        else:
+            best_candidate = candidates[0]
+            code_bbox = tuple(map(int, best_candidate[:4]))
+            yield emit(f"Top candidate bbox: {code_bbox}")
+            if mode == "Advanced stable":
+                yield emit("Starting local crop fusion for code region ...")
+                local_fused = fuse_local_crop(records, ref_pos, code_bbox, radius=max(4, burst_radius + 1))
+                yield emit("Local crop fusion completed.")
             else:
-                yield emit("Running aggressive code restoration sweep ...")
-                restored, decoded, score2 = restore_code_crop(fused_crop)
-
-            result = CropResult(frame_idx=ref_record.idx, bbox=burst_bbox, crop=restored, score=score + score2, decoded_text=decoded)
-            if best_overall is None or result.score > best_overall.score:
-                best_overall = result
-                best_code_image = restored
-
-            if decoded:
-                yield emit(f"Decoded DataMatrix text: {decoded}")
-                break
-
-        if best_overall is None or best_code_image is None:
-            raise RuntimeError("No code crop could be reconstructed.")
-
-        yield emit("Reconstructing ruler crop with local burst fusion ...")
-        rb = ruler_bbox(ref_frame)
-        ruler_crop, ruler_used = fuse_crop_burst(records, ref_pos, rb, radius=max(1, int(burst_radius)), max_neighbors=9)
-        ruler_crop = unsharp(clahe_bgr(ruler_crop), sigma=1.0, amount=1.1)
-        yield emit(f"Ruler burst fusion used {len(ruler_used)} frame(s): {ruler_used}")
-
-        annotated = annotate_frame(ref_frame, best_overall.bbox)
-        summary_path = outputs_dir / "summary.png"
-        code_path = outputs_dir / "best_code.png"
-        cv2.imwrite(str(code_path), best_code_image)
+                x1, y1, x2, y2 = code_bbox
+                local_fused = fused_frame[y1:y2, x1:x2]
+
+            yield emit("Running code restoration sweep ...")
+            code_crop, decode_text, notes = restore_code_crop(local_fused)
+            for note in notes:
+                yield emit(note)
+
+        # Review frame with overlays.
+        review = fused_frame.copy()
+        cv2.rectangle(review, (rx1, ry1), (rx2, ry2), (0, 255, 0), 2)
+        if code_bbox is not None:
+            x1, y1, x2, y2 = code_bbox
+            cv2.rectangle(review, (x1, y1), (x2, y2), (0, 165, 255), 2)
+
+        summary_path = work / "summary.png"
         make_contact_sheet(
             [
-                ("Reference frame with ROIs", annotated),
-                ("Fused ruler crop", ruler_crop),
-                ("Best restored code crop", best_code_image),
-                ("Reference crop before restoration", crop_img(ref_frame, best_overall.bbox)),
+                (f"Reference / fused frame #{ref_record.idx}", review),
+                ("Ruler crop", ruler_crop),
+                ("Best DataMatrix crop", code_crop),
+                ("Fused frame", fused_frame),
             ],
             summary_path,
         )
         yield emit(f"Summary image written: {summary_path}")
 
         yield emit("Writing enhanced review video ...")
-        preview_frames: List[np.ndarray] = []
-        for rec in records:
-            fr = load_frame(rec.path)
-            preview_frames.append(annotate_frame(unsharp(clahe_bgr(fr), sigma=1.0, amount=0.8), best_overall.bbox))
-        out_video = outputs_dir / "enhanced_review.mp4"
-        write_video(preview_frames, out_video, fps=float(info.get("fps", 15.0) or 15.0))
+        enhanced_frames: List[np.ndarray] = []
+        for record in records:
+            frame = load_frame(record.path)
+            enhanced = unsharp_mask(clahe_l_channel(frame), sigma=0.9, amount=0.9)
+            enhanced_frames.append(enhanced)
+        out_video = work / "enhanced.mp4"
+        write_video(enhanced_frames, out_video, fps=max(1.0, info["fps"] / max(1, stride)))
         yield emit(f"Enhanced review video written: {out_video}")
 
-        decoded_text = best_overall.decoded_text or "No decode yet. Best restored crop exported for manual review."
-        logs_text = "\n".join(logs)
-        yield str(out_video), str(summary_path), str(code_path), decoded_text, logs_text
-    except Exception as exc:
-        logs.append(f"Error: {type(exc).__name__}: {exc}")
-        raise gr.Error("\n".join(logs))
-
+        if decode_text:
+            yield str(out_video), str(summary_path), "\n".join(logs + [f"Decoded text: {decode_text}"])
+        else:
+            yield str(out_video), str(summary_path), "\n".join(logs + ["Decoded text: none"])
 
-# --------------------- UI ---------------------
+    except Exception as e:
+        logs.append(f"Error: {type(e).__name__}: {e}")
+        raise gr.Error("\n".join(logs))
 
-def build_demo() -> gr.Blocks:
-    with gr.Blocks(title="Motion Blur Recovery for Tool Video") as demo:
-        gr.Markdown(
-            "# Motion Blur Recovery for Tool Video\n"
-            "Stable hybrid pipeline focused on the ruler and the DataMatrix region.\n"
-            "Use **Advanced stable** for stronger local reconstruction."
-        )
-        with gr.Row():
-            with gr.Column(scale=1):
-                video_in = gr.Video(label="Input video")
-                mode = gr.Dropdown(
-                    choices=["Advanced stable (recommended)", "Fast stable"],
-                    value="Advanced stable (recommended)",
-                    label="Processing mode",
-                )
-                stride = gr.Slider(1, 4, value=1, step=1, label="Frame stride")
-                max_frames = gr.Slider(0, 300, value=0, step=1, label="Max frames (0 = all)")
-                burst_radius = gr.Slider(2, 10, value=6, step=1, label="Neighbor radius for local burst fusion")
-                run_btn = gr.Button("Process video", variant="primary")
-            with gr.Column(scale=1):
-                out_video = gr.Video(label="Enhanced review video")
-                out_summary = gr.Image(label="Summary image", type="filepath")
-                out_code = gr.Image(label="Best restored code crop", type="filepath")
-                decoded = gr.Textbox(label="Decoded text / status")
-                logs = gr.Textbox(label="Log", lines=20)
-
-        run_btn.click(
-            fn=process_video,
-            inputs=[video_in, mode, stride, max_frames, burst_radius],
-            outputs=[out_video, out_summary, out_code, decoded, logs],
-        )
-    return demo
 
+DESCRIPTION = """
+# Motion-deblur tool for handheld machine-tool inspection videos
+
+This version stays on a stable, self-contained path:
+- no external repo cloning
+- no model downloads
+- Python + OpenCV + local multi-frame fusion
+- simple stage logging only
+
+Recommended mode:
+- **Advanced stable** for the best self-contained result
+- **Baseline** if you want the simplest fallback
+"""
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(DESCRIPTION)
+    with gr.Row():
+        with gr.Column(scale=1):
+            video = gr.Video(label="Input video")
+            mode = gr.Dropdown(["Advanced stable", "Baseline"], value="Advanced stable", label="Mode")
+            stride = gr.Slider(1, 4, value=1, step=1, label="Frame stride")
+            max_frames = gr.Slider(0, 600, value=0, step=1, label="Max frames (0 = all extracted frames)")
+            burst_radius = gr.Slider(2, 10, value=6, step=1, label="Burst radius")
+            run_btn = gr.Button("Process", variant="primary")
+        with gr.Column(scale=1):
+            out_video = gr.Video(label="Enhanced video")
+            out_image = gr.Image(label="Summary")
+            out_log = gr.Textbox(label="Logs", lines=24)
+
+    run_btn.click(
+        fn=process_video,
+        inputs=[video, mode, stride, max_frames, burst_radius],
+        outputs=[out_video, out_image, out_log],
+    )
 
-demo = build_demo()
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)
-