batch_deblur.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Batch Image Deblurring - Interactive terminal application
==========================================================

This program processes all images in the input-images folder using the selected algorithm
and places the results in output-images/<algorithm>/.

Requirements:
    Python 3.10+
    pip install numpy scipy opencv-python scikit-image pillow

Run:
    python batch_deblur.py

Custom paths (optional):
    python batch_deblur.py --input-dir ./my-input --output-dir ./my-output

Image processing note:
    Deblurring requires a suitable estimate of the PSF (point spread function / blur kernel).
    If the PSF type, length, or angle does not match the actual blur, no classical algorithm
    can guarantee an accurate, artifact-free result.
"""

from __future__ import annotations

import argparse
import copy
import hashlib
import inspect
import json
import math
import os
import platform
import re
import sys
import time
import traceback
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import Any, Callable, Final

# ---------------------------------------------------------------------------
# Dependency loading
# ---------------------------------------------------------------------------

_DEPENDENCY_ERROR: Exception | None = None

try:
    import cv2
    import numpy as np
    import scipy
    from PIL import Image
    from scipy import fft as sp_fft
    from skimage import __version__ as skimage_version
    from skimage.restoration import (
        richardson_lucy,
        unsupervised_wiener,
        wiener,
    )
except ImportError as exc:  # A friendly message is shown in main().
    _DEPENDENCY_ERROR = exc


APP_NAME: Final[str] = "Batch Image Deblurring"
APP_VERSION: Final[str] = "1.0.0"

SUPPORTED_EXTENSIONS: Final[set[str]] = {
    ".jpg",
    ".jpeg",
    ".png",
    ".bmp",
    ".tif",
    ".tiff",
    ".webp",
}

EXIF_ORIENTATION_TAG: Final[int] = 274
EPSILON: Final[float] = 1e-8


# ---------------------------------------------------------------------------
# UI helpers
# ---------------------------------------------------------------------------

class UI:
    """Small dependency-free terminal UI with validation and optional color."""

    RESET = "\033[0m"
    BOLD = "\033[1m"
    DIM = "\033[2m"
    CYAN = "\033[36m"
    GREEN = "\033[32m"
    YELLOW = "\033[33m"
    RED = "\033[31m"
    BLUE = "\033[34m"

    def __init__(self, use_color: bool = True) -> None:
        self.use_color = (
            use_color
            and sys.stdout.isatty()
            and os.environ.get("NO_COLOR") is None
        )

    def style(self, text: str, *codes: str) -> str:
        if not self.use_color:
            return text
        return "".join(codes) + text + self.RESET

    def rule(self, char: str = "─", width: int = 72) -> None:
        print(self.style(char * width, self.DIM))

    def header(self) -> None:
        self.rule("═")
        print(self.style(f"  {APP_NAME}  v{APP_VERSION}", self.BOLD, self.CYAN))
        print("  Batch image processing with true deconvolution")
        self.rule("═")

    def section(self, title: str) -> None:
        print()
        print(self.style(f"◆ {title}", self.BOLD, self.BLUE))
        self.rule()

    def info(self, text: str) -> None:
        print(self.style("ℹ ", self.CYAN) + text)

    def success(self, text: str) -> None:
        print(self.style("✓ ", self.GREEN) + text)

    def warning(self, text: str) -> None:
        print(self.style("⚠ ", self.YELLOW) + text)

    def error(self, text: str) -> None:
        print(self.style("✗ ", self.RED) + text, file=sys.stderr)

    def menu_item(self, key: str, title: str, description: str) -> None:
        key_text = self.style(f"[{key}]", self.BOLD, self.CYAN)
        print(f"  {key_text} {self.style(title, self.BOLD)}")
        print(f"      {self.style(description, self.DIM)}")

    def ask_choice(
        self,
        prompt: str,
        valid_choices: set[str],
        *,
        default: str | None = None,
    ) -> str:
        while True:
            default_hint = f" [{default}]" if default is not None else ""
            try:
                value = input(f"{prompt}{default_hint}: ").strip()
            except EOFError as exc:
                raise KeyboardInterrupt from exc

            if not value and default is not None:
                return default
            if value in valid_choices:
                return value
            self.warning("Invalid choice; enter one of the displayed options.")

    def ask_yes_no(self, prompt: str, *, default: bool = True) -> bool:
        hint = "Y/n" if default else "y/N"
        while True:
            try:
                value = input(f"{prompt} [{hint}]: ").strip().lower()
            except EOFError as exc:
                raise KeyboardInterrupt from exc

            if not value:
                return default
            if value in {"y", "yes", "1", "yeah", "yep"}:
                return True
            if value in {"n", "no", "0", "nope", "nah"}:
                return False
            self.warning("Please enter y or n.")

    def ask_int(
        self,
        prompt: str,
        *,
        default: int,
        minimum: int,
        maximum: int,
        odd: bool = False,
    ) -> int:
        while True:
            try:
                raw = input(f"{prompt} [{default}]: ").strip()
            except EOFError as exc:
                raise KeyboardInterrupt from exc

            if not raw:
                value = default
            else:
                try:
                    value = int(raw)
                except ValueError:
                    self.warning("Enter an integer.")
                    continue

            if not minimum <= value <= maximum:
                self.warning(f"Number must be between {minimum} and {maximum}.")
                continue
            if odd and value % 2 == 0:
                self.warning("Kernel size must be odd.")
                continue
            return value

    def ask_float(
        self,
        prompt: str,
        *,
        default: float,
        minimum: float,
        maximum: float,
        strictly_positive: bool = False,
    ) -> float:
        while True:
            try:
                raw = input(f"{prompt} [{default:g}]: ").strip()
            except EOFError as exc:
                raise KeyboardInterrupt from exc

            if not raw:
                value = default
            else:
                try:
                    value = float(raw)
                except ValueError:
                    self.warning("Enter a valid number.")
                    continue

            if not math.isfinite(value):
                self.warning("Number must be finite.")
                continue
            if strictly_positive and value <= 0:
                self.warning("Number must be greater than zero.")
                continue
            if not minimum <= value <= maximum:
                self.warning(f"Number must be between {minimum:g} and {maximum:g}.")
                continue
            return value


# ---------------------------------------------------------------------------
# Data models and algorithm registry
# ---------------------------------------------------------------------------

@dataclass(frozen=True)
class AlgorithmInfo:
    slug: str
    title: str
    description: str
    speed: str


@dataclass
class PSFConfig:
    kind: str
    label: str
    params: dict[str, Any]
    kernel: "np.ndarray"
    file_tag: str

    def report_data(self) -> dict[str, Any]:
        return {
            "kind": self.kind,
            "label": self.label,
            "params": self.params,
            "shape": list(self.kernel.shape),
            "sum": float(self.kernel.sum()),
            "file_tag": self.file_tag,
        }


@dataclass(frozen=True)
class ScaleInfo:
    dtype_name: str
    low: float
    high: float
    is_integer: bool
    integer_min: int | None = None
    integer_max: int | None = None


ALGORITHMS: Final[dict[str, AlgorithmInfo]] = {
    "wiener": AlgorithmInfo(
        slug="wiener",
        title="Wiener–Hunt",
        description="Fast and stable; a good starting choice and suitable for noisy images.",
        speed="Fast",
    ),
    "richardson_lucy": AlgorithmInfo(
        slug="richardson-lucy",
        title="Richardson–Lucy",
        description="Iterative and sharper; sensitive to noise and ringing at high iteration counts.",
        speed="Medium",
    ),
    "tikhonov": AlgorithmInfo(
        slug="tikhonov",
        title="Tikhonov / Laplacian",
        description="Stable frequency-domain solution with Laplacian regularization.",
        speed="Very fast",
    ),
    "tv_admm": AlgorithmInfo(
        slug="tv-admm",
        title="Total Variation with ADMM",
        description="Edge-preserving and suitable for natural images; slower than the classical options.",
        speed="Slow",
    ),
    "unsupervised_wiener": AlgorithmInfo(
        slug="unsupervised-wiener",
        title="Unsupervised Wiener",
        description="Estimates the regularization parameter using Gibbs sampling.",
        speed="Slow",
    ),
}

MENU_TO_ALGORITHM: Final[dict[str, str]] = {
    "1": "wiener",
    "2": "richardson_lucy",
    "3": "tikhonov",
    "4": "tv_admm",
    "5": "unsupervised_wiener",
}

PROFILE_DEFAULTS: Final[dict[str, dict[str, dict[str, Any]]]] = {
    "gentle": {
        "wiener": {"balance": 0.08},
        "richardson_lucy": {"iterations": 15, "filter_epsilon": 1e-7},
        "tikhonov": {"regularization": 0.020},
        "tv_admm": {"tv_weight": 0.020, "rho": 1.0, "iterations": 50},
        "unsupervised_wiener": {
            "threshold": 1e-4,
            "burnin": 10,
            "min_iterations": 20,
            "max_iterations": 80,
        },
    },
    "balanced": {
        "wiener": {"balance": 0.03},
        "richardson_lucy": {"iterations": 30, "filter_epsilon": 1e-7},
        "tikhonov": {"regularization": 0.008},
        "tv_admm": {"tv_weight": 0.010, "rho": 1.0, "iterations": 80},
        "unsupervised_wiener": {
            "threshold": 1e-4,
            "burnin": 15,
            "min_iterations": 30,
            "max_iterations": 150,
        },
    },
    "aggressive": {
        "wiener": {"balance": 0.01},
        "richardson_lucy": {"iterations": 50, "filter_epsilon": 1e-8},
        "tikhonov": {"regularization": 0.003},
        "tv_admm": {"tv_weight": 0.005, "rho": 1.0, "iterations": 120},
        "unsupervised_wiener": {
            "threshold": 5e-5,
            "burnin": 20,
            "min_iterations": 40,
            "max_iterations": 250,
        },
    },
}

PROFILE_LABELS: Final[dict[str, str]] = {
    "gentle": "Gentle",
    "balanced": "Balanced",
    "aggressive": "Aggressive",
    "custom": "Custom",
}


# ---------------------------------------------------------------------------
# PSF generation and loading
# ---------------------------------------------------------------------------

def make_odd(value: int) -> int:
    return value if value % 2 == 1 else value + 1


def normalize_psf(kernel: "np.ndarray") -> "np.ndarray":
    kernel = np.asarray(kernel, dtype=np.float32)
    kernel = np.squeeze(kernel)

    if kernel.ndim != 2:
        raise ValueError("PSF must be a two-dimensional array.")
    if min(kernel.shape) < 1:
        raise ValueError("PSF is empty.")
    if not np.all(np.isfinite(kernel)):
        raise ValueError("PSF contains NaN or Infinity.")
    if np.any(kernel < 0):
        raise ValueError("PSF values must be nonnegative.")

    total = float(kernel.sum())
    if total <= EPSILON:
        raise ValueError("The sum of PSF values must be greater than zero.")

    return np.ascontiguousarray(kernel / total, dtype=np.float32)


def gaussian_psf(size: int, sigma: float) -> "np.ndarray":
    radius = size // 2
    axis = np.arange(-radius, radius + 1, dtype=np.float32)
    xx, yy = np.meshgrid(axis, axis)
    kernel = np.exp(-(xx * xx + yy * yy) / (2.0 * sigma * sigma))
    return normalize_psf(kernel)


def box_psf(size: int) -> "np.ndarray":
    return normalize_psf(np.ones((size, size), dtype=np.float32))


def motion_psf(length: float, angle_degrees: float, oversample: int = 8) -> "np.ndarray":
    """Create an anti-aliased one-pixel-wide linear motion PSF."""
    kernel_size = make_odd(max(3, int(math.ceil(length)) + 2))
    high_size = kernel_size * oversample
    canvas = np.zeros((high_size, high_size), dtype=np.float32)

    center = (high_size - 1) / 2.0
    half_length = max(0.5, (length * oversample - 1.0) / 2.0)
    theta = math.radians(angle_degrees)
    dx = math.cos(theta) * half_length
    dy = math.sin(theta) * half_length

    p1 = (int(round(center - dx)), int(round(center - dy)))
    p2 = (int(round(center + dx)), int(round(center + dy)))

    # A high-resolution line is area-downsampled to obtain sub-pixel coverage.
    cv2.line(
        canvas,
        p1,
        p2,
        color=1.0,
        thickness=oversample,
        lineType=cv2.LINE_AA,
    )
    kernel = cv2.resize(
        canvas,
        (kernel_size, kernel_size),
        interpolation=cv2.INTER_AREA,
    )
    return normalize_psf(kernel)


def resolve_user_path(raw_path: str, script_dir: Path) -> Path:
    candidate = Path(raw_path).expanduser()
    if candidate.is_absolute():
        return candidate.resolve()

    cwd_candidate = (Path.cwd() / candidate).resolve()
    if cwd_candidate.exists():
        return cwd_candidate
    return (script_dir / candidate).resolve()


def load_custom_psf(path: Path) -> "np.ndarray":
    if not path.is_file():
        raise ValueError(f"Kernel file not found: {path}")

    if path.suffix.lower() == ".npy":
        kernel = np.load(path, allow_pickle=False)
    else:
        data = np.frombuffer(path.read_bytes(), dtype=np.uint8)
        image = cv2.imdecode(data, cv2.IMREAD_GRAYSCALE)
        if image is None:
            raise ValueError("Kernel file cannot be read; use a grayscale image or a .npy file.")
        kernel = image.astype(np.float32)

    kernel = np.squeeze(np.asarray(kernel))
    if kernel.ndim != 2:
        raise ValueError("Custom kernel must be exactly two-dimensional.")

    # Odd dimensions remove half-pixel ambiguity when the PSF is centered.
    pad_bottom = 1 if kernel.shape[0] % 2 == 0 else 0
    pad_right = 1 if kernel.shape[1] % 2 == 0 else 0
    if pad_bottom or pad_right:
        kernel = np.pad(kernel, ((0, pad_bottom), (0, pad_right)), mode="constant")

    return normalize_psf(kernel)


def safe_tag_component(text: str, max_length: int = 24) -> str:
    text = re.sub(r"[^A-Za-z0-9._-]+", "-", text).strip("-._")
    return (text or "kernel")[:max_length]


def number_tag(value: float) -> str:
    text = f"{value:.3f}".rstrip("0").rstrip(".")
    return text.replace("-", "m").replace(".", "p")


def choose_psf(ui: UI, script_dir: Path) -> PSFConfig:
    ui.section("Blur Model / PSF Selection")
    ui.info("For proper deblurring, the PSF should match the actual image blur as closely as possible.")
    ui.menu_item("1", "Motion blur", "Length and angle of camera or subject motion")
    ui.menu_item("2", "Gaussian blur", "Approximate out-of-focus blur")
    ui.menu_item("3", "Box blur", "Uniform averaging")
    ui.menu_item("4", "Custom PSF", "Grayscale image file or NumPy array with a .npy extension")

    choice = ui.ask_choice("Select the PSF type", {"1", "2", "3", "4"}, default="1")

    if choice == "1":
        length = ui.ask_float(
            "Motion blur length in pixels",
            default=15.0,
            minimum=1.0,
            maximum=301.0,
            strictly_positive=True,
        )
        angle = ui.ask_float(
            "Angle; 0 is horizontal, 90 is vertical, and positive is clockwise",
            default=0.0,
            minimum=-360.0,
            maximum=360.0,
        )
        normalized_angle = angle % 180.0
        kernel = motion_psf(length, normalized_angle)
        return PSFConfig(
            kind="motion",
            label=f"Motion blur: length={length:g}px, angle={normalized_angle:g}°",
            params={"length_px": length, "angle_degrees": normalized_angle},
            kernel=kernel,
            file_tag=f"motion-L{number_tag(length)}-A{number_tag(normalized_angle)}",
        )

    if choice == "2":
        sigma = ui.ask_float(
            "Gaussian sigma",
            default=2.0,
            minimum=0.1,
            maximum=50.0,
            strictly_positive=True,
        )
        recommended_size = make_odd(max(3, int(math.ceil(6.0 * sigma)) + 1))
        recommended_size = min(recommended_size, 301)
        size = ui.ask_int(
            "Gaussian kernel size (odd)",
            default=recommended_size,
            minimum=3,
            maximum=301,
            odd=True,
        )
        kernel = gaussian_psf(size, sigma)
        return PSFConfig(
            kind="gaussian",
            label=f"Gaussian blur: kernel={size}×{size}, sigma={sigma:g}",
            params={"kernel_size": size, "sigma": sigma},
            kernel=kernel,
            file_tag=f"gaussian-K{size}-S{number_tag(sigma)}",
        )

    if choice == "3":
        size = ui.ask_int(
            "Box kernel size (odd)",
            default=5,
            minimum=3,
            maximum=301,
            odd=True,
        )
        kernel = box_psf(size)
        return PSFConfig(
            kind="box",
            label=f"Box blur: kernel={size}×{size}",
            params={"kernel_size": size},
            kernel=kernel,
            file_tag=f"box-K{size}",
        )

    while True:
        try:
            raw = input("Custom PSF file path: ").strip()
        except EOFError as exc:
            raise KeyboardInterrupt from exc
        if not raw:
            ui.warning("Enter a file path.")
            continue
        try:
            path = resolve_user_path(raw, script_dir)
            kernel = load_custom_psf(path)
            break
        except (OSError, ValueError) as exc:
            ui.warning(str(exc))

    kernel_name = safe_tag_component(path.stem)
    return PSFConfig(
        kind="custom",
        label=f"Custom PSF: {path.name}, shape={kernel.shape[0]}×{kernel.shape[1]}",
        params={"source": str(path), "kernel_shape": list(kernel.shape)},
        kernel=kernel,
        file_tag=f"custom-{kernel_name}-K{kernel.shape[0]}x{kernel.shape[1]}",
    )


# ---------------------------------------------------------------------------
# Algorithm parameter UX
# ---------------------------------------------------------------------------

def choose_algorithms(ui: UI) -> list[str]:
    ui.section("Deblurring Algorithm Selection")
    for menu_key, algorithm_key in MENU_TO_ALGORITHM.items():
        info = ALGORITHMS[algorithm_key]
        ui.menu_item(menu_key, info.title, f"{info.description}  Speed: {info.speed}")
    ui.menu_item("6", "Run all algorithms", "For comparison; each method is saved in a separate folder.")
    ui.menu_item("0", "Exit", "End the program without processing")

    choice = ui.ask_choice("Select an algorithm", set(MENU_TO_ALGORITHM) | {"0", "6"}, default="1")
    if choice == "0":
        return []
    if choice == "6":
        return list(ALGORITHMS.keys())
    return [MENU_TO_ALGORITHM[choice]]


def choose_profile(ui: UI) -> str:
    ui.section("Algorithm Strength and Settings")
    ui.menu_item("1", "Balanced (recommended)", "A good balance of sharpness, noise, and ringing")
    ui.menu_item("2", "Gentle", "Fewer artifacts; more conservative correction")
    ui.menu_item("3", "Aggressive", "More sharpness; higher chance of noise and ringing")
    ui.menu_item("4", "Custom", "Enter parameters for each algorithm manually")
    choice = ui.ask_choice("Select a profile", {"1", "2", "3", "4"}, default="1")
    return {"1": "balanced", "2": "gentle", "3": "aggressive", "4": "custom"}[choice]


def custom_algorithm_parameters(
    ui: UI,
    selected_algorithms: list[str],
) -> dict[str, dict[str, Any]]:
    params = copy.deepcopy(PROFILE_DEFAULTS["balanced"])

    for key in selected_algorithms:
        ui.section(f"Custom settings: {ALGORITHMS[key].title}")

        if key == "wiener":
            params[key]["balance"] = ui.ask_float(
                "Balance; higher values mean stronger regularization",
                default=params[key]["balance"],
                minimum=1e-6,
                maximum=10.0,
                strictly_positive=True,
            )

        elif key == "richardson_lucy":
            params[key]["iterations"] = ui.ask_int(
                "Number of iterations",
                default=params[key]["iterations"],
                minimum=1,
                maximum=500,
            )
            params[key]["filter_epsilon"] = ui.ask_float(
                "Filter epsilon to prevent division by a very small number",
                default=params[key]["filter_epsilon"],
                minimum=1e-12,
                maximum=1e-2,
                strictly_positive=True,
            )

        elif key == "tikhonov":
            params[key]["regularization"] = ui.ask_float(
                "Laplacian regularization coefficient",
                default=params[key]["regularization"],
                minimum=1e-7,
                maximum=10.0,
                strictly_positive=True,
            )

        elif key == "tv_admm":
            params[key]["tv_weight"] = ui.ask_float(
                "TV weight; higher values mean stronger smoothing",
                default=params[key]["tv_weight"],
                minimum=1e-6,
                maximum=1.0,
                strictly_positive=True,
            )
            params[key]["rho"] = ui.ask_float(
                "ADMM rho parameter",
                default=params[key]["rho"],
                minimum=1e-4,
                maximum=100.0,
                strictly_positive=True,
            )
            params[key]["iterations"] = ui.ask_int(
                "Number of iterations",
                default=params[key]["iterations"],
                minimum=1,
                maximum=1000,
            )

        elif key == "unsupervised_wiener":
            params[key]["threshold"] = ui.ask_float(
                "Gibbs sampler stopping threshold",
                default=params[key]["threshold"],
                minimum=1e-8,
                maximum=1e-1,
                strictly_positive=True,
            )
            params[key]["burnin"] = ui.ask_int(
                "Burn-in samples",
                default=params[key]["burnin"],
                minimum=0,
                maximum=500,
            )
            params[key]["min_iterations"] = ui.ask_int(
                "Minimum iterations",
                default=params[key]["min_iterations"],
                minimum=1,
                maximum=1000,
            )
            while True:
                max_iterations = ui.ask_int(
                    "Maximum iterations",
                    default=params[key]["max_iterations"],
                    minimum=1,
                    maximum=3000,
                )
                if max_iterations >= params[key]["min_iterations"]:
                    params[key]["max_iterations"] = max_iterations
                    break
                ui.warning("Maximum iterations must not be less than minimum iterations.")

    return {key: params[key] for key in selected_algorithms}


def choose_algorithm_parameters(
    ui: UI,
    selected_algorithms: list[str],
    profile: str,
) -> dict[str, dict[str, Any]]:
    if profile == "custom":
        return custom_algorithm_parameters(ui, selected_algorithms)
    defaults = copy.deepcopy(PROFILE_DEFAULTS[profile])
    return {key: defaults[key] for key in selected_algorithms}


# ---------------------------------------------------------------------------
# Image I/O and numeric conversion
# ---------------------------------------------------------------------------

def read_exif_orientation(path: Path) -> int:
    try:
        with Image.open(path) as image:
            orientation = image.getexif().get(EXIF_ORIENTATION_TAG, 1)
            return int(orientation) if orientation is not None else 1
    except Exception:
        return 1


def apply_exif_orientation(image: "np.ndarray", orientation: int) -> "np.ndarray":
    if orientation == 2:
        image = np.fliplr(image)
    elif orientation == 3:
        image = np.rot90(image, 2)
    elif orientation == 4:
        image = np.flipud(image)
    elif orientation == 5:
        image = np.swapaxes(image, 0, 1)
    elif orientation == 6:
        image = np.rot90(image, 3)
    elif orientation == 7:
        image = np.flip(np.swapaxes(image, 0, 1), axis=(0, 1))
    elif orientation == 8:
        image = np.rot90(image, 1)
    return np.ascontiguousarray(image)


def read_image(path: Path) -> "np.ndarray":
    try:
        encoded = np.frombuffer(path.read_bytes(), dtype=np.uint8)
    except OSError as exc:
        raise OSError(f"Could not read file: {exc}") from exc

    image = cv2.imdecode(encoded, cv2.IMREAD_UNCHANGED)
    if image is None:
        raise ValueError("OpenCV could not decode the image.")

    orientation = read_exif_orientation(path)
    image = apply_exif_orientation(image, orientation)

    if image.ndim not in {2, 3}:
        raise ValueError(f"Unsupported number of image dimensions: shape={image.shape}")
    if image.ndim == 3 and image.shape[2] not in {1, 2, 3, 4}:
        raise ValueError(f"Unsupported number of channels: {image.shape[2]}")
    return image


def split_alpha(image: "np.ndarray") -> tuple["np.ndarray", "np.ndarray | None"]:
    if image.ndim == 2:
        return image, None
    channels = image.shape[2]
    if channels == 1:
        return image[:, :, 0], None
    if channels == 2:  # grayscale + alpha
        return image[:, :, 0], image[:, :, 1]
    if channels == 4:  # BGR + alpha
        return image[:, :, :3], image[:, :, 3]
    return image, None


def merge_alpha(content: "np.ndarray", alpha: "np.ndarray | None") -> "np.ndarray":
    if alpha is None:
        return content
    if content.ndim == 2:
        return np.dstack((content, alpha))
    return np.dstack((content, alpha))


def to_working_float(image: "np.ndarray") -> tuple["np.ndarray", ScaleInfo]:
    dtype = image.dtype

    if np.issubdtype(dtype, np.unsignedinteger):
        info = np.iinfo(dtype)
        scale = float(info.max)
        working = image.astype(np.float32) / scale
        return working, ScaleInfo(
            dtype_name=dtype.name,
            low=0.0,
            high=scale,
            is_integer=True,
            integer_min=0,
            integer_max=int(info.max),
        )

    if np.issubdtype(dtype, np.signedinteger):
        info = np.iinfo(dtype)
        low, high = float(info.min), float(info.max)
        working = (image.astype(np.float32) - low) / (high - low)
        return working, ScaleInfo(
            dtype_name=dtype.name,
            low=low,
            high=high,
            is_integer=True,
            integer_min=int(info.min),
            integer_max=int(info.max),
        )

    if np.issubdtype(dtype, np.floating):
        finite = image[np.isfinite(image)]
        if finite.size == 0:
            raise ValueError("Float image contains no finite values.")
        data_min = float(finite.min())
        data_max = float(finite.max())
        if 0.0 <= data_min and data_max <= 1.0:
            low, high = 0.0, 1.0
        elif data_max > data_min:
            low, high = data_min, data_max
        else:
            low, high = data_min, data_min + 1.0
        cleaned = np.nan_to_num(image, nan=low, posinf=high, neginf=low)
        working = (cleaned.astype(np.float32) - low) / (high - low)
        return working, ScaleInfo(
            dtype_name=dtype.name,
            low=low,
            high=high,
            is_integer=False,
        )

    raise ValueError(f"Unsupported dtype: {dtype}")


def from_working_float(image: "np.ndarray", scale: ScaleInfo) -> "np.ndarray":
    clipped = np.clip(image, 0.0, 1.0)
    dtype = np.dtype(scale.dtype_name)
    restored = scale.low + clipped * (scale.high - scale.low)

    if scale.is_integer:
        restored = np.rint(restored)
        assert scale.integer_min is not None and scale.integer_max is not None
        restored = np.clip(restored, scale.integer_min, scale.integer_max)
    return restored.astype(dtype)


def encode_extension(path: Path) -> str:
    suffix = path.suffix.lower()
    if suffix == ".jpeg":
        return ".jpg"
    if suffix == ".tif":
        return ".tiff"
    return suffix


def write_image_atomic(path: Path, image: "np.ndarray") -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    extension = encode_extension(path)

    params: list[int] = []
    if extension == ".jpg":
        params = [int(cv2.IMWRITE_JPEG_QUALITY), 95]
        if hasattr(cv2, "IMWRITE_JPEG_OPTIMIZE"):
            params.extend([int(cv2.IMWRITE_JPEG_OPTIMIZE), 1])
    elif extension == ".png":
        params = [int(cv2.IMWRITE_PNG_COMPRESSION), 3]
    elif extension == ".webp":
        params = [int(cv2.IMWRITE_WEBP_QUALITY), 95]

    ok, encoded = cv2.imencode(extension, np.ascontiguousarray(image), params)
    if not ok:
        raise OSError(f"OpenCV could not encode the image as {extension}.")

    temp_path = path.with_name(f".{path.name}.tmp-{os.getpid()}")
    try:
        with temp_path.open("wb") as handle:
            handle.write(encoded.tobytes())
            handle.flush()
            os.fsync(handle.fileno())
        os.replace(temp_path, path)
    finally:
        try:
            temp_path.unlink(missing_ok=True)
        except OSError:
            pass


# ---------------------------------------------------------------------------
# Deblurring implementations
# ---------------------------------------------------------------------------

def psf_to_otf(psf: "np.ndarray", shape: tuple[int, int]) -> "np.ndarray":
    """Convert a centered spatial PSF to an optical transfer function."""
    if psf.shape[0] > shape[0] or psf.shape[1] > shape[1]:
        raise ValueError(
            f"PSF with shape={psf.shape} is larger than the processing image with shape={shape}."
        )

    padded = np.zeros(shape, dtype=np.float32)
    kh, kw = psf.shape
    padded[:kh, :kw] = psf
    padded = np.roll(padded, shift=(-(kh // 2), -(kw // 2)), axis=(0, 1))
    return sp_fft.fft2(padded)


def deblur_wiener(
    channel: "np.ndarray",
    psf: "np.ndarray",
    params: dict[str, Any],
) -> "np.ndarray":
    result = wiener(
        channel,
        psf,
        balance=float(params["balance"]),
        clip=False,
    )
    return np.asarray(result, dtype=np.float32)


def deblur_richardson_lucy(
    channel: "np.ndarray",
    psf: "np.ndarray",
    params: dict[str, Any],
) -> "np.ndarray":
    kwargs: dict[str, Any] = {
        "num_iter": int(params["iterations"]),
        "clip": False,
    }
    if "filter_epsilon" in inspect.signature(richardson_lucy).parameters:
        kwargs["filter_epsilon"] = float(params["filter_epsilon"])

    # Richardson–Lucy assumes nonnegative intensities.
    result = richardson_lucy(np.clip(channel, 0.0, 1.0), psf, **kwargs)
    return np.asarray(result, dtype=np.float32)


def deblur_tikhonov(
    channel: "np.ndarray",
    psf: "np.ndarray",
    params: dict[str, Any],
) -> "np.ndarray":
    regularization = float(params["regularization"])
    shape = channel.shape
    transfer = psf_to_otf(psf, shape)

    laplacian = np.array(
        [[0.0, -1.0, 0.0], [-1.0, 4.0, -1.0], [0.0, -1.0, 0.0]],
        dtype=np.float32,
    )
    laplacian_transfer = psf_to_otf(laplacian, shape)
    observed = sp_fft.fft2(channel)

    denominator = (
        np.abs(transfer) ** 2
        + regularization * np.abs(laplacian_transfer) ** 2
        + EPSILON
    )
    estimate = sp_fft.ifft2(np.conj(transfer) * observed / denominator).real
    return np.asarray(estimate, dtype=np.float32)


def forward_gradient_x(image: "np.ndarray") -> "np.ndarray":
    return np.roll(image, -1, axis=1) - image


def forward_gradient_y(image: "np.ndarray") -> "np.ndarray":
    return np.roll(image, -1, axis=0) - image


def deblur_tv_admm(
    channel: "np.ndarray",
    psf: "np.ndarray",
    params: dict[str, Any],
) -> "np.ndarray":
    """Solve 0.5||H x-y||² + lambda*TV(x) with periodic-boundary ADMM."""
    tv_weight = float(params["tv_weight"])
    rho = float(params["rho"])
    iterations = int(params["iterations"])
    shape = channel.shape

    transfer = psf_to_otf(psf, shape)
    observed = sp_fft.fft2(channel)

    # Fourier symbols of forward periodic differences.
    fy = sp_fft.fftfreq(shape[0]).astype(np.float32)
    fx = sp_fft.fftfreq(shape[1]).astype(np.float32)
    dx_transfer = np.exp(2j * np.pi * fx)[None, :] - 1.0
    dy_transfer = np.exp(2j * np.pi * fy)[:, None] - 1.0

    denominator = (
        np.abs(transfer) ** 2
        + rho * (np.abs(dx_transfer) ** 2 + np.abs(dy_transfer) ** 2)
        + EPSILON
    )

    x = channel.astype(np.float32, copy=True)
    z_x = np.zeros_like(x)
    z_y = np.zeros_like(x)
    u_x = np.zeros_like(x)
    u_y = np.zeros_like(x)
    threshold = tv_weight / rho

    for _ in range(iterations):
        rhs = (
            np.conj(transfer) * observed
            + rho * np.conj(dx_transfer) * sp_fft.fft2(z_x - u_x)
            + rho * np.conj(dy_transfer) * sp_fft.fft2(z_y - u_y)
        )
        x = sp_fft.ifft2(rhs / denominator).real.astype(np.float32, copy=False)

        grad_x = forward_gradient_x(x)
        grad_y = forward_gradient_y(x)
        v_x = grad_x + u_x
        v_y = grad_y + u_y

        magnitude = np.sqrt(v_x * v_x + v_y * v_y)
        shrink = np.maximum(0.0, 1.0 - threshold / np.maximum(magnitude, EPSILON))
        z_x = shrink * v_x
        z_y = shrink * v_y

        u_x += grad_x - z_x
        u_y += grad_y - z_y

    return np.asarray(x, dtype=np.float32)


def deblur_unsupervised_wiener(
    channel: "np.ndarray",
    psf: "np.ndarray",
    params: dict[str, Any],
) -> "np.ndarray":
    user_params = {
        "threshold": float(params["threshold"]),
        "burnin": int(params["burnin"]),
        "min_num_iter": int(params["min_iterations"]),
        "max_num_iter": int(params["max_iterations"]),
    }
    kwargs: dict[str, Any] = {
        "user_params": user_params,
        "clip": False,
    }
    if "rng" in inspect.signature(unsupervised_wiener).parameters:
        kwargs["rng"] = 0  # Deterministic/reproducible batch output.

    result, _ = unsupervised_wiener(channel, psf, **kwargs)
    return np.asarray(result, dtype=np.float32)


DEBLUR_FUNCTIONS: Final[
    dict[str, Callable[["np.ndarray", "np.ndarray", dict[str, Any]], "np.ndarray"]]
] = {
    "wiener": deblur_wiener,
    "richardson_lucy": deblur_richardson_lucy,
    "tikhonov": deblur_tikhonov,
    "tv_admm": deblur_tv_admm,
    "unsupervised_wiener": deblur_unsupervised_wiener,
}


def padding_for_shape(
    image_shape: tuple[int, int],
    psf_shape: tuple[int, int],
) -> tuple[int, int]:
    height, width = image_shape
    desired_y = max(8, psf_shape[0] // 2 + 4)
    desired_x = max(8, psf_shape[1] // 2 + 4)
    pad_y = min(desired_y, max(0, height - 1))
    pad_x = min(desired_x, max(0, width - 1))
    return pad_y, pad_x


def deblur_single_channel(
    channel: "np.ndarray",
    psf: "np.ndarray",
    algorithm_key: str,
    params: dict[str, Any],
    *,
    edge_padding: bool,
) -> "np.ndarray":
    if channel.ndim != 2:
        raise ValueError("Each input channel must be two-dimensional.")
    if min(channel.shape) < 2:
        raise ValueError("Image width and height must be at least 2 pixels.")

    pad_y, pad_x = (0, 0)
    working = channel
    if edge_padding:
        pad_y, pad_x = padding_for_shape(channel.shape, psf.shape)
        if pad_y or pad_x:
            working = np.pad(
                channel,
                ((pad_y, pad_y), (pad_x, pad_x)),
                mode="reflect",
            )

    if psf.shape[0] > working.shape[0] or psf.shape[1] > working.shape[1]:
        raise ValueError(
            "Blur kernel is too large relative to the image; reduce the PSF size."
        )

    function = DEBLUR_FUNCTIONS[algorithm_key]
    restored = function(working, psf, params)

    if restored.shape != working.shape:
        raise RuntimeError(
            f"Algorithm changed the output shape: {working.shape} -> {restored.shape}"
        )
    if not np.all(np.isfinite(restored)):
        raise FloatingPointError("Algorithm output contains NaN or Infinity.")

    if pad_y or pad_x:
        restored = restored[
            pad_y : pad_y + channel.shape[0],
            pad_x : pad_x + channel.shape[1],
        ]
    return np.clip(restored, 0.0, 1.0).astype(np.float32, copy=False)


def deblur_image(
    image: "np.ndarray",
    psf: "np.ndarray",
    algorithm_key: str,
    params: dict[str, Any],
    *,
    edge_padding: bool,
) -> "np.ndarray":
    content, alpha = split_alpha(image)
    working, scale = to_working_float(content)

    if working.ndim == 2:
        restored_float = deblur_single_channel(
            working,
            psf,
            algorithm_key,
            params,
            edge_padding=edge_padding,
        )
    else:
        restored_float = np.empty_like(working, dtype=np.float32)
        for channel_index in range(working.shape[2]):
            restored_float[:, :, channel_index] = deblur_single_channel(
                working[:, :, channel_index],
                psf,
                algorithm_key,
                params,
                edge_padding=edge_padding,
            )

    restored_content = from_working_float(restored_float, scale)
    return merge_alpha(restored_content, alpha)


# ---------------------------------------------------------------------------
# Batch processing and reporting
# ---------------------------------------------------------------------------

def discover_images(
    input_dir: Path,
    recursive: bool,
    *,
    exclude_dir: Path | None = None,
) -> list[Path]:
    iterator = input_dir.rglob("*") if recursive else input_dir.glob("*")
    files: list[Path] = []
    for path in iterator:
        if not path.is_file() or path.suffix.lower() not in SUPPORTED_EXTENSIONS:
            continue
        if exclude_dir is not None and (path == exclude_dir or exclude_dir in path.parents):
            continue
        files.append(path)
    return sorted(files, key=lambda path: str(path.relative_to(input_dir)).casefold())


def truncate_filename_stem(stem: str, tag: str, max_chars: int = 180) -> str:
    required = len(tag) + 2
    available = max(24, max_chars - required)
    if len(stem) <= available:
        return stem
    digest = hashlib.sha1(stem.encode("utf-8", errors="replace")).hexdigest()[:8]
    return f"{stem[: max(8, available - 10)]}~{digest}"


def output_path_for(
    input_path: Path,
    input_dir: Path,
    output_dir: Path,
    algorithm_key: str,
    psf: PSFConfig,
    profile: str,
) -> Path:
    relative = input_path.relative_to(input_dir)
    info = ALGORITHMS[algorithm_key]
    profile_tag = profile if profile != "custom" else "custom"
    result_tag = f"deblurred-{info.slug}-{psf.file_tag}-{profile_tag}"
    safe_stem = truncate_filename_stem(relative.stem, result_tag)
    output_name = f"{safe_stem}__{result_tag}{relative.suffix.lower()}"
    return output_dir / info.slug / relative.parent / output_name


def human_duration(seconds: float) -> str:
    if seconds < 1:
        return f"{seconds * 1000:.0f} ms"
    if seconds < 60:
        return f"{seconds:.1f} s"
    minutes, remaining = divmod(seconds, 60)
    return f"{int(minutes)}m {remaining:.0f}s"


def make_report_base(
    *,
    input_dir: Path,
    output_dir: Path,
    selected_algorithms: list[str],
    algorithm_params: dict[str, dict[str, Any]],
    psf: PSFConfig,
    profile: str,
    recursive: bool,
    overwrite: bool,
    edge_padding: bool,
) -> dict[str, Any]:
    return {
        "application": {"name": APP_NAME, "version": APP_VERSION},
        "started_at": datetime.now().astimezone().isoformat(),
        "environment": {
            "python": platform.python_version(),
            "platform": platform.platform(),
            "numpy": np.__version__,
            "scipy": scipy.__version__,
            "opencv": cv2.__version__,
            "scikit_image": skimage_version,
        },
        "settings": {
            "input_dir": str(input_dir),
            "output_dir": str(output_dir),
            "recursive": recursive,
            "overwrite": overwrite,
            "edge_padding": edge_padding,
            "profile": profile,
            "profile_label": PROFILE_LABELS[profile],
            "algorithms": selected_algorithms,
            "algorithm_parameters": algorithm_params,
            "psf": psf.report_data(),
        },
        "summary": {},
        "results": [],
    }


def write_json_atomic(path: Path, payload: dict[str, Any]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    temp_path = path.with_name(f".{path.name}.tmp-{os.getpid()}")
    try:
        with temp_path.open("w", encoding="utf-8", newline="\n") as handle:
            json.dump(payload, handle, ensure_ascii=False, indent=2)
            handle.write("\n")
            handle.flush()
            os.fsync(handle.fileno())
        os.replace(temp_path, path)
    finally:
        try:
            temp_path.unlink(missing_ok=True)
        except OSError:
            pass


def process_batch(
    ui: UI,
    images: list[Path],
    *,
    input_dir: Path,
    output_dir: Path,
    selected_algorithms: list[str],
    algorithm_params: dict[str, dict[str, Any]],
    psf: PSFConfig,
    profile: str,
    recursive: bool,
    overwrite: bool,
    edge_padding: bool,
) -> tuple[dict[str, int], Path]:
    report = make_report_base(
        input_dir=input_dir,
        output_dir=output_dir,
        selected_algorithms=selected_algorithms,
        algorithm_params=algorithm_params,
        psf=psf,
        profile=profile,
        recursive=recursive,
        overwrite=overwrite,
        edge_padding=edge_padding,
    )

    run_stamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
    report_path = output_dir / f"deblur-report-{run_stamp}.json"
    counter = {"success": 0, "skipped": 0, "failed": 0}
    total_jobs = len(images) * len(selected_algorithms)
    job_index = 0
    batch_started = time.perf_counter()

    ui.section("Processing")

    try:
        for image_index, input_path in enumerate(images, start=1):
            relative_label = str(input_path.relative_to(input_dir))
            try:
                source_image = read_image(input_path)
            except Exception as exc:
                # A read failure affects every selected algorithm for this image.
                error_text = f"{type(exc).__name__}: {exc}"
                ui.error(f"[{image_index}/{len(images)}] {relative_label} — read error: {error_text}")
                for algorithm_key in selected_algorithms:
                    job_index += 1
                    counter["failed"] += 1
                    report["results"].append(
                        {
                            "input": str(input_path),
                            "algorithm": algorithm_key,
                            "status": "failed",
                            "stage": "read",
                            "error": error_text,
                        }
                    )
                continue

            for algorithm_key in selected_algorithms:
                job_index += 1
                output_path = output_path_for(
                    input_path,
                    input_dir,
                    output_dir,
                    algorithm_key,
                    psf,
                    profile,
                )
                algorithm_title = ALGORITHMS[algorithm_key].title
                prefix = f"[{job_index}/{total_jobs}] {relative_label} → {algorithm_title}"

                if output_path.exists() and not overwrite:
                    counter["skipped"] += 1
                    ui.warning(f"{prefix} — skipped; output already exists.")
                    report["results"].append(
                        {
                            "input": str(input_path),
                            "output": str(output_path),
                            "algorithm": algorithm_key,
                            "status": "skipped",
                            "reason": "output_exists",
                        }
                    )
                    continue

                started = time.perf_counter()
                try:
                    restored = deblur_image(
                        source_image,
                        psf.kernel,
                        algorithm_key,
                        algorithm_params[algorithm_key],
                        edge_padding=edge_padding,
                    )
                    write_image_atomic(output_path, restored)
                    elapsed = time.perf_counter() - started
                    counter["success"] += 1
                    ui.success(f"{prefix} — {human_duration(elapsed)}")
                    report["results"].append(
                        {
                            "input": str(input_path),
                            "output": str(output_path),
                            "algorithm": algorithm_key,
                            "status": "success",
                            "duration_seconds": round(elapsed, 6),
                            "source_shape": list(source_image.shape),
                            "source_dtype": str(source_image.dtype),
                        }
                    )
                except Exception as exc:
                    elapsed = time.perf_counter() - started
                    counter["failed"] += 1
                    error_text = f"{type(exc).__name__}: {exc}"
                    ui.error(f"{prefix} — {error_text}")
                    report["results"].append(
                        {
                            "input": str(input_path),
                            "output": str(output_path),
                            "algorithm": algorithm_key,
                            "status": "failed",
                            "stage": "process_or_write",
                            "duration_seconds": round(elapsed, 6),
                            "error": error_text,
                            "traceback": traceback.format_exc(limit=8),
                        }
                    )
    except KeyboardInterrupt:
        report["interrupted"] = True
        ui.warning("Processing stopped with Ctrl+C; the report for completed results will be saved.")
    finally:
        total_elapsed = time.perf_counter() - batch_started
        report["finished_at"] = datetime.now().astimezone().isoformat()
        report["summary"] = {
            **counter,
            "total_jobs": total_jobs,
            "completed_jobs": sum(counter.values()),
            "duration_seconds": round(total_elapsed, 6),
        }
        write_json_atomic(report_path, report)

    return counter, report_path


# ---------------------------------------------------------------------------
# Main application flow
# ---------------------------------------------------------------------------

def build_argument_parser(script_dir: Path) -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="Batch deblurring with an interactive menu",
    )
    parser.add_argument(
        "--input-dir",
        type=Path,
        default=script_dir / "input-images",
        help="Input image folder; default: input-images next to the program file",
    )
    parser.add_argument(
        "--output-dir",
        type=Path,
        default=script_dir / "output-images",
        help="Output folder; default: output-images next to the program file",
    )
    parser.add_argument(
        "--no-color",
        action="store_true",
        help="Disable ANSI colors in the terminal",
    )
    return parser


def normalize_directory(path: Path) -> Path:
    path = path.expanduser()
    if not path.is_absolute():
        path = Path.cwd() / path
    return path.resolve()


def print_run_summary(
    ui: UI,
    *,
    input_dir: Path,
    output_dir: Path,
    images: list[Path],
    selected_algorithms: list[str],
    psf: PSFConfig,
    profile: str,
    recursive: bool,
    overwrite: bool,
    edge_padding: bool,
) -> None:
    ui.section("Run Summary")
    print(f"  Input folder        : {input_dir}")
    print(f"  Number of images    : {len(images)}")
    print(f"  Search subfolders   : {'Yes' if recursive else 'No'}")
    print(f"  Algorithms          : {', '.join(ALGORITHMS[k].title for k in selected_algorithms)}")
    print(f"  PSF                 : {psf.label}")
    print(f"  Profile             : {PROFILE_LABELS[profile]}")
    print(f"  Edge padding        : {'Enabled' if edge_padding else 'Disabled'}")
    print(f"  Overwrite output    : {'Yes' if overwrite else 'No; existing file will be skipped'}")
    print(f"  Output folder       : {output_dir}")
    print(f"  Number of jobs      : {len(images) * len(selected_algorithms)}")


def main(argv: list[str] | None = None) -> int:
    if _DEPENDENCY_ERROR is not None:
        print("One of the required libraries is not installed.", file=sys.stderr)
        print(f"Error: {_DEPENDENCY_ERROR}", file=sys.stderr)
        print(
            "Install dependencies:\n"
            "  python -m pip install --upgrade numpy scipy opencv-python scikit-image pillow",
            file=sys.stderr,
        )
        return 3

    script_dir = Path(__file__).resolve().parent
    parser = build_argument_parser(script_dir)
    args = parser.parse_args(argv)
    ui = UI(use_color=not args.no_color)

    input_dir = normalize_directory(args.input_dir)
    output_dir = normalize_directory(args.output_dir)

    ui.header()
    ui.info(f"Input: {input_dir}")
    ui.info(f"Output: {output_dir}")

    if not input_dir.exists():
        try:
            input_dir.mkdir(parents=True, exist_ok=True)
        except OSError as exc:
            ui.error(f"Could not create the input folder: {exc}")
            return 2
        ui.warning("The input folder was created, but it does not contain any images yet.")
        ui.info("Place images in the folder and run the program again.")
        return 2

    if not input_dir.is_dir():
        ui.error("The input path is not a directory.")
        return 2

    try:
        selected_algorithms = choose_algorithms(ui)
        if not selected_algorithms:
            ui.info("Program exited without processing.")
            return 0

        psf = choose_psf(ui, script_dir)
        profile = choose_profile(ui)
        algorithm_params = choose_algorithm_parameters(ui, selected_algorithms, profile)

        ui.section("Batch Settings")
        recursive = ui.ask_yes_no("Process images in subfolders too?", default=True)
        overwrite = ui.ask_yes_no("Overwrite existing output files with the same name?", default=False)
        edge_padding = ui.ask_yes_no(
            "Use reflect padding to reduce edge artifacts?",
            default=True,
        )

        if output_dir == input_dir:
            ui.error("The output folder cannot be exactly the same as the input folder.")
            return 2

        excluded_output = output_dir if input_dir in output_dir.parents else None
        if excluded_output is not None and recursive:
            ui.warning(
                "The output folder is inside the input folder; to prevent reprocessing, "
                "output contents will be excluded from the search."
            )

        images = discover_images(
            input_dir,
            recursive,
            exclude_dir=excluded_output,
        )
        if not images:
            extensions = ", ".join(sorted(SUPPORTED_EXTENSIONS))
            ui.warning("No supported images were found in the input folder.")
            ui.info(f"Accepted extensions: {extensions}")
            return 2

        output_dir.mkdir(parents=True, exist_ok=True)
        print_run_summary(
            ui,
            input_dir=input_dir,
            output_dir=output_dir,
            images=images,
            selected_algorithms=selected_algorithms,
            psf=psf,
            profile=profile,
            recursive=recursive,
            overwrite=overwrite,
            edge_padding=edge_padding,
        )

        if not ui.ask_yes_no("Start processing?", default=True):
            ui.info("Processing canceled.")
            return 0

        counters, report_path = process_batch(
            ui,
            images,
            input_dir=input_dir,
            output_dir=output_dir,
            selected_algorithms=selected_algorithms,
            algorithm_params=algorithm_params,
            psf=psf,
            profile=profile,
            recursive=recursive,
            overwrite=overwrite,
            edge_padding=edge_padding,
        )

        ui.section("Result")
        ui.success(f"Successful: {counters['success']}")
        if counters["skipped"]:
            ui.warning(f"Skipped: {counters['skipped']}")
        if counters["failed"]:
            ui.error(f"Failed: {counters['failed']}")
        ui.info(f"JSON report: {report_path}")
        ui.info(f"Image output: {output_dir}")

        return 1 if counters["failed"] else 0

    except KeyboardInterrupt:
        print()
        ui.warning("Operation stopped by the user.")
        return 130
    except OSError as exc:
        ui.error(f"File system error: {exc}")
        return 2


if __name__ == "__main__":
    raise SystemExit(main())