extractfaces-gui 0.1.0__tar.gz

extractfaces_gui-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Rafael O. Ribeiro
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

extractfaces_gui-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: extractfaces-gui
+Version: 0.1.0
+Summary: GUI application to extract faces from videos
+Author: Rafael O. Ribeiro
+Author-email: Rafael O. Ribeiro <rafaeloliveiraribeiro@gmail.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Requires-Dist: pyside6>=6.10,<7
+Requires-Dist: forensicface>=0.8,<0.9
+Requires-Dist: onnxruntime-gpu>=1.25,<1.26 ; sys_platform == 'win32'
+Requires-Python: >=3.14
+Project-URL: Homepage, https://github.com/rafribeiro/extractfaces-gui
+Project-URL: Repository, https://github.com/rafribeiro/extractfaces-gui
+Project-URL: Issues, https://github.com/rafribeiro/extractfaces-gui/issues
+Description-Content-Type: text/markdown
+
+# Extract Faces
+
+A Python desktop app built with Qt for extracting PNG face crops from videos
+using [forensicface](https://github.com/rafribeiro/forensicface).
+Play a video, draw a rectangular search area, choose an output folder, and
+configure the detector and extraction settings. The app also displays video
+dimensions, frame rate, duration, and media codecs.
+
+## Run locally
+
+Requires Python 3.14 or newer. From this project folder:
+
+```powershell
+uv sync
+uv run extract-faces
+```
+
+Alternatively, install with `pip install .`, then run `extract-faces` or
+`python -m extract_faces`. Once published to PyPI, installation will be
+`pip install extractfaces-gui`.
+
+## Face detector setup
+
+The app uses forensicface's SCRFD detector with optional attributes and
+embeddings disabled. Place its `det_10g.onnx` model at:
+
+```text
+~/.forensicface/models/detection/scrfd/det_10g.onnx
+```
+
+On Windows, `~` means your user folder, such as `C:\Users\rafael`.
+See [forensicface's model documentation](https://github.com/rafribeiro/forensicface#layout-de-modelos-por-tarefa-e-alias)
+for the layout and model credits. The app does not download model weights.
+CPU processing is the default; enable GPU only with a compatible GPU/runtime.
+Forensicface installs CUDA dependencies even when using CPU, so installation
+can be a large download. ONNX Runtime is constrained to the 1.25 series on
+Windows because newer CUDA extras currently lack compatible Windows wheels.
+
+## Use the app
+
+1. Open a video with the file picker or drop a video file onto the app (the first
+   local file is opened if several are dropped). Playback is silent. Metadata includes dimensions, frame rate,
+   duration, and codecs when available.
+2. Pause or drag a rectangle on the preview. Detection searches that area in
+   every processed frame. Clear the region to search the full frame.
+3. Choose an empty output folder, crop size multiplier, frames to skip, and
+   start time. A multiplier of 2 doubles the detected box's dimensions;
+   skipping 4 frames processes every fifth frame.
+   Set **Detector size (det_size)** and **Detection threshold (det_thresh)**
+   before extraction to configure SCRFD. Defaults are 320 and 0.5. Larger
+   detector sizes take longer; lower thresholds may accept more false positives.
+4. Click **Extract faces**. Progress counts sampled frames. Cancel takes effect
+   after the current detector operation; crops already saved are kept.
+
+Click **Show console output** to expand the console pane. It captures Python
+standard output and errors, including forensicface initialization, progress,
+and extraction tracebacks, even while collapsed. The most recent 2,000 lines
+are kept. Native-library output written directly to the operating system's
+console is not captured. Dropping another video is disabled during extraction.
+
+Extraction reads the original video. The rectangle restricts detection;
+added crop margins may extend beyond the rectangle, within the full frame.
+Closing during extraction requests cancellation; close again after it stops.
+
+## Code layout
+
+All UI and extraction code is in `src/extract_faces/app.py`:
+
+- `VideoView` paints frames and handles the rectangle in image coordinates.
+- `ExtractionWorker` runs forensicface in a background thread. A small adapter
+  crops the detector input and restores coordinates before forensicface saves
+  crops from the original frame.
+- `MainWindow` creates the controls and connects their actions.
+
+`__init__.py` is the installed command's entry point; `__main__.py` supports
+`python -m extract_faces`. No separate services or application layers.
+
+Run the tests with `uv run python -m unittest discover -s tests -v`.
+They exercise the GUI without a visible window and use a fake detector with
+forensicface's real video extraction method, so model weights are unnecessary.

extractfaces_gui-0.1.0/README.md

@@ -0,0 +1,80 @@
+# Extract Faces
+
+A Python desktop app built with Qt for extracting PNG face crops from videos
+using [forensicface](https://github.com/rafribeiro/forensicface).
+Play a video, draw a rectangular search area, choose an output folder, and
+configure the detector and extraction settings. The app also displays video
+dimensions, frame rate, duration, and media codecs.
+
+## Run locally
+
+Requires Python 3.14 or newer. From this project folder:
+
+```powershell
+uv sync
+uv run extract-faces
+```
+
+Alternatively, install with `pip install .`, then run `extract-faces` or
+`python -m extract_faces`. Once published to PyPI, installation will be
+`pip install extractfaces-gui`.
+
+## Face detector setup
+
+The app uses forensicface's SCRFD detector with optional attributes and
+embeddings disabled. Place its `det_10g.onnx` model at:
+
+```text
+~/.forensicface/models/detection/scrfd/det_10g.onnx
+```
+
+On Windows, `~` means your user folder, such as `C:\Users\rafael`.
+See [forensicface's model documentation](https://github.com/rafribeiro/forensicface#layout-de-modelos-por-tarefa-e-alias)
+for the layout and model credits. The app does not download model weights.
+CPU processing is the default; enable GPU only with a compatible GPU/runtime.
+Forensicface installs CUDA dependencies even when using CPU, so installation
+can be a large download. ONNX Runtime is constrained to the 1.25 series on
+Windows because newer CUDA extras currently lack compatible Windows wheels.
+
+## Use the app
+
+1. Open a video with the file picker or drop a video file onto the app (the first
+   local file is opened if several are dropped). Playback is silent. Metadata includes dimensions, frame rate,
+   duration, and codecs when available.
+2. Pause or drag a rectangle on the preview. Detection searches that area in
+   every processed frame. Clear the region to search the full frame.
+3. Choose an empty output folder, crop size multiplier, frames to skip, and
+   start time. A multiplier of 2 doubles the detected box's dimensions;
+   skipping 4 frames processes every fifth frame.
+   Set **Detector size (det_size)** and **Detection threshold (det_thresh)**
+   before extraction to configure SCRFD. Defaults are 320 and 0.5. Larger
+   detector sizes take longer; lower thresholds may accept more false positives.
+4. Click **Extract faces**. Progress counts sampled frames. Cancel takes effect
+   after the current detector operation; crops already saved are kept.
+
+Click **Show console output** to expand the console pane. It captures Python
+standard output and errors, including forensicface initialization, progress,
+and extraction tracebacks, even while collapsed. The most recent 2,000 lines
+are kept. Native-library output written directly to the operating system's
+console is not captured. Dropping another video is disabled during extraction.
+
+Extraction reads the original video. The rectangle restricts detection;
+added crop margins may extend beyond the rectangle, within the full frame.
+Closing during extraction requests cancellation; close again after it stops.
+
+## Code layout
+
+All UI and extraction code is in `src/extract_faces/app.py`:
+
+- `VideoView` paints frames and handles the rectangle in image coordinates.
+- `ExtractionWorker` runs forensicface in a background thread. A small adapter
+  crops the detector input and restores coordinates before forensicface saves
+  crops from the original frame.
+- `MainWindow` creates the controls and connects their actions.
+
+`__init__.py` is the installed command's entry point; `__main__.py` supports
+`python -m extract_faces`. No separate services or application layers.
+
+Run the tests with `uv run python -m unittest discover -s tests -v`.
+They exercise the GUI without a visible window and use a fake detector with
+forensicface's real video extraction method, so model weights are unnecessary.

extractfaces_gui-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "extractfaces-gui"
+version = "0.1.0"
+description = "GUI application to extract faces from videos"
+readme = "README.md"
+requires-python = ">=3.14"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+dependencies = [
+    "PySide6>=6.10,<7",
+    "forensicface>=0.8,<0.9",
+    "onnxruntime-gpu>=1.25,<1.26; sys_platform == 'win32'",
+]
+
+[[project.authors]]
+name = "Rafael O. Ribeiro"
+email = "rafaeloliveiraribeiro@gmail.com"
+
+[project.gui-scripts]
+extract-faces = "extract_faces:main"
+
+[project.urls]
+Homepage = "https://github.com/rafribeiro/extractfaces-gui"
+Repository = "https://github.com/rafribeiro/extractfaces-gui"
+Issues = "https://github.com/rafribeiro/extractfaces-gui/issues"
+
+[build-system]
+requires = ["uv_build>=0.12.23,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "extract_faces"

extractfaces_gui-0.1.0/pyproject.toml.orig

@@ -0,0 +1,30 @@
+[project]
+name = "extractfaces-gui"
+version = "0.1.0"
+description = "GUI application to extract faces from videos"
+readme = "README.md"
+requires-python = ">=3.14"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+authors = [{ name = "Rafael O. Ribeiro", email = "rafaeloliveiraribeiro@gmail.com" }]
+dependencies = [
+    "PySide6>=6.10,<7",
+    "forensicface>=0.8,<0.9",
+    # Newer CUDA extras currently resolve to packages without Windows wheels.
+    "onnxruntime-gpu>=1.25,<1.26; sys_platform == 'win32'",
+]
+
+[project.gui-scripts]
+extract-faces = "extract_faces:main"
+
+[project.urls]
+Homepage = "https://github.com/rafribeiro/extractfaces-gui"
+Repository = "https://github.com/rafribeiro/extractfaces-gui"
+Issues = "https://github.com/rafribeiro/extractfaces-gui/issues"
+
+[build-system]
+requires = ["uv_build>=0.12.23,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "extract_faces"

extractfaces_gui-0.1.0/src/extract_faces/__init__.py

@@ -0,0 +1,4 @@
+def main() -> None:
+    from .app import main as run_app
+
+    run_app()

extractfaces_gui-0.1.0/src/extract_faces/__main__.py

@@ -0,0 +1,3 @@
+from . import main
+
+main()

extractfaces_gui-0.1.0/src/extract_faces/app.py

@@ -0,0 +1,500 @@
+"""A small Qt window for previewing videos and extracting face crops."""
+
+import math
+import sys
+import traceback
+from pathlib import Path
+
+import cv2
+from PySide6.QtCore import QObject, QPointF, QRectF, Qt, QThread, QUrl, Signal, Slot
+from PySide6.QtGui import QColor, QImage, QPainter, QPen, QTextCursor
+from PySide6.QtMultimedia import QMediaMetaData, QMediaPlayer, QVideoSink
+from PySide6.QtWidgets import (
+    QApplication, QCheckBox, QDoubleSpinBox, QFileDialog, QFormLayout,
+    QHBoxLayout, QLabel, QLineEdit, QMainWindow, QMessageBox, QProgressBar,
+    QPlainTextEdit, QPushButton, QSlider, QSpinBox, QVBoxLayout, QWidget,
+)
+
+
+class ConsoleStream(QObject):
+    """Send Python output to the GUI safely, including from the worker thread."""
+
+    text_written = Signal(str)
+    encoding = "utf-8"
+
+    def __init__(self, original):
+        super().__init__()
+        self.original = original
+
+    def write(self, text):
+        if self.original is not None:
+            self.original.write(text)
+        self.text_written.emit(text)
+        return len(text)
+
+    def flush(self):
+        if self.original is not None:
+            self.original.flush()
+
+    def isatty(self):
+        return False
+
+
+class VideoView(QWidget):
+    """Paint the video and store the selection in original image pixels."""
+
+    selection_changed = Signal()
+    selection_started = Signal()
+
+    def __init__(self):
+        super().__init__()
+        self.image = QImage()
+        self.region = None
+        self.anchor = None
+        self.setMinimumSize(480, 270)
+
+    def set_frame(self, frame):
+        image = frame.toImage()
+        if not image.isNull():
+            self.image = image
+            self.update()
+
+    def image_rect(self):
+        if self.image.isNull():
+            return QRectF()
+        scale = min(self.width() / self.image.width(), self.height() / self.image.height())
+        width, height = self.image.width() * scale, self.image.height() * scale
+        return QRectF((self.width() - width) / 2, (self.height() - height) / 2, width, height)
+
+    def image_point(self, point):
+        rect = self.image_rect()
+        return QPointF(
+            max(0, min(self.image.width(), (point.x() - rect.x()) * self.image.width() / rect.width())),
+            max(0, min(self.image.height(), (point.y() - rect.y()) * self.image.height() / rect.height())),
+        )
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.fillRect(self.rect(), QColor("#202020"))
+        if self.image.isNull():
+            painter.setPen(Qt.GlobalColor.white)
+            painter.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter, "Open a video to begin")
+            return
+        rect = self.image_rect()
+        painter.drawImage(rect, self.image)
+        if self.region is not None:
+            scale = rect.width() / self.image.width()
+            selection = QRectF(rect.x() + self.region.x() * scale,
+                               rect.y() + self.region.y() * scale,
+                               self.region.width() * scale, self.region.height() * scale)
+            painter.setPen(QPen(QColor("#00e5ff"), 2))
+            painter.drawRect(selection)
+
+    def mousePressEvent(self, event):
+        if event.button() == Qt.MouseButton.LeftButton and self.image_rect().contains(event.position()):
+            self.selection_started.emit()
+            self.anchor = self.image_point(event.position())
+            self.region = QRectF(self.anchor, self.anchor)
+
+    def mouseMoveEvent(self, event):
+        if self.anchor is not None:
+            self.region = QRectF(self.anchor, self.image_point(event.position())).normalized()
+            self.update()
+
+    def mouseReleaseEvent(self, event):
+        if self.anchor is not None:
+            self.mouseMoveEvent(event)
+            self.anchor = None
+            if self.region.width() < 2 or self.region.height() < 2:
+                self.region = None
+            self.selection_changed.emit()
+            self.update()
+
+    def clear_region(self):
+        self.region = None
+        self.selection_changed.emit()
+        self.update()
+
+    def region_pixels(self):
+        if self.region is None:
+            return None
+        return (math.floor(self.region.left()), math.floor(self.region.top()),
+                math.ceil(self.region.right()), math.ceil(self.region.bottom()))
+
+
+class ExtractionCancelled(Exception):
+    pass
+
+
+class ExtractionWorker(QThread):
+    """Run forensicface away from the GUI thread; report sampled frames."""
+
+    progress = Signal(int)
+    message = Signal(str)
+
+    def __init__(self, video, destination, region, every_n_frames, margin, start_from,
+                 use_gpu, det_size=320, det_thresh=0.5):
+        super().__init__()
+        self.video = video
+        self.destination = destination
+        self.region = region
+        self.every_n_frames = every_n_frames
+        self.margin = margin
+        self.start_from = start_from
+        self.use_gpu = use_gpu
+        self.det_size = det_size
+        self.det_thresh = det_thresh
+
+    def run(self):
+        try:
+            # Import and load the detector here so the window remains responsive.
+            from forensicface.app import ForensicFace
+
+            detector = ForensicFace(detection="scrfd", embedding=None, pose=None,
+                                    gender=None, age=None, quality=None, use_gpu=self.use_gpu,
+                                    det_size=self.det_size, det_thresh=self.det_thresh)
+            original_process_image = detector.process_image
+            processed = 0
+
+            def process_region(frame, **kwargs):
+                nonlocal processed
+                if self.isInterruptionRequested():
+                    raise ExtractionCancelled()
+                if self.region is None:
+                    results = original_process_image(frame, **kwargs)
+                else:
+                    x1, y1, x2, y2 = self.region
+                    if not (0 <= x1 < x2 <= frame.shape[1] and 0 <= y1 < y2 <= frame.shape[0]):
+                        raise ValueError("Video preview and extraction dimensions differ. Clear the region and retry.")
+                    results = original_process_image(frame[y1:y2, x1:x2], **kwargs)
+                    # extract_faces crops the full frame, so restore full-frame coordinates.
+                    for result in results:
+                        result["bbox"] = result["bbox"] + [x1, y1, x1, y1]
+                        result["keypoints"] = result["keypoints"] + [x1, y1]
+                processed += 1
+                self.progress.emit(processed)
+                return results
+
+            # extract_faces has no ROI argument; adapt this instance's image processing.
+            detector.process_image = process_region
+            count = detector.extract_faces(
+                self.video, dest_folder=self.destination, every_n_frames=self.every_n_frames,
+                margin=self.margin, start_from=self.start_from,
+            )
+            self.message.emit(f"Finished: {count} face crops saved to {self.destination}")
+        except ExtractionCancelled:
+            self.message.emit("Extraction cancelled. Crops already saved remain in the output folder.")
+        except Exception as error:
+            traceback.print_exc()
+            self.message.emit(f"Extraction failed: {error}")
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Extract Faces")
+        self.setAcceptDrops(True)
+        self.resize(1000, 800)
+        self.video_path = None
+        self.worker = None
+        self.duration_seconds = 0
+        self.fps = 0
+
+        self.player = QMediaPlayer(self)
+        self.sink = QVideoSink(self)
+        self.player.setVideoSink(self.sink)
+        self.view = VideoView()
+        self.sink.videoFrameChanged.connect(self.view.set_frame)
+        self.view.selection_started.connect(self.player.pause)
+
+        central = QWidget()
+        self.setCentralWidget(central)
+        layout = QVBoxLayout(central)
+        self.open_button = QPushButton("Open video…")
+        self.open_button.clicked.connect(self.open_video)
+        layout.addWidget(self.open_button)
+        layout.addWidget(self.view, 1)
+
+        playback = QHBoxLayout()
+        self.play_button = QPushButton("Play / Pause")
+        self.play_button.clicked.connect(self.toggle_playback)
+        playback.addWidget(self.play_button)
+        self.seek = QSlider(Qt.Orientation.Horizontal)
+        self.seek.sliderMoved.connect(self.player.setPosition)
+        self.player.positionChanged.connect(self.update_position)
+        self.player.durationChanged.connect(lambda duration: self.seek.setRange(0, duration))
+        playback.addWidget(self.seek, 1)
+        self.time_label = QLabel("0.00 s")
+        playback.addWidget(self.time_label)
+        layout.addLayout(playback)
+
+        self.metadata = QLabel("No video selected")
+        self.metadata.setWordWrap(True)
+        layout.addWidget(self.metadata)
+        self.player.metaDataChanged.connect(self.update_codecs)
+        self.player.errorOccurred.connect(lambda error, text: self.status.setText(f"Playback error: {text}"))
+
+        self.settings = QWidget()
+        form = QFormLayout(self.settings)
+        region_row = QHBoxLayout()
+        self.region_label = QLabel("Full frame — drag on the video to select a region")
+        region_row.addWidget(self.region_label, 1)
+        clear_button = QPushButton("Clear region")
+        clear_button.clicked.connect(self.view.clear_region)
+        region_row.addWidget(clear_button)
+        form.addRow("Search area", region_row)
+        self.view.selection_changed.connect(self.update_region)
+
+        folder_row = QHBoxLayout()
+        self.destination = QLineEdit()
+        self.destination.setAcceptDrops(False)
+        folder_row.addWidget(self.destination)
+        browse_button = QPushButton("Browse…")
+        browse_button.clicked.connect(self.choose_folder)
+        folder_row.addWidget(browse_button)
+        form.addRow("Output folder", folder_row)
+
+        self.margin = QDoubleSpinBox()
+        self.margin.setRange(1, 10)
+        self.margin.setSingleStep(0.1)
+        self.margin.setValue(2)
+        self.margin.setToolTip("1 keeps the detected box; 2 doubles its width and height.")
+        form.addRow("Crop size multiplier", self.margin)
+        self.skip = QSpinBox()
+        self.skip.setRange(0, 100000)
+        self.skip.setToolTip("0 processes every frame; 4 processes every fifth frame.")
+        form.addRow("Frames to skip", self.skip)
+        self.start = QDoubleSpinBox()
+        self.start.setRange(0, 864000)
+        self.start.setSuffix(" s")
+        start_row = QHBoxLayout()
+        start_row.addWidget(self.start)
+        current_button = QPushButton("Use current position")
+        current_button.clicked.connect(lambda: self.start.setValue(self.player.position() / 1000))
+        start_row.addWidget(current_button)
+        form.addRow("Start time", start_row)
+        self.det_size = QSpinBox()
+        self.det_size.setRange(32, 4096)
+        self.det_size.setSingleStep(32)
+        self.det_size.setValue(320)
+        self.det_size.setToolTip("Square detector input size in pixels. Larger sizes can detect smaller faces but take longer.")
+        form.addRow("Detector size (det_size)", self.det_size)
+        self.det_thresh = QDoubleSpinBox()
+        self.det_thresh.setRange(0, 1)
+        self.det_thresh.setSingleStep(0.05)
+        self.det_thresh.setValue(0.5)
+        self.det_thresh.setToolTip("Minimum detection confidence. Lower values accept more detections, including possible false positives.")
+        form.addRow("Detection threshold (det_thresh)", self.det_thresh)
+        self.gpu = QCheckBox("Use GPU (requires a compatible runtime)")
+        form.addRow(self.gpu)
+        layout.addWidget(self.settings)
+
+        actions = QHBoxLayout()
+        self.extract_button = QPushButton("Extract faces")
+        self.extract_button.setEnabled(False)
+        self.extract_button.clicked.connect(self.extract)
+        actions.addWidget(self.extract_button)
+        self.cancel_button = QPushButton("Cancel extraction")
+        self.cancel_button.setEnabled(False)
+        self.cancel_button.clicked.connect(self.cancel_extraction)
+        actions.addWidget(self.cancel_button)
+        layout.addLayout(actions)
+        self.progress = QProgressBar()
+        layout.addWidget(self.progress)
+        self.status = QLabel("Ready. Playback is silent; extraction uses the original video.")
+        self.status.setWordWrap(True)
+        self.status.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+        layout.addWidget(self.status)
+
+        self.console_toggle = QPushButton("Show console output")
+        self.console_toggle.setCheckable(True)
+        layout.addWidget(self.console_toggle)
+        self.console = QPlainTextEdit()
+        self.console.setAcceptDrops(False)
+        self.console.setReadOnly(True)
+        self.console.setMaximumBlockCount(2000)
+        self.console.setMinimumHeight(120)
+        self.console.setMaximumHeight(240)
+        self.console.hide()
+        self.console_toggle.toggled.connect(self.toggle_console)
+        layout.addWidget(self.console)
+
+    def toggle_console(self, expanded):
+        self.console.setVisible(expanded)
+        self.console_toggle.setText("Hide console output" if expanded else "Show console output")
+
+    @Slot(str)
+    def append_console(self, text):
+        # tqdm uses carriage returns; show each update as a readable log line.
+        cursor = self.console.textCursor()
+        cursor.movePosition(QTextCursor.MoveOperation.End)
+        cursor.insertText(text.replace("\r", "\n"))
+        self.console.setTextCursor(cursor)
+        self.console.ensureCursorVisible()
+
+    def dropped_video(self, mime_data):
+        if self.worker is not None:
+            return None
+        for url in mime_data.urls():
+            if url.isLocalFile() and Path(url.toLocalFile()).is_file():
+                return url.toLocalFile()
+        return None
+
+    def dragEnterEvent(self, event):
+        if self.dropped_video(event.mimeData()):
+            event.acceptProposedAction()
+        else:
+            event.ignore()
+
+    def dropEvent(self, event):
+        path = self.dropped_video(event.mimeData())
+        if path:
+            event.acceptProposedAction()
+            self.load_video(path)
+        else:
+            event.ignore()
+
+    def open_video(self):
+        path, _ = QFileDialog.getOpenFileName(self, "Open video", "", "Video files (*.mp4 *.avi *.mov *.mkv *.webm *.m4v *.mpeg *.mts);;All files (*)")
+        if not path:
+            return
+        self.load_video(path)
+
+    def load_video(self, path):
+        if self.worker is not None:
+            return
+        capture = cv2.VideoCapture(path)
+        try:
+            if not capture.isOpened():
+                QMessageBox.warning(self, "Cannot open video", "The video could not be read.")
+                return
+            width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            fps = capture.get(cv2.CAP_PROP_FPS)
+            frames = capture.get(cv2.CAP_PROP_FRAME_COUNT)
+            codec = int(capture.get(cv2.CAP_PROP_FOURCC))
+            fourcc = "".join(chr((codec >> (8 * i)) & 255) for i in range(4)).strip("\x00")
+        finally:
+            capture.release()
+        self.player.stop()
+        self.video_path = path
+        self.fps = fps if math.isfinite(fps) and fps > 0 else 0
+        self.duration_seconds = frames / self.fps if self.fps and math.isfinite(frames) else 0
+        self.base_metadata = f"{Path(path).name} | {width} × {height} | {self.fps:.3f} fps | {self.duration_seconds:.2f} s | Video: {fourcc or 'unknown'}"
+        self.metadata.setText(self.base_metadata)
+        self.view.image = QImage()
+        self.view.clear_region()
+        self.destination.setText(str(Path(path).with_name(Path(path).stem + "_faces")))
+        self.start.setValue(0)
+        self.start.setMaximum(max(0, self.duration_seconds - 0.01))
+        self.player.setSource(QUrl.fromLocalFile(path))
+        self.player.play()
+        self.extract_button.setEnabled(True)
+        self.status.setText("Pause or drag on the video to select the search area.")
+
+    def update_codecs(self):
+        if not self.video_path:
+            return
+        metadata = self.player.metaData()
+        video = metadata.stringValue(QMediaMetaData.Key.VideoCodec)
+        audio = metadata.stringValue(QMediaMetaData.Key.AudioCodec)
+        self.metadata.setText(self.base_metadata + f" | Media codecs: {video or 'unknown video'}, {audio or 'no audio / unknown'}")
+
+    def update_position(self, position):
+        if not self.seek.isSliderDown():
+            self.seek.setValue(position)
+        self.time_label.setText(f"{position / 1000:.2f} s")
+
+    def toggle_playback(self):
+        if self.player.playbackState() == QMediaPlayer.PlaybackState.PlayingState:
+            self.player.pause()
+        else:
+            self.player.play()
+
+    def update_region(self):
+        region = self.view.region_pixels()
+        self.region_label.setText(f"Pixels (x1, y1, x2, y2): {region}" if region else "Full frame — drag on the video to select a region")
+
+    def choose_folder(self):
+        folder = QFileDialog.getExistingDirectory(self, "Output folder", self.destination.text())
+        if folder:
+            self.destination.setText(folder)
+
+    def extract(self):
+        destination = self.destination.text().strip()
+        if not destination:
+            QMessageBox.warning(self, "Output folder required", "Choose a folder for the PNG crops.")
+            return
+        try:
+            folder = Path(destination).expanduser().resolve()
+            folder.mkdir(parents=True, exist_ok=True)
+            if any(folder.iterdir()):
+                QMessageBox.warning(self, "Choose an empty folder", "Choose an empty output folder to avoid overwriting previous crops.")
+                return
+        except OSError as error:
+            QMessageBox.warning(self, "Cannot use output folder", str(error))
+            return
+        self.player.pause()
+        self.settings.setEnabled(False)
+        self.view.setEnabled(False)
+        self.open_button.setEnabled(False)
+        self.extract_button.setEnabled(False)
+        self.cancel_button.setEnabled(True)
+        every_n = self.skip.value() + 1
+        estimated_frames = max(1, math.ceil((self.duration_seconds - self.start.value()) * self.fps / every_n))
+        self.progress.setRange(0, estimated_frames if self.fps else 0)
+        self.progress.setValue(0)
+        self.status.setText("Loading face detector…")
+        self.worker = ExtractionWorker(self.video_path, str(folder), self.view.region_pixels(),
+                                       every_n, self.margin.value(), self.start.value(), self.gpu.isChecked(),
+                                       det_size=self.det_size.value(), det_thresh=self.det_thresh.value())
+        self.worker.progress.connect(self.update_progress)
+        self.worker.message.connect(self.status.setText)
+        self.worker.finished.connect(self.extraction_finished)
+        self.worker.start()
+
+    def update_progress(self, processed):
+        if self.progress.maximum() > 0:
+            self.progress.setMaximum(max(self.progress.maximum(), processed))
+            self.progress.setValue(processed)
+        self.status.setText(f"Processed {processed} sampled frames…")
+
+    def cancel_extraction(self):
+        if self.worker:
+            self.worker.requestInterruption()
+            self.cancel_button.setEnabled(False)
+            self.status.setText("Cancelling after the current detector operation…")
+
+    def extraction_finished(self):
+        self.settings.setEnabled(True)
+        self.view.setEnabled(True)
+        self.open_button.setEnabled(True)
+        self.extract_button.setEnabled(True)
+        self.cancel_button.setEnabled(False)
+        self.worker.deleteLater()
+        self.worker = None
+
+    def closeEvent(self, event):
+        if self.worker and self.worker.isRunning():
+            self.cancel_extraction()
+            event.ignore()
+        else:
+            self.player.stop()
+            event.accept()
+
+
+def main():
+    app = QApplication(sys.argv)
+    window = MainWindow()
+    original_stdout, original_stderr = sys.stdout, sys.stderr
+    stdout = ConsoleStream(original_stdout)
+    stderr = ConsoleStream(original_stderr)
+    stdout.text_written.connect(window.append_console)
+    stderr.text_written.connect(window.append_console)
+    sys.stdout, sys.stderr = stdout, stderr
+    try:
+        window.show()
+        exit_code = app.exec()
+    finally:
+        sys.stdout, sys.stderr = original_stdout, original_stderr
+    sys.exit(exit_code)