Refactor HVideoTool to exclusively use YOLO for detection and DeepMosaics for restoration: removed classic CV and composite detectors, updated configuration and UI accordingly. Enhanced documentation in README and CLAUDE.md to reflect these changes, including new batch processing capabilities and device diagnostics.

hvideotool/core/detection/classic_cv.py

@@ -1,216 +0,0 @@
-"""Weights-free, heuristic censorship detector (classic computer vision).
-
-APPROXIMATE BY DESIGN. This detector uses hand-tuned CV heuristics, not a
-trained model. Its purpose is to make the whole pipeline runnable end-to-end
-and to exercise the :class:`Detector` interface. For real-world accuracy,
-replace it with a trained model (see ``yolo.py``, to be implemented) — the rest
-of the app does not need to change.
-
-Heuristics:
-- black_bar: large, near-uniform very dark regions (classic censor bars).
-- mosaic:    regions that reconstruct well from a coarse block grid (low
-             residual) yet have high coarse-scale contrast (i.e. blocky, not flat).
-- blur:      regions with local high-frequency energy far below the frame median,
-             while still being textured (excludes genuinely flat areas).
-"""
-
-from __future__ import annotations
-
-import cv2
-import numpy as np
-
-from ...config import DetectionConfig
-from ..video.frame import Frame
-from .base import Detector
-from .types import CensorType, Detection
-
-
-class ClassicCVDetector(Detector):
-    def __init__(
-        self,
-        config: DetectionConfig | None = None,
-        types: "set[CensorType] | None" = None,
-    ) -> None:
-        self.cfg = config or DetectionConfig()
-        # Which censorship kinds to look for. Default: all. The composite detector
-        # restricts this to black_bar/blur (mosaic comes from the YOLO model).
-        self.types = (
-            types if types is not None
-            else {CensorType.MOSAIC, CensorType.BLUR, CensorType.BLACK_BAR}
-        )
-
-    # ------------------------------------------------------------------ public
-    def detect(self, frame: Frame) -> list[Detection]:
-        bgr = frame.image
-        h0, w0 = bgr.shape[:2]
-        scale = self._proc_scale(w0, h0)
-        proc = (
-            cv2.resize(bgr, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA)
-            if scale != 1.0
-            else bgr
-        )
-        gray = cv2.cvtColor(proc, cv2.COLOR_BGR2GRAY)
-        ph, pw = gray.shape
-        min_area = self.cfg.min_area_frac * pw * ph
-
-        dets: list[Detection] = []
-        for ctype, fn, factor in (
-            (CensorType.BLACK_BAR, self._detect_bars, 1.0),
-            (CensorType.MOSAIC, self._detect_mosaic, 4.0),
-            (CensorType.BLUR, self._detect_blur, 6.0),
-        ):
-            if ctype not in self.types:
-                continue
-            try:
-                dets += fn(proc, gray, min_area * factor)
-            except Exception:
-                # A failing heuristic must not break playback; skip it for this frame.
-                continue
-
-        # Map proc-space coordinates back to source-frame pixels.
-        inv = 1.0 / scale
-        for d in dets:
-            x, y, w, h = d.bbox
-            d.bbox = (round(x * inv), round(y * inv), round(w * inv), round(h * inv))
-            d.polygon = [(round(px * inv), round(py * inv)) for px, py in d.polygon]
-        return self._dedup(dets)
-
-    # ----------------------------------------------------------------- helpers
-    def _proc_scale(self, w: int, h: int) -> float:
-        longest = max(w, h)
-        if longest <= self.cfg.proc_max_dim:
-            return 1.0
-        return self.cfg.proc_max_dim / longest
-
-    @staticmethod
-    def _local_std(g: np.ndarray, win: int) -> np.ndarray:
-        """Per-pixel standard deviation over a (win x win) box window."""
-        mean = cv2.boxFilter(g, -1, (win, win))
-        sqmean = cv2.boxFilter(g * g, -1, (win, win))
-        var = np.maximum(sqmean - mean * mean, 0.0)
-        return np.sqrt(var)
-
-    def _mask_to_detections(
-        self,
-        mask: np.ndarray,
-        ctype: CensorType,
-        min_area: float,
-        base_score: float,
-        min_extent: float = 0.0,
-        min_side: int = 0,
-    ) -> list[Detection]:
-        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8))
-        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, np.ones((9, 9), np.uint8))
-        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-
-        out: list[Detection] = []
-        for c in contours:
-            area = cv2.contourArea(c)
-            if area < min_area:
-                continue
-            x, y, w, h = cv2.boundingRect(c)
-            if min(w, h) < min_side:
-                continue  # reject thin strips (e.g. edge false-positives)
-            extent = area / float(w * h + 1e-6)  # how rectangular the blob is
-            if extent < min_extent:
-                continue
-            approx = cv2.approxPolyDP(c, 0.01 * cv2.arcLength(c, True), True)
-            poly = [(int(p[0][0]), int(p[0][1])) for p in approx]
-            score = float(np.clip(base_score + 0.25 * extent, 0.0, 1.0))
-            out.append(Detection(type=ctype, score=score, bbox=(x, y, w, h), polygon=poly))
-        return out
-
-    # --------------------------------------------------------------- detectors
-    def _detect_bars(self, bgr, gray, min_area) -> list[Detection]:
-        # Solid censor bars are achromatic (black OR white) rectangles. Requiring
-        # low saturation + high rectangularity excludes large flat *colored* fills
-        # that are common in drawn/anime backgrounds.
-        hsv = cv2.cvtColor(bgr, cv2.COLOR_BGR2HSV)
-        sat, val = hsv[:, :, 1], hsv[:, :, 2]
-        achromatic = sat < self.cfg.bar_saturation_max
-        dark = (val < self.cfg.black_intensity) & achromatic
-        light = (val > self.cfg.white_intensity) & achromatic
-        mask = (dark | light).astype(np.uint8) * 255
-        return self._mask_to_detections(
-            mask, CensorType.BLACK_BAR, min_area, base_score=0.55,
-            min_extent=self.cfg.bar_min_extent,
-        )
-
-    def _detect_mosaic(self, bgr, gray, min_area) -> list[Detection]:
-        g = gray.astype(np.float32)
-        h, w = gray.shape
-        win = 17
-        # Lowest reconstruction residual across candidate tile sizes AND grid phases.
-        # Real mosaics aren't aligned to the origin, so we try a few offsets per size
-        # (phase-invariant) and keep the best fit.
-        best_residual = np.full((h, w), np.inf, np.float32)
-        for b in self.cfg.mosaic_block_sizes:
-            half = b // 2
-            for oy, ox in ((0, 0), (half, 0), (0, half), (half, half)):
-                sub = g[oy:, ox:]
-                sh, sw = sub.shape
-                if sh < b or sw < b:
-                    continue
-                small = cv2.resize(sub, (max(1, sw // b), max(1, sh // b)), interpolation=cv2.INTER_AREA)
-                restored = cv2.resize(small, (sw, sh), interpolation=cv2.INTER_NEAREST)
-                region = best_residual[oy:oy + sh, ox:ox + sw]
-                np.minimum(region, np.abs(sub - restored), out=region)
-        best_residual = cv2.boxFilter(best_residual, -1, (win, win))
-
-        contrast = self._local_std(g, win)
-        # Mosaic has edges in BOTH directions; a lone straight boundary (flat-region
-        # border, bar edge) has edge energy in only one — exclude those.
-        gx = cv2.boxFilter(np.abs(cv2.Sobel(g, cv2.CV_32F, 1, 0, ksize=3)), -1, (win, win))
-        gy = cv2.boxFilter(np.abs(cv2.Sobel(g, cv2.CV_32F, 0, 1, ksize=3)), -1, (win, win))
-        both_dirs = (gx > self.cfg.mosaic_grad_min) & (gy > self.cfg.mosaic_grad_min)
-
-        blocky = best_residual < self.cfg.mosaic_residual_max
-        textured = contrast > self.cfg.mosaic_contrast_min
-        mask = (blocky & textured & both_dirs).astype(np.uint8) * 255
-        return self._mask_to_detections(
-            mask, CensorType.MOSAIC, min_area, base_score=0.50, min_side=self.cfg.mosaic_min_side
-        )
-
-    def _detect_blur(self, bgr, gray, min_area) -> list[Detection]:
-        g = gray.astype(np.float32)
-        win = self.cfg.blur_window | 1  # force odd
-        lap = cv2.Laplacian(g, cv2.CV_32F, ksize=3)
-        sharpness = cv2.boxFilter(lap * lap, -1, (win, win))  # local high-freq energy
-        median = float(np.median(sharpness)) + 1e-6
-        contrast = self._local_std(g, win)
-
-        blurry = sharpness < median * self.cfg.blur_sharpness_ratio
-        textured = contrast > self.cfg.blur_contrast_min
-        mask = (blurry & textured).astype(np.uint8) * 255
-        return self._mask_to_detections(
-            mask, CensorType.BLUR, min_area, base_score=0.40, min_side=self.cfg.mosaic_min_side
-        )
-
-    # ----------------------------------------------------------------- dedup
-    def _dedup(self, dets: list[Detection]) -> list[Detection]:
-        """Greedy IoU suppression; prefer black_bar > mosaic > blur, then score."""
-        priority = {
-            CensorType.BLACK_BAR: 3,
-            CensorType.MOSAIC: 2,
-            CensorType.BLUR: 1,
-            CensorType.UNKNOWN: 0,
-        }
-        dets = sorted(dets, key=lambda d: (priority[d.type], d.score), reverse=True)
-        kept: list[Detection] = []
-        for d in dets:
-            if all(self._iou(d.bbox, k.bbox) < 0.5 for k in kept):
-                kept.append(d)
-        return kept
-
-    @staticmethod
-    def _iou(a: tuple[int, int, int, int], b: tuple[int, int, int, int]) -> float:
-        ax, ay, aw, ah = a
-        bx, by, bw, bh = b
-        ix = max(ax, bx)
-        iy = max(ay, by)
-        ix2 = min(ax + aw, bx + bw)
-        iy2 = min(ay + ah, by + bh)
-        iw, ih = max(0, ix2 - ix), max(0, iy2 - iy)
-        inter = iw * ih
-        union = aw * ah + bw * bh - inter
-        return inter / union if union > 0 else 0.0

hvideotool/core/detection/composite.py

@@ -1,51 +0,0 @@
-"""Composite detector: runs several detectors and merges their results.
-
-Used for the "combined" mode = YOLO (mosaic) + classic-CV (black bars / blur).
-Detections from all sub-detectors are concatenated, then de-duplicated by IoU
-(higher score wins) so overlapping hits from different detectors don't stack.
-"""
-
-from __future__ import annotations
-
-from ..video.frame import Frame
-from .base import Detector
-from .types import Detection
-
-
-class CompositeDetector(Detector):
-    def __init__(self, detectors: list[Detector], iou_threshold: float = 0.6) -> None:
-        if not detectors:
-            raise ValueError("CompositeDetector requires at least one detector")
-        self._detectors = detectors
-        self._iou = iou_threshold
-
-    @property
-    def name(self) -> str:
-        return "Composite(" + " + ".join(d.name for d in self._detectors) + ")"
-
-    def detect(self, frame: Frame) -> list[Detection]:
-        merged: list[Detection] = []
-        for detector in self._detectors:
-            try:
-                merged += detector.detect(frame)
-            except Exception:  # noqa: BLE001 - one detector failing must not kill the frame
-                continue
-        return self._dedup(merged)
-
-    def _dedup(self, dets: list[Detection]) -> list[Detection]:
-        dets = sorted(dets, key=lambda d: d.score, reverse=True)
-        kept: list[Detection] = []
-        for d in dets:
-            if all(self._iou_of(d.bbox, k.bbox) < self._iou for k in kept):
-                kept.append(d)
-        return kept
-
-    @staticmethod
-    def _iou_of(a: tuple[int, int, int, int], b: tuple[int, int, int, int]) -> float:
-        ax, ay, aw, ah = a
-        bx, by, bw, bh = b
-        ix, iy = max(ax, bx), max(ay, by)
-        ix2, iy2 = min(ax + aw, bx + bw), min(ay + ah, by + bh)
-        inter = max(0, ix2 - ix) * max(0, iy2 - iy)
-        union = aw * ah + bw * bh - inter
-        return inter / union if union > 0 else 0.0

hvideotool/core/detection/factory.py

@@ -3,14 +3,15 @@
 Kept separate from ``app.py`` so both the app bootstrap and the UI can build
 detectors without an import cycle. Raises ``ValueError`` (not ``SystemExit``) on
 bad config so the GUI can show the message instead of exiting.
+
+Only the YOLO detector is supported — the classic-CV heuristic (and the composite
+mode that combined them) were removed: they were noisy/approximate on real footage.
 """
 
 from __future__ import annotations
 
 from ...config import AppConfig
 from .base import Detector
-from .classic_cv import ClassicCVDetector
-from .types import CensorType
 
 
 def _require_model(config: AppConfig) -> str:
@@ -23,19 +24,6 @@ def _require_model(config: AppConfig) -> str:
 
 
 def build_detector(config: AppConfig) -> Detector:
-    if config.detector == "classic":
-        return ClassicCVDetector(config.detection)
-    if config.detector == "yolo":
-        from .yolo import YoloDetector  # lazy: pulls torch/ultralytics
+    from .yolo import YoloDetector  # lazy: pulls torch/ultralytics
 
-        return YoloDetector(_require_model(config), config.detection)
-    if config.detector == "combined":
-        # YOLO handles mosaic; classic-CV handles black bars / blur.
-        from .composite import CompositeDetector
-        from .yolo import YoloDetector
-
-        return CompositeDetector([
-            YoloDetector(_require_model(config), config.detection),
-            ClassicCVDetector(config.detection, types={CensorType.BLACK_BAR, CensorType.BLUR}),
-        ])
-    raise ValueError(f"Неизвестный детектор: {config.detector!r}")
+    return YoloDetector(_require_model(config), config.detection)

hvideotool/core/detection/yolo.py

@@ -7,7 +7,7 @@ a single ``mosaic`` class — but it works with any Ultralytics ``.pt`` whose cl
 names map onto :class:`CensorType`.
 
 Heavy imports (``ultralytics``/``torch``) happen lazily in ``__init__`` so the
-rest of the app — and the classic-CV detector — never pull them in.
+rest of the app never pulls them in until detection actually runs.
 
 Licensing: Ultralytics YOLO and the LADA weights are AGPL-3.0. See README.
 """

hvideotool/core/project.py

@@ -30,6 +30,7 @@ FRAMES_DIR = "frames"
 CACHE_FILE = "detections.json"
 COLLECTIONS_DIR = "collections"
 FAVORITES_DIR = "Избранное"  # the single default collection ("в избранное")
+RESTORED_DIR = "restored"    # batch "расцензурить все" output (kept out of frames/)
 _VERSION = 1
 
 # The subset of AppConfig fields a project remembers (mirrored to/from project.json).
@@ -78,6 +79,12 @@ class Project:
         """The single default collection — frames moved "to favorites" land here."""
         return self.collections_dir / FAVORITES_DIR
 
+    @property
+    def restored_dir(self) -> Path:
+        """Batch restoration output ("расцензурить все") — mirrors frame basenames.
+        Kept out of ``frames/`` so results aren't listed/re-detected/re-restored."""
+        return self.root / RESTORED_DIR
+
     # ------------------------------------------------------------- lifecycle
     @classmethod
     def create(

hvideotool/core/restore/base.py

@@ -1,9 +1,10 @@
 """Restorer interface — "un-censor" detected regions of an image.
 
 A Restorer takes an image plus the detected censored regions and returns a new
-image with those regions reconstructed/filled. This mirrors the ``Detector``
-abstraction so different engines (classic inpaint now; a generative model like
-DeepMosaics / LADA later) plug in behind the same interface.
+image with those regions reconstructed. This mirrors the ``Detector`` abstraction
+so different DeepMosaics engines (per-frame and temporal/BVDNet; LADA later) plug
+in behind the same interface. Note DeepMosaics locates the mosaic itself, so the
+``detections`` argument is currently advisory (unused by the DeepMosaics engines).
 """
 
 from __future__ import annotations
@@ -24,7 +25,18 @@ class Cancelled(Exception):
     """Raised by a Restorer when ``should_cancel`` asked it to stop."""
 
 
+# Sequence (batch) restore callbacks — see ``Restorer.restore_sequence``.
+FrameGetter = Callable[[int], np.ndarray]            # index -> BGR image
+DetGetter = Callable[[int], list[Detection]]         # index -> that frame's detections
+ResultSink = Callable[[int, np.ndarray], None]       # (index, restored image) -> None
+
+
 class Restorer(ABC):
+    #: Whether this engine uses *neighbouring* frames (so a batch run must feed it a
+    #: contiguous, ordered sequence — see :meth:`restore_sequence`). Per-frame engines
+    #: leave this False; the temporal DeepMosaics (BVDNet) sets it True.
+    temporal: bool = False
+
     @property
     def name(self) -> str:
         return type(self).__name__
@@ -42,3 +54,24 @@ class Restorer(ABC):
         True the engine should abort and raise :class:`Cancelled`.
         """
         raise NotImplementedError
+
+    def restore_sequence(
+        self,
+        count: int,
+        get_frame: FrameGetter,
+        get_dets: DetGetter,
+        emit: ResultSink,
+        should_cancel: CancelCheck | None = None,
+    ) -> None:
+        """Restore ``count`` frames *in order*, calling ``emit(i, restored)`` for each.
+
+        The default treats every frame independently (just loops :meth:`restore`).
+        Temporal engines override this to pull neighbouring frames via ``get_frame``
+        and carry recurrent state across the sequence. ``get_frame``/``get_dets`` are
+        lazy so the engine only reads the frames it needs; ``emit`` lets the caller
+        stream results to disk instead of holding them all in memory.
+        """
+        for i in range(count):
+            if should_cancel is not None and should_cancel():
+                raise Cancelled("Восстановление отменено")
+            emit(i, self.restore(get_frame(i), get_dets(i), should_cancel))

hvideotool/core/restore/deepmosaics.py

@@ -26,18 +26,29 @@ from types import SimpleNamespace
 import numpy as np
 
 from ..detection.types import Detection
-from .base import CancelCheck, Cancelled, Restorer
+from .base import (
+    CancelCheck,
+    Cancelled,
+    DetGetter,
+    FrameGetter,
+    ResultSink,
+    Restorer,
+)
 
 _VENDOR = Path(__file__).parent / "_deepmosaics"
 # Default place to drop DeepMosaics clean weights (gitignored — see models/).
 DEFAULT_WEIGHTS_DIR = Path(__file__).resolve().parents[3] / "models" / "deepmosaics"
 
 
-def discover_models(extra_dir: str | None = None) -> list[tuple[str, str]]:
-    """Find usable per-frame clean models: (display_name, full_path).
+def discover_models(
+    extra_dir: str | None = None, include_video: bool = False
+) -> list[tuple[str, str]]:
+    """Find usable clean models: (display_name, full_path).
 
     Scans the bundled ``models/deepmosaics`` folder (plus ``extra_dir`` if given)
-    for ``clean_*.pth``. The video model is skipped — it can't run per-frame.
+    for ``clean_*.pth``. By default the video model is skipped — it can't run
+    per-frame; pass ``include_video=True`` for the temporal (BVDNet) engine, which
+    *needs* ``clean_*_video.pth``.
     """
     dirs = [DEFAULT_WEIGHTS_DIR]
     if extra_dir:
@@ -48,13 +59,23 @@ def discover_models(extra_dir: str | None = None) -> list[tuple[str, str]]:
         if not d.is_dir():
             continue
         for p in sorted(d.glob("clean_*.pth")):
-            if "video" in p.name.lower() or p.name in seen:
+            if p.name in seen:
+                continue
+            if "video" in p.name.lower() and not include_video:
                 continue
             seen.add(p.name)
             out.append((p.stem, str(p)))
     return out
 
 
+def _find_mosaic_position(model: Path, dm_dir: str | None) -> Path | None:
+    """Locate ``mosaic_position.pth`` (the BiSeNet mosaic locator) for ``model``."""
+    candidates = [model.parent / "mosaic_position.pth"]
+    if dm_dir:
+        candidates.append(Path(dm_dir) / "pretrained_models" / "mosaic" / "mosaic_position.pth")
+    return next((p for p in candidates if p.is_file()), None)
+
+
 def _netg_kind(model_name: str) -> str:
     """Pick DeepMosaics' netG type from the weights filename (see their options.py)."""
     n = model_name.lower()
@@ -90,7 +111,7 @@ class DeepMosaicsRestorer(Restorer):
                 )
         model = Path(model_path)
         self._netg = _netg_kind(model.name)  # raises on a video model
-        pos = self._find_mosaic_position(model, deepmosaics_dir)
+        pos = _find_mosaic_position(model, deepmosaics_dir)
         if pos is None:
             raise ValueError(
                 "Рядом с clean-моделью не найден mosaic_position.pth.\n"
@@ -101,13 +122,6 @@ class DeepMosaicsRestorer(Restorer):
         self._gpu = gpu_id
         self._loaded = False  # models loaded lazily on first restore
 
-    @staticmethod
-    def _find_mosaic_position(model: Path, dm_dir: str | None) -> Path | None:
-        candidates = [model.parent / "mosaic_position.pth"]
-        if dm_dir:
-            candidates.append(Path(dm_dir) / "pretrained_models" / "mosaic" / "mosaic_position.pth")
-        return next((p for p in candidates if p.is_file()), None)
-
     @property
     def name(self) -> str:
         return f"DeepMosaics(gpu={self._gpu})"
@@ -167,3 +181,147 @@ class DeepMosaicsRestorer(Restorer):
         img_mosaic = work[y - size:y + size, x - size:x + size]
         img_fake = rm.run_pix2pix(img_mosaic, self._netG, opt)
         return impro.replace_mosaic(work, img_fake, mask, x, y, size, opt.no_feather)
+
+
+class DeepMosaicsVideoRestorer(Restorer):
+    """Temporal DeepMosaics (BVDNet) — un-censors using *neighbouring* frames.
+
+    Reproduces DeepMosaics' ``cleanmosaic_video_fusion`` per target frame: for frame
+    ``i`` it feeds the network a temporal window of ``T`` frames (sampled at step ``S``
+    around ``i``) plus its own previous output (recurrent), so the reconstruction is
+    temporally coherent. Because of that recurrence the frames MUST be processed in
+    order over a contiguous range — see :meth:`restore_sequence` (the batch run).
+
+    Needs the **video** weights ``clean_youknow_video.pth`` + ``mosaic_position.pth``
+    (beside it). Single-frame :meth:`restore` degrades to a window of the same frame.
+    """
+
+    temporal = True
+
+    # DeepMosaics fusion window: N before/after at step S → T = 2N+1 frames, INPUT_SIZE px.
+    _N, _T, _S = 2, 5, 3
+    _INPUT_SIZE = 256
+
+    def __init__(
+        self,
+        deepmosaics_dir: str | None,
+        model_path: str | None,
+        python_exe: str | None = None,  # unused (in-process); kept for factory parity
+        gpu_id: str = "0",
+    ) -> None:
+        chosen: Path | None = None
+        if model_path and Path(model_path).is_file() and "video" in Path(model_path).name.lower():
+            chosen = Path(model_path)
+        else:  # configured model missing or not a video model → auto-pick a video model
+            vids = [p for _n, p in discover_models(include_video=True) if "video" in Path(p).name.lower()]
+            if vids:
+                chosen = Path(vids[0])
+        if chosen is None:
+            raise ValueError(
+                "Не найдены веса видеомодели DeepMosaics (clean_*_video.pth).\n"
+                "Положите clean_youknow_video.pth + mosaic_position.pth в models/deepmosaics "
+                "(или выберите в «Восстановление…»). См. README."
+            )
+        pos = _find_mosaic_position(chosen, deepmosaics_dir)
+        if pos is None:
+            raise ValueError(
+                "Рядом с видеомоделью не найден mosaic_position.pth.\n"
+                "Положите mosaic_position.pth в ту же папку, что и clean_*_video.pth. См. README."
+            )
+        self._model = str(chosen)
+        self._pos = str(pos)
+        self._gpu = gpu_id
+        self._loaded = False
+
+    @property
+    def name(self) -> str:
+        return f"DeepMosaicsVideo(gpu={self._gpu})"
+
+    # ------------------------------------------------------------------ engine
+    def _ensure_loaded(self) -> None:
+        if self._loaded:
+            return
+        if str(_VENDOR) not in sys.path:
+            sys.path.insert(0, str(_VENDOR))
+
+        import torch  # noqa: E402
+        if self._gpu != "-1" and not torch.cuda.is_available():
+            self._gpu = "-1"  # CPU fallback (see DeepMosaicsRestorer for why)
+
+        from models import loadmodel, runmodel  # type: ignore  # noqa: E402
+        import util.data as data                 # type: ignore  # noqa: E402
+        import util.image_processing as impro     # type: ignore  # noqa: E402
+
+        self._torch = torch
+        self._runmodel = runmodel
+        self._data = data
+        self._impro = impro
+        self._opt = SimpleNamespace(
+            gpu_id=self._gpu,
+            model_path=self._model,
+            mosaic_position_model_path=self._pos,
+            mask_threshold=64,
+            all_mosaic_area=False,
+            ex_mult=1.5,
+            no_feather=False,
+        )
+        self._netM = loadmodel.bisenet(self._opt, "mosaic")
+        self._netG = loadmodel.video(self._opt)  # BVDNet
+        self._loaded = True
+
+    def restore(
+        self,
+        image: np.ndarray,
+        detections: list[Detection],
+        should_cancel: CancelCheck | None = None,
+    ) -> np.ndarray:
+        """Single-frame restore — no neighbours, so the window is the same frame."""
+        out: dict[int, np.ndarray] = {}
+        self.restore_sequence(
+            1,
+            lambda _i: image,
+            lambda _i: detections,
+            lambda i, r: out.__setitem__(i, r),
+            should_cancel,
+        )
+        return out.get(0, image.copy())
+
+    def restore_sequence(
+        self,
+        count: int,
+        get_frame: FrameGetter,
+        get_dets: DetGetter,
+        emit: ResultSink,
+        should_cancel: CancelCheck | None = None,
+    ) -> None:
+        self._ensure_loaded()
+        torch, data, impro, opt = self._torch, self._data, self._impro, self._opt
+        N, T, S, SZ = self._N, self._T, self._S, self._INPUT_SIZE
+
+        previous = None  # recurrent state: the network's previous output (a tensor)
+        for i in range(count):
+            if should_cancel is not None and should_cancel():
+                raise Cancelled("Восстановление отменено")
+            img_origin = get_frame(i)
+            x, y, size, mask = self._runmodel.get_mosaic_position(img_origin, self._netM, opt)
+            if size <= 50:
+                emit(i, img_origin.copy())  # no mosaic here; recurrence carries over
+                continue
+
+            stream = []
+            for k in range(T):
+                j = min(max(i + (k - N) * S, 0), count - 1)  # clamp window to range edges
+                frame = img_origin if j == i else get_frame(j)
+                crop = frame[y - size:y + size, x - size:x + size]
+                stream.append(impro.resize(crop, SZ)[:, :, ::-1])  # BGR→RGB, SZ×SZ
+
+            if previous is None:  # seed recurrence with the (centre) input crop
+                previous = data.im2tensor(stream[N], bgr2rgb=False, gpu_id=opt.gpu_id)
+
+            arr = np.array(stream).reshape(1, T, SZ, SZ, 3).transpose((0, 4, 1, 2, 3))
+            tensor = data.to_tensor(data.normalize(arr), gpu_id=opt.gpu_id)
+            with torch.no_grad():
+                pred = self._netG(tensor, previous)
+            previous = pred
+            img_fake = data.tensor2im(pred, rgb2bgr=True)
+            emit(i, impro.replace_mosaic(img_origin.copy(), img_fake, mask, x, y, size, opt.no_feather))

hvideotool/core/restore/factory.py

@@ -1,9 +1,13 @@
 """Restorer factory: build a Restorer from the app config.
 
-- ``inpaint``: cv2 baseline (no weights, no GPU; fills, doesn't reconstruct).
-- ``deepmosaics``: real generative mosaic removal. The DeepMosaics network code is
-  vendored (``_deepmosaics/``, GPL-3.0) and run in-process; the user supplies only the
-  clean weights (+ ``mosaic_position.pth`` alongside). A CUDA GPU is recommended.
+Only DeepMosaics is supported (the cv2 inpaint baseline was removed — it filled but
+did not reconstruct). The DeepMosaics network code is vendored (``_deepmosaics/``,
+GPL-3.0) and run in-process; the user supplies only the weights (+ ``mosaic_position.pth``
+alongside). A CUDA GPU is recommended.
+
+- ``deepmosaics``: per-frame generative mosaic removal (image model).
+- ``deepmosaics_video``: temporal variant (BVDNet) that uses neighbouring frames for
+  coherence — needs the ``clean_*_video.pth`` weights and a contiguous frame sequence.
 """
 
 from __future__ import annotations
@@ -11,25 +15,28 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from .base import Restorer
-from .inpaint import InpaintRestorer
 
 if TYPE_CHECKING:  # avoid importing AppConfig at runtime here (not needed)
     from ...config import AppConfig
 
 
-def build_restorer(name: str = "inpaint", config: "AppConfig | None" = None) -> Restorer:
-    if name == "inpaint":
-        return InpaintRestorer()
+def build_restorer(name: str = "deepmosaics", config: "AppConfig | None" = None) -> Restorer:
+    if config is None:
+        raise ValueError("Для DeepMosaics нужны настройки (config).")
     if name == "deepmosaics":
         from .deepmosaics import DeepMosaicsRestorer
 
-        if config is None:
-            raise ValueError("Для DeepMosaics нужны настройки (config).")
         return DeepMosaicsRestorer(
             config.dm_dir, config.dm_model, config.dm_python, config.dm_gpu
         )
+    if name == "deepmosaics_video":
+        from .deepmosaics import DeepMosaicsVideoRestorer
+
+        return DeepMosaicsVideoRestorer(
+            config.dm_dir, config.dm_model, config.dm_python, config.dm_gpu
+        )
     if name == "lada":
         raise ValueError(
-            "Движок LADA пока не подключён. Используйте DeepMosaics или inpaint. См. README."
+            "Движок LADA пока не подключён. Используйте DeepMosaics. См. README."
         )
     raise ValueError(f"Неизвестный режим восстановления: {name!r}")

hvideotool/core/restore/inpaint.py

@@ -1,41 +0,0 @@
-"""Classic inpainting restorer (cv2) — the always-available baseline.
-
-HONEST LIMITATION: cv2 inpainting fills the masked region by propagating
-surrounding pixels. It removes the mosaic/bar but does NOT reconstruct the hidden
-detail — it smooths/guesses. For real reconstruction a generative model
-(DeepMosaics / LADA) is needed; this is the no-weights, no-GPU fallback so the
-"Расцензурить кадр" flow works end-to-end today.
-"""
-
-from __future__ import annotations
-
-import cv2
-import numpy as np
-
-from ..detection.types import Detection
-from .base import CancelCheck, Restorer
-from .mask import detections_to_mask
-
-
-class InpaintRestorer(Restorer):
-    def __init__(self, radius: int = 3, dilate: int = 2, method: str = "telea") -> None:
-        self.radius = radius
-        self.dilate = dilate
-        self.method = method
-
-    @property
-    def name(self) -> str:
-        return f"InpaintRestorer({self.method})"
-
-    def restore(
-        self,
-        image: np.ndarray,
-        detections: list[Detection],
-        should_cancel: CancelCheck | None = None,
-    ) -> np.ndarray:
-        # Single cv2.inpaint call — effectively instant, so cancellation is moot.
-        if not detections:
-            return image.copy()
-        mask = detections_to_mask(image.shape, detections, dilate=self.dilate)
-        flags = cv2.INPAINT_TELEA if self.method == "telea" else cv2.INPAINT_NS
-        return cv2.inpaint(image, mask, self.radius, flags)

hvideotool/core/restore/mask.py

@@ -1,26 +0,0 @@
-"""Build a binary mask of the censored regions from detections."""
-
-from __future__ import annotations
-
-import cv2
-import numpy as np
-
-from ..detection.types import Detection
-
-
-def detections_to_mask(
-    shape: tuple[int, int], detections: list[Detection], dilate: int = 0
-) -> np.ndarray:
-    """White (255) over every detected region (polygon if present, else bbox)."""
-    h, w = shape[:2]
-    mask = np.zeros((h, w), np.uint8)
-    for d in detections:
-        if len(d.polygon) >= 3:
-            cv2.fillPoly(mask, [np.array(d.polygon, np.int32)], 255)
-        else:
-            x, y, bw, bh = d.bbox
-            cv2.rectangle(mask, (x, y), (x + bw, y + bh), 255, -1)
-    if dilate > 0:
-        k = np.ones((dilate * 2 + 1, dilate * 2 + 1), np.uint8)
-        mask = cv2.dilate(mask, k)
-    return mask

hvideotool/core/torch_info.py

@@ -1,18 +1,66 @@
-"""Probe the PyTorch / CUDA situation, so the UI can show a device badge.
+"""Diagnose the PyTorch / CUDA situation so the UI can explain *why* it's on CPU.
 
-Pure (no Qt). ``gather()`` imports torch (slow / heavy) — call it off the GUI
-thread. The rest are tiny formatters the UI uses to explain *why* it's on CPU and
-how to enable the GPU.
+Pure (no Qt). ``gather()`` is the heavy part — it imports torch and shells out to
+``nvidia-smi`` — so call it off the GUI thread. ``analyze()`` is fast formatting on
+the gathered dict and figures out the most likely cause + concrete fix.
 """
 
 from __future__ import annotations
 
-# pip index for the CUDA build (matches the README).
-CUDA_WHEEL_INDEX = "https://download.pytorch.org/whl/cu121"
+import re
+import shutil
+import subprocess
+import sys
+
+# pip indexes for the CUDA builds (see README). cu121 needs a driver with CUDA >= 12.1.
+CUDA_WHEELS = {
+    "cu121": "https://download.pytorch.org/whl/cu121",
+    "cu118": "https://download.pytorch.org/whl/cu118",
+}
+
+_NO_WINDOW = 0x08000000 if sys.platform == "win32" else 0  # CREATE_NO_WINDOW
+
+
+def _run_nvidia_smi() -> dict:
+    """Probe the NVIDIA driver/GPU via nvidia-smi. Never raises."""
+    out: dict = {"found": False, "gpus": [], "driver_version": None, "cuda_driver": None}
+    exe = shutil.which("nvidia-smi")
+    if not exe and sys.platform == "win32":
+        candidate = r"C:\Windows\System32\nvidia-smi.exe"
+        exe = candidate if shutil.os.path.isfile(candidate) else None
+    if not exe:
+        return out
+    # GPU names + driver version (robust CSV form).
+    try:
+        r = subprocess.run(
+            [exe, "--query-gpu=name,driver_version", "--format=csv,noheader,nounits"],
+            capture_output=True, text=True, timeout=10, creationflags=_NO_WINDOW,
+        )
+        if r.returncode == 0:
+            out["found"] = True
+            for line in r.stdout.strip().splitlines():
+                parts = [p.strip() for p in line.split(",")]
+                if parts and parts[0]:
+                    out["gpus"].append(parts[0])
+                    if len(parts) > 1 and parts[1]:
+                        out["driver_version"] = parts[1]
+    except Exception:  # noqa: BLE001 - any failure => "not found"
+        return out
+    # Max CUDA version the driver supports (only in the plain header).
+    try:
+        r2 = subprocess.run(
+            [exe], capture_output=True, text=True, timeout=10, creationflags=_NO_WINDOW,
+        )
+        m = re.search(r"CUDA Version:\s*([\d.]+)", r2.stdout)
+        if m:
+            out["cuda_driver"] = m.group(1)
+    except Exception:  # noqa: BLE001
+        pass
+    return out
 
 
 def gather() -> dict:
-    """Collect torch/CUDA facts. Never raises — missing torch is a valid result."""
+    """Collect torch + NVIDIA facts. Never raises — missing torch/GPU are valid."""
     info: dict = {
         "installed": False,
         "version": None,        # torch.__version__ (e.g. "2.12.0+cpu")
@@ -20,27 +68,38 @@ def gather() -> dict:
         "cuda_available": False,
         "device_name": None,    # the active GPU's name, if any
         "import_error": None,
+        # filled by nvidia-smi:
+        "nvidia_smi": False,
+        "gpus": [],
+        "driver_version": None,
+        "cuda_driver": None,
     }
     try:
         import torch
-    except Exception as exc:  # noqa: BLE001 - report any import failure, not just ImportError
+    except Exception as exc:  # noqa: BLE001 - report any import failure
         info["import_error"] = str(exc)
-        return info
-    info["installed"] = True
-    info["version"] = getattr(torch, "__version__", None)
-    try:
-        info["built_cuda"] = torch.version.cuda
-    except Exception:  # noqa: BLE001
-        info["built_cuda"] = None
-    try:
-        info["cuda_available"] = bool(torch.cuda.is_available())
-    except Exception:  # noqa: BLE001
-        info["cuda_available"] = False
-    if info["cuda_available"]:
+    else:
+        info["installed"] = True
+        info["version"] = getattr(torch, "__version__", None)
         try:
-            info["device_name"] = torch.cuda.get_device_name(0)
+            info["built_cuda"] = torch.version.cuda
         except Exception:  # noqa: BLE001
-            info["device_name"] = None
+            info["built_cuda"] = None
+        try:
+            info["cuda_available"] = bool(torch.cuda.is_available())
+        except Exception:  # noqa: BLE001
+            info["cuda_available"] = False
+        if info["cuda_available"]:
+            try:
+                info["device_name"] = torch.cuda.get_device_name(0)
+            except Exception:  # noqa: BLE001
+                info["device_name"] = None
+
+    smi = _run_nvidia_smi()
+    info["nvidia_smi"] = smi["found"]
+    info["gpus"] = smi["gpus"]
+    info["driver_version"] = smi["driver_version"]
+    info["cuda_driver"] = smi["cuda_driver"]
     return info
 
 
@@ -48,33 +107,117 @@ def device_label(info: dict) -> str:
     return "CUDA" if info.get("cuda_available") else "CPU"
 
 
-def reason(info: dict) -> str:
-    """One-sentence human explanation of the current device choice."""
-    if not info.get("installed"):
-        return ("PyTorch не установлен — детектор YOLO и восстановление DeepMosaics "
-                "работают на CPU (классический детектор torch не требует).")
-    if info.get("cuda_available"):
-        name = info.get("device_name") or "GPU"
-        return f"PyTorch использует CUDA: {name}. Вычисления идут на видеокарте."
-    version = info.get("version") or "?"
-    built = info.get("built_cuda")
-    if not built:
-        return (f"Установлена CPU-сборка PyTorch ({version}) — без поддержки CUDA, "
-                "поэтому вычисления идут на процессоре (медленно).")
-    return (f"PyTorch собран с CUDA {built} ({version}), но GPU недоступен: нет "
-            "NVIDIA-видеокарты, не установлен/устарел драйвер, либо версия CUDA "
-            "несовместима с драйвером.")
+def _ver_tuple(v: str | None) -> tuple[int, ...]:
+    try:
+        return tuple(int(x) for x in str(v).split(".")[:2])
+    except (ValueError, AttributeError):
+        return ()
 
 
-def install_hint() -> str:
-    """Steps to enable the GPU (shown when running on CPU)."""
+def recommend_channel(info: dict) -> str:
+    """Pick the pip CUDA wheel index that matches the driver (cu118 for older)."""
+    cd = _ver_tuple(info.get("cuda_driver"))
+    if cd and cd < (12, 1):
+        return "cu118"
+    return "cu121"
+
+
+def install_command(channel: str = "cu121") -> str:
+    """The pip commands to (re)install the chosen CUDA build.
+
+    Targets the **running interpreter** (``sys.executable -m pip``) so the command
+    hits the same venv that runs the app — not whatever ``pip`` is on PATH. (A common
+    trap: running bare ``pip`` in a global shell while torch lives in the project venv.)
+    """
+    index = CUDA_WHEELS.get(channel, CUDA_WHEELS["cu121"])
+    py = sys.executable or "python"
+    q = f'"{py}"' if " " in py else py
     return (
-        "Как включить GPU (NVIDIA):\n"
-        "1. Нужна видеокарта NVIDIA и свежий драйвер (проверка в консоли: nvidia-smi).\n"
-        "2. Переустановите PyTorch со сборкой CUDA:\n\n"
-        "   pip uninstall -y torch torchvision\n"
-        f"   pip install torch torchvision --index-url {CUDA_WHEEL_INDEX}\n\n"
-        "3. Перезапустите приложение.\n\n"
-        "Классический детектор работает и без CUDA. На CPU детекция и расцензуривание "
-        "просто медленнее."
+        f"{q} -m pip uninstall -y torch torchvision\n"
+        f"{q} -m pip install torch torchvision --index-url {index}"
     )
+
+
+def analyze(info: dict) -> dict:
+    """Turn the raw facts into {summary, details[list], steps, command}."""
+    installed = info.get("installed")
+    cuda = info.get("cuda_available")
+    built = info.get("built_cuda")
+    gpus = info.get("gpus") or []
+    smi = info.get("nvidia_smi")
+    driver = info.get("driver_version")
+    cuda_driver = info.get("cuda_driver")
+    channel = recommend_channel(info)
+    command = install_command(channel)
+
+    if not installed:
+        build_str = "не установлен"
+    elif built:
+        build_str = f"CUDA {built}"
+    else:
+        build_str = "CPU-only (+cpu)"
+    gpu_str = (
+        ", ".join(gpus) if gpus
+        else ("не обнаружена" if smi or info.get("nvidia_smi") is False else "nvidia-smi не найден")
+    )
+    if not gpus and not smi:
+        gpu_str = "nvidia-smi не найден (нет драйвера NVIDIA?)"
+    details = [
+        f"PyTorch: {info.get('version') or 'не установлен'}",
+        f"Сборка PyTorch: {build_str}",
+        f"CUDA доступна в PyTorch: {'да' if cuda else 'нет'}",
+        f"Видеокарта (nvidia-smi): {gpu_str}",
+        f"Драйвер NVIDIA: {driver or '—'}",
+        f"Макс. CUDA драйвера: {cuda_driver or '—'}",
+        f"Интерпретатор (venv): {sys.executable}",
+    ]
+    if info.get("import_error"):
+        details.append(f"Ошибка импорта torch: {info['import_error']}")
+
+    if not installed:
+        summary = "PyTorch не установлен — детекция YOLO и DeepMosaics идут на CPU."
+        steps = ("Установите PyTorch (CUDA-сборку, если есть NVIDIA-видеокарта):\n\n"
+                 + command + "\n\nДля YOLO также: pip install -e \".[yolo]\"")
+    elif cuda:
+        gpu = info.get("device_name") or (gpus[0] if gpus else "GPU")
+        summary = f"Всё в порядке: PyTorch использует CUDA. Активный GPU: {gpu}."
+        steps = "GPU уже задействован — ничего делать не нужно."
+    elif not built:  # CPU-only torch build — the usual case
+        if gpus:
+            summary = (
+                "Главная причина: установлена CPU-сборка PyTorch (+cpu) — она физически "
+                f"не умеет в CUDA. Видеокарта ({gpus[0]}) и драйвер {driver or '?'} на месте, "
+                "поэтому достаточно переустановить PyTorch со сборкой CUDA."
+            )
+            steps = ("Переустановите PyTorch под CUDA, затем перезапустите приложение:\n\n"
+                     + command)
+        else:
+            summary = (
+                "Установлена CPU-сборка PyTorch (+cpu), и видеокарта NVIDIA не обнаружена "
+                "(nvidia-smi не отвечает). Либо нет NVIDIA GPU, либо не установлен драйвер."
+            )
+            steps = ("1. Проверьте видеокарту и драйвер: в консоли выполните  nvidia-smi\n"
+                     "2. Если NVIDIA GPU есть — переустановите PyTorch под CUDA:\n\n"
+                     + command +
+                     "\n\nБез NVIDIA GPU всё работает на CPU — просто медленнее.")
+    else:  # CUDA-enabled torch build, but CUDA still not available
+        if not gpus:
+            summary = (
+                f"PyTorch собран под CUDA {built}, но видеокарта/драйвер NVIDIA не найдены. "
+                "Скорее всего не установлен драйвер NVIDIA или нет GPU."
+            )
+            steps = "Установите свежий драйвер NVIDIA и перезапустите. Проверка: nvidia-smi."
+        elif cuda_driver and _ver_tuple(cuda_driver) < _ver_tuple(built):
+            summary = (
+                f"Драйвер поддерживает CUDA {cuda_driver}, а PyTorch собран под CUDA {built} — "
+                "версия драйвера слишком старая."
+            )
+            steps = ("Вариант A — обновите драйвер NVIDIA (рекомендуется).\n"
+                     "Вариант B — поставьте PyTorch под CUDA вашего драйвера:\n\n" + command)
+        else:
+            summary = (
+                f"PyTorch собран под CUDA {built}, GPU ({gpus[0]}) есть, но CUDA недоступна — "
+                "вероятен конфликт версий или повреждённая установка."
+            )
+            steps = "Переустановите PyTorch под CUDA:\n\n" + command
+    return {"summary": summary, "details": details, "steps": steps, "command": command}