old_main.py

import sys
import cv2
import numpy as np
import json
from PyQt6.QtWidgets import QApplication, QLabel, QWidget, QMenu, QSplashScreen
from PyQt6.QtGui import (
    QImage, QPixmap, QMouseEvent, QAction,
    QPainter, QPainterPath, QWheelEvent, QRadialGradient, QLinearGradient, QBrush, QColor,
    QIcon, QFont
)
from PyQt6.QtCore import QTimer, Qt, QRectF, QPointF, QAbstractNativeEventFilter
from pathlib import Path
import urllib.request
import ctypes
import ctypes.wintypes


class HotkeyFilter(QAbstractNativeEventFilter):
    """╨д╨╕╨╗╤М╤В╤А ╨╜╨░╤В╨╕╨▓╨╜╤Л╤Е ╤Б╨╛╨▒╤Л╤В╨╕╨╣ ╨┤╨╗╤П ╨┐╨╡╤А╨╡╤Е╨▓╨░╤В╨░ ╨│╨╗╨╛╨▒╨░╨╗╤М╨╜╤Л╤Е ╨│╨╛╤А╤П╤З╨╕╤Е ╨║╨╗╨░╨▓╨╕╤И (WM_HOTKEY)"""
    
    def __init__(self, callback):
        super().__init__()
        self.callback = callback
    
    def nativeEventFilter(self, eventType, message):
        if eventType == b'windows_generic_MSG':
            try:
                msg = ctypes.wintypes.MSG.from_address(int(message))
                if msg.message == 0x0312:  # WM_HOTKEY
                    self.callback(msg.wParam)
                    return True, 0
            except Exception:
                pass
        return False, 0

# MediaPipe ╨┤╨╗╤П AI-╤Н╤Д╤Д╨╡╨║╤В╨╛╨▓ (╨╜╨╛╨▓╤Л╨╣ Tasks API)
def _get_log_path():
    """╨Я╤Г╤В╤М ╨║ ╨╗╨╛╨│-╤Д╨░╨╣╨╗╤Г ╤А╤П╨┤╨╛╨╝ ╤Б exe ╨╕╨╗╨╕ main.py"""
    if getattr(sys, 'frozen', False):
        return Path(sys.executable).parent / "minicamapp_error.log"
    return Path(__file__).parent / "minicamapp_error.log"

try:
    import mediapipe as mp
    from mediapipe.tasks import python
    from mediapipe.tasks.python import vision
    MEDIAPIPE_AVAILABLE = True
    print(f"тЬЕ MediaPipe ╨╖╨░╨│╤А╤Г╨╢╨╡╨╜ (╨▓╨╡╤А╤Б╨╕╤П: {mp.__version__})")
except Exception as e:
    import traceback
    MEDIAPIPE_AVAILABLE = False
    error_text = traceback.format_exc()
    print(f"тЪая╕П MediaPipe ╨╜╨╡╨┤╨╛╤Б╤В╤Г╨┐╨╡╨╜: {e}")
    # ╨Я╨╕╤И╨╡╨╝ ╨┐╨╛╨╗╨╜╤Г╤О ╨╛╤И╨╕╨▒╨║╤Г ╨▓ ╨╗╨╛╨│-╤Д╨░╨╣╨╗ (╨▓╨╕╨┤╨╡╨╜ ╨┤╨░╨╢╨╡ ╨▒╨╡╨╖ ╨║╨╛╨╜╤Б╨╛╨╗╨╕)
    try:
        log_path = _get_log_path()
        with open(log_path, 'w', encoding='utf-8') as f:
            f.write(f"MediaPipe import error:\n{error_text}\n")
        print(f"   ╨Я╨╛╨┤╤А╨╛╨▒╨╜╨╛╤Б╤В╨╕ ╨▓ ╤Д╨░╨╣╨╗╨╡: {log_path}")
    except Exception:
        pass


# ==================== TRANSLATIONS ====================
TRANSLATIONS = {
    "en": {
        # Menu items
        "video_shape": "Video Shape",
        "rectangle": "Rectangle",
        "rounded_rectangle": "Rounded Rectangle",
        "circle": "Circle",
        "flip_horizontal": "Flip Horizontally",
        "flip_vertical": "Flip Vertically",
        "face_tracking": "Face Tracking",
        "background_blur": "Background Blur",
        "edge_blur": "Edge Blur",
        "language": "Language",
        "exit": "Exit",
        
        # Settings
        "disabled": "Disabled",
        "very_far": "Very Far (1.2x)",
        "far": "Far (1.4x)",
        "medium": "Medium (1.8x)",
        "close": "Close (2.5x)",
        "weak": "Weak (15)",
        "strong": "Strong (45)",
        "very_strong": "Very Strong (65)",
        "narrow": "Narrow (15px)",
        "wide": "Wide (50px)",
        "very_wide": "Very Wide (70px)",
        
        # Opacity
        "opacity": "Opacity",
        "opacity_100": "100%",
        "opacity_75": "75%",
        "opacity_50": "50%",
        "opacity_25": "25%",
        
        # Languages
        "lang_english": "English",
        "lang_russian": "╨а╤Г╤Б╤Б╨║╨╕╨╣"
    },
    "ru": {
        # Menu items
        "video_shape": "╨д╨╛╤А╨╝╨░ ╨▓╨╕╨┤╨╡╨╛",
        "rectangle": "╨Я╤А╤П╨╝╨╛╤Г╨│╨╛╨╗╤М╨╜╨╕╨║",
        "rounded_rectangle": "╨б╨║╤А╤Г╨│╨╗╤С╨╜╨╜╤Л╨╣ ╨┐╤А╤П╨╝╨╛╤Г╨│╨╛╨╗╤М╨╜╨╕╨║",
        "circle": "╨Ъ╤А╤Г╨│",
        "flip_horizontal": "╨Ю╤В╨╖╨╡╤А╨║╨░╨╗╨╕╤В╤М ╨┐╨╛ ╨│╨╛╤А╨╕╨╖╨╛╨╜╤В╨░╨╗╨╕",
        "flip_vertical": "╨Ю╤В╨╖╨╡╤А╨║╨░╨╗╨╕╤В╤М ╨┐╨╛ ╨▓╨╡╤А╤В╨╕╨║╨░╨╗╨╕",
        "face_tracking": "╨Ю╤В╤Б╨╗╨╡╨╢╨╕╨▓╨░╨╜╨╕╨╡ ╨╗╨╕╤Ж╨░",
        "background_blur": "╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╤Д╨╛╨╜╨░",
        "edge_blur": "╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║╤А╨░╤С╨▓",
        "language": "╨п╨╖╤Л╨║",
        "exit": "╨Т╤Л╤Е╨╛╨┤",
        
        # Settings
        "disabled": "╨Т╤Л╨║╨╗╤О╤З╨╡╨╜╨╛",
        "very_far": "╨Ю╤З╨╡╨╜╤М ╨┤╨░╨╗╨╡╨║╨╛ (1.2x)",
        "far": "╨Ф╨░╨╗╨╡╨║╨╛ (1.4x)",
        "medium": "╨б╤А╨╡╨┤╨╜╨╡ (1.8x)",
        "close": "╨С╨╗╨╕╨╖╨║╨╛ (2.5x)",
        "weak": "╨б╨╗╨░╨▒╨╛╨╡ (15)",
        "strong": "╨б╨╕╨╗╤М╨╜╨╛╨╡ (45)",
        "very_strong": "╨Ю╤З╨╡╨╜╤М ╤Б╨╕╨╗╤М╨╜╨╛╨╡ (65)",
        "narrow": "╨г╨╖╨║╨╛╨╡ (15px)",
        "wide": "╨и╨╕╤А╨╛╨║╨╛╨╡ (50px)",
        "very_wide": "╨Ю╤З╨╡╨╜╤М ╤И╨╕╤А╨╛╨║╨╛╨╡ (70px)",
        
        # ╨Я╤А╨╛╨╖╤А╨░╤З╨╜╨╛╤Б╤В╤М
        "opacity": "╨Я╤А╨╛╨╖╤А╨░╤З╨╜╨╛╤Б╤В╤М",
        "opacity_100": "100%",
        "opacity_75": "75%",
        "opacity_50": "50%",
        "opacity_25": "25%",
        
        # Languages
        "lang_english": "English",
        "lang_russian": "╨а╤Г╤Б╤Б╨║╨╕╨╣"
    }
}


class ConfigManager:
    """╨Ь╨╡╨╜╨╡╨┤╨╢╨╡╤А ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╨╕ ╨┤╨╗╤П ╤Б╨╛╤Е╤А╨░╨╜╨╡╨╜╨╕╤П ╨╕ ╨╖╨░╨│╤А╤Г╨╖╨║╨╕ ╨╜╨░╤Б╤В╤А╨╛╨╡╨║"""
    
    @staticmethod
    def get_config_path():
        """╨Я╨╛╨╗╤Г╤З╨╕╤В╤М ╨┐╤Г╤В╤М ╨║ ╤Д╨░╨╣╨╗╤Г ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╨╕
        
        ╨а╨░╨▒╨╛╤В╨░╨╡╤В ╨║╨░╨║ ╨┤╨╗╤П ╤А╨░╨╖╤А╨░╨▒╨╛╤В╨║╨╕ (main.py), ╤В╨░╨║ ╨╕ ╨┤╨╗╤П ╤Г╨┐╨░╨║╨╛╨▓╨░╨╜╨╜╨╛╨│╨╛ exe (PyInstaller)
        """
        if getattr(sys, 'frozen', False):
            # ╨г╨┐╨░╨║╨╛╨▓╨░╨╜╨╜╨╛╨╡ ╨┐╤А╨╕╨╗╨╛╨╢╨╡╨╜╨╕╨╡ (PyInstaller)
            # sys.executable - ╤Н╤В╨╛ ╨┐╤Г╤В╤М ╨║ .exe ╤Д╨░╨╣╨╗╤Г
            app_dir = Path(sys.executable).parent
        else:
            # ╨а╨╡╨╢╨╕╨╝ ╤А╨░╨╖╤А╨░╨▒╨╛╤В╨║╨╕ (╨╖╨░╨┐╤Г╤Б╨║ ╤З╨╡╤А╨╡╨╖ python)
            app_dir = Path(__file__).parent
        
        return app_dir / "config.json"
    
    @staticmethod
    def load_config():
        """╨Ч╨░╨│╤А╤Г╨╖╨╕╤В╤М ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╤О ╨╕╨╖ ╤Д╨░╨╣╨╗╨░"""
        config_path = ConfigManager.get_config_path()
        
        # ╨Ч╨╜╨░╤З╨╡╨╜╨╕╤П ╨┐╨╛ ╤Г╨╝╨╛╨╗╤З╨░╨╜╨╕╤О
        default_config = {
            "language": "ru",  # ╨п╨╖╤Л╨║ ╨┐╨╛ ╤Г╨╝╨╛╨╗╤З╨░╨╜╨╕╤О: ╤А╤Г╤Б╤Б╨║╨╕╨╣
            "window": {
                "x": 100,
                "y": 100,
                "width": 640,
                "height": 480
            },
            "video": {
                "shape": "rectangle",
                "flip_horizontal": False,
                "flip_vertical": False
            },
            "effects": {
                "face_tracking": {
                    "enabled": False,
                    "zoom_level": 1.4
                },
                "background_blur": {
                    "enabled": False,
                    "strength": 25
                },
                "edge_blur": {
                    "enabled": False,
                    "width": 30
                }
            },
            "opacity": 1.0
        }
        
        # ╨Я╤Л╤В╨░╨╡╨╝╤Б╤П ╨╖╨░╨│╤А╤Г╨╖╨╕╤В╤М ╨║╨╛╨╜╤Д╨╕╨│
        try:
            if config_path.exists():
                with open(config_path, 'r', encoding='utf-8') as f:
                    loaded_config = json.load(f)
                    print(f"тЬЕ ╨Ъ╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╤П ╨╖╨░╨│╤А╤Г╨╢╨╡╨╜╨░ ╨╕╨╖ {config_path}")
                    # ╨Ю╨▒╤К╨╡╨┤╨╕╨╜╤П╨╡╨╝ ╤Б ╨┤╨╡╤Д╨╛╨╗╤В╨╜╤Л╨╝╨╕ ╨╖╨╜╨░╤З╨╡╨╜╨╕╤П╨╝╨╕ (╨╜╨░ ╤Б╨╗╤Г╤З╨░╨╣ ╨╡╤Б╨╗╨╕ ╨┤╨╛╨▒╨░╨▓╨╗╨╡╨╜╤Л ╨╜╨╛╨▓╤Л╨╡ ╨┐╨╛╨╗╤П)
                    return ConfigManager._merge_configs(default_config, loaded_config)
            else:
                print(f"ЁЯУЭ ╨д╨░╨╣╨╗ ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╨╕ ╨╜╨╡ ╨╜╨░╨╣╨┤╨╡╨╜, ╨╕╤Б╨┐╨╛╨╗╤М╨╖╤Г╤О╤В╤Б╤П ╨╖╨╜╨░╤З╨╡╨╜╨╕╤П ╨┐╨╛ ╤Г╨╝╨╛╨╗╤З╨░╨╜╨╕╤О")
                return default_config
        except Exception as e:
            print(f"тЪая╕П ╨Ю╤И╨╕╨▒╨║╨░ ╨╖╨░╨│╤А╤Г╨╖╨║╨╕ ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╨╕: {e}")
            print(f"   ╨Ш╤Б╨┐╨╛╨╗╤М╨╖╤Г╤О╤В╤Б╤П ╨╖╨╜╨░╤З╨╡╨╜╨╕╤П ╨┐╨╛ ╤Г╨╝╨╛╨╗╤З╨░╨╜╨╕╤О")
            return default_config
    
    @staticmethod
    def save_config(config):
        """╨б╨╛╤Е╤А╨░╨╜╨╕╤В╤М ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╤О ╨▓ ╤Д╨░╨╣╨╗"""
        config_path = ConfigManager.get_config_path()
        
        try:
            with open(config_path, 'w', encoding='utf-8') as f:
                json.dump(config, f, indent=2, ensure_ascii=False)
            # print(f"ЁЯТ╛ ╨Ъ╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╤П ╤Б╨╛╤Е╤А╨░╨╜╨╡╨╜╨░ ╨▓ {config_path}")  # ╨Ч╨░╨║╨╛╨╝╨╝╨╡╨╜╤В╨╕╤А╨╛╨▓╨░╨╜╨╛ ╤З╤В╨╛╨▒╤Л ╨╜╨╡ ╤Б╨┐╨░╨╝╨╕╤В╤М
        except Exception as e:
            print(f"тЪая╕П ╨Ю╤И╨╕╨▒╨║╨░ ╤Б╨╛╤Е╤А╨░╨╜╨╡╨╜╨╕╤П ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╨╕: {e}")
    
    @staticmethod
    def _merge_configs(default, loaded):
        """╨Ю╨▒╤К╨╡╨┤╨╕╨╜╨╕╤В╤М ╨╖╨░╨│╤А╤Г╨╢╨╡╨╜╨╜╤Г╤О ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╤О ╤Б ╨┤╨╡╤Д╨╛╨╗╤В╨╜╨╛╨╣ (╨┤╨╗╤П ╨╛╨▒╤А╨░╤В╨╜╨╛╨╣ ╤Б╨╛╨▓╨╝╨╡╤Б╤В╨╕╨╝╨╛╤Б╤В╨╕)"""
        result = default.copy()
        
        for key, value in loaded.items():
            if key in result and isinstance(value, dict) and isinstance(result[key], dict):
                # ╨а╨╡╨║╤Г╤А╤Б╨╕╨▓╨╜╨╛ ╨╛╨▒╤К╨╡╨┤╨╕╨╜╤П╨╡╨╝ ╨▓╨╗╨╛╨╢╨╡╨╜╨╜╤Л╨╡ ╤Б╨╗╨╛╨▓╨░╤А╨╕
                result[key] = ConfigManager._merge_configs(result[key], value)
            else:
                # ╨Я╨╡╤А╨╡╨╖╨░╨┐╨╕╤Б╤Л╨▓╨░╨╡╨╝ ╨╖╨╜╨░╤З╨╡╨╜╨╕╨╡
                result[key] = value
        
        return result


class VideoWindow(QWidget):
    def _get_resource_path(self, filename):
        """╨Я╨╛╨╗╤Г╤З╨╕╤В╤М ╨┐╤Г╤В╤М ╨║ ╤Д╨░╨╣╨╗╤Г ╤А╨╡╤Б╤Г╤А╤Б╨░ (╤А╨░╨▒╨╛╤В╨░╨╡╤В ╨┤╨╗╤П dev ╨╕ exe ╤А╨╡╨╢╨╕╨╝╨╛╨▓)"""
        if getattr(sys, 'frozen', False):
            app_dir = Path(sys.executable).parent
        else:
            app_dir = Path(__file__).parent
        return app_dir / filename

    def _splash_progress(self, value: int, message: str):
        """╨Ю╨▒╨╜╨╛╨▓╨╕╤В╤М ╤Б╨┐╨╗╤Н╤И-╤Н╨║╤А╨░╨╜ ╨╡╤Б╨╗╨╕ ╨╛╨╜ ╨╡╤Б╤В╤М"""
        if self._splash:
            self._splash.set_progress(value, message)

    def _apply_win32_noactivate(self):
        """Win32: WS_EX_NOACTIVATE - ╨╛╨║╨╜╨╛ ╨╜╨╡ ╨░╨║╤В╨╕╨▓╨╕╤А╤Г╨╡╤В╤Б╤П ╨┐╤А╨╕ ╨║╨╗╨╕╨║╨╡ ╨▓ ╨┤╤А╤Г╨│╨╛╨╡ ╨╛╨║╨╜╨╛"""
        try:
            GWL_EXSTYLE   = -20
            WS_EX_NOACTIVATE   = 0x08000000
            WS_EX_APPWINDOW    = 0x00040000

            hwnd = int(self.winId())
            style = ctypes.windll.user32.GetWindowLongW(hwnd, GWL_EXSTYLE)
            # ╨Ф╨╛╨▒╨░╨▓╨╗╤П╨╡╨╝ NOACTIVATE, ╤Г╨▒╨╕╤А╨░╨╡╨╝ APPWINDOW (╤З╤В╨╛╨▒╤Л ╨╜╨╡ ╨┐╨╡╤А╨╡╤Е╨▓╨░╤В╤Л╨▓╨░╨╗ ╤Д╨╛╨║╤Г╤Б ╤З╨╡╤А╨╡╨╖ taskbar)
            style = (style | WS_EX_NOACTIVATE) & ~WS_EX_APPWINDOW
            ctypes.windll.user32.SetWindowLongW(hwnd, GWL_EXSTYLE, style)
        except Exception as e:
            print(f"тЪая╕П Win32 NOACTIVATE: {e}")

    def _reassert_topmost(self):
        """Win32: ╨┐╨╡╤А╨╡╤Г╤В╨▓╨╡╤А╨╢╨┤╨░╨╡╨╝ HWND_TOPMOST ╨║╨░╨╢╨┤╤Л╨╡ 500╨╝╤Б - ╨╜╨░ ╤Б╨╗╤Г╤З╨░╨╣ ╨╡╤Б╨╗╨╕ ╨╕╨│╤А╨░ ╤Б╨┤╨▓╨╕╨╜╤Г╨╗╨░ z-╨┐╨╛╤А╤П╨┤╨╛╨║"""
        try:
            HWND_TOPMOST = -1
            SWP_NOMOVE   = 0x0002
            SWP_NOSIZE   = 0x0001
            SWP_NOACTIVATE = 0x0010
            hwnd = int(self.winId())
            ctypes.windll.user32.SetWindowPos(
                hwnd, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE
            )
        except Exception:
            pass

    def download_model_if_needed(self):
        """╨б╨║╨░╤З╨░╤В╤М ╨╝╨╛╨┤╨╡╨╗╤М ╤Б╨╡╨│╨╝╨╡╨╜╤В╨░╤Ж╨╕╨╕ ╨╡╤Б╨╗╨╕ ╨╡╤С ╨╜╨╡╤В"""
        if getattr(sys, 'frozen', False):
            app_dir = Path(sys.executable).parent
        else:
            app_dir = Path(__file__).parent
        
        model_dir = app_dir / "models"
        model_dir.mkdir(exist_ok=True)
        
        model_path = model_dir / "selfie_segmenter.tflite"
        
        if model_path.exists():
            print(f"ЁЯУж ╨Ь╨╛╨┤╨╡╨╗╤М ╤Б╨╡╨│╨╝╨╡╨╜╤В╨░╤Ж╨╕╨╕ ╨╜╨░╨╣╨┤╨╡╨╜╨░: {model_path}")
            return model_path
        
        # ╨б╨║╨░╤З╨╕╨▓╨░╨╡╨╝ ╨╝╨╛╨┤╨╡╨╗╤М
        model_url = "https://storage.googleapis.com/mediapipe-models/image_segmenter/selfie_segmenter/float16/latest/selfie_segmenter.tflite"
        
        try:
            print("ЁЯУе ╨б╨║╨░╤З╨╕╨▓╨░╨╜╨╕╨╡ ╨╝╨╛╨┤╨╡╨╗╨╕ ╤Б╨╡╨│╨╝╨╡╨╜╤В╨░╤Ж╨╕╨╕ AI (~3MB)...")
            urllib.request.urlretrieve(model_url, model_path)
            print(f"тЬЕ ╨Ь╨╛╨┤╨╡╨╗╤М ╤Б╨╡╨│╨╝╨╡╨╜╤В╨░╤Ж╨╕╨╕ ╤Б╨║╨░╤З╨░╨╜╨░: {model_path}")
            return model_path
        except Exception as e:
            print(f"тЭМ ╨Ю╤И╨╕╨▒╨║╨░ ╤Б╨║╨░╤З╨╕╨▓╨░╨╜╨╕╤П ╨╝╨╛╨┤╨╡╨╗╨╕: {e}")
            return None
    
    def download_face_detector_model(self):
        """╨б╨║╨░╤З╨░╤В╤М ╨╝╨╛╨┤╨╡╨╗╤М ╨╛╨┐╤А╨╡╨┤╨╡╨╗╨╡╨╜╨╕╤П ╨╗╨╕╤Ж ╨╡╤Б╨╗╨╕ ╨╡╤С ╨╜╨╡╤В"""
        if getattr(sys, 'frozen', False):
            app_dir = Path(sys.executable).parent
        else:
            app_dir = Path(__file__).parent
        
        model_dir = app_dir / "models"
        model_dir.mkdir(exist_ok=True)
        
        model_path = model_dir / "blaze_face_short_range.tflite"
        
        if model_path.exists():
            print(f"ЁЯУж ╨Ь╨╛╨┤╨╡╨╗╤М ╨╛╨┐╤А╨╡╨┤╨╡╨╗╨╡╨╜╨╕╤П ╨╗╨╕╤Ж ╨╜╨░╨╣╨┤╨╡╨╜╨░: {model_path}")
            return model_path
        
        # ╨б╨║╨░╤З╨╕╨▓╨░╨╡╨╝ ╨╝╨╛╨┤╨╡╨╗╤М BlazeFace
        model_url = "https://storage.googleapis.com/mediapipe-models/face_detector/blaze_face_short_range/float16/1/blaze_face_short_range.tflite"
        
        try:
            print("ЁЯУе ╨б╨║╨░╤З╨╕╨▓╨░╨╜╨╕╨╡ ╨╝╨╛╨┤╨╡╨╗╨╕ ╨╛╨┐╤А╨╡╨┤╨╡╨╗╨╡╨╜╨╕╤П ╨╗╨╕╤Ж (~1MB)...")
            urllib.request.urlretrieve(model_url, model_path)
            print(f"тЬЕ ╨Ь╨╛╨┤╨╡╨╗╤М ╨╛╨┐╤А╨╡╨┤╨╡╨╗╨╡╨╜╨╕╤П ╨╗╨╕╤Ж ╤Б╨║╨░╤З╨░╨╜╨░: {model_path}")
            return model_path
        except Exception as e:
            print(f"тЭМ ╨Ю╤И╨╕╨▒╨║╨░ ╤Б╨║╨░╤З╨╕╨▓╨░╨╜╨╕╤П ╨╝╨╛╨┤╨╡╨╗╨╕ ╨╛╨┐╤А╨╡╨┤╨╡╨╗╨╡╨╜╨╕╤П ╨╗╨╕╤Ж: {e}")
            return None
    
    def __init__(self, splash=None):
        super().__init__()
        self._splash = splash

        # ╨Ч╨░╨│╤А╤Г╨╢╨░╨╡╨╝ ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╤О
        self._splash_progress(15, "Loading config...")
        self.config = ConfigManager.load_config()
        self.current_language = self.config.get("language", "ru")

        self.setWindowTitle("MiniCamApp")
        
        # ╨г╤Б╤В╨░╨╜╨░╨▓╨╗╨╕╨▓╨░╨╡╨╝ ╨╕╨║╨╛╨╜╨║╤Г ╨┐╤А╨╕╨╗╨╛╨╢╨╡╨╜╨╕╤П (╨┤╨╗╤П ╨┐╨░╨╜╨╡╨╗╨╕ ╨╖╨░╨┤╨░╤З ╨╕ Alt+Tab)
        icon_path = self._get_resource_path("icon.ico")
        if icon_path.exists():
            self.setWindowIcon(QIcon(str(icon_path)))
            app_instance = QApplication.instance()
            if app_instance:
                app_instance.setWindowIcon(QIcon(str(icon_path)))
            print(f"ЁЯОи ╨Ш╨║╨╛╨╜╨║╨░ ╨╖╨░╨│╤А╤Г╨╢╨╡╨╜╨░: {icon_path}")
        else:
            print(f"тЪая╕П ╨Ш╨║╨╛╨╜╨║╨░ ╨╜╨╡ ╨╜╨░╨╣╨┤╨╡╨╜╨░: {icon_path}")
        
        # ╨Я╤А╨╕╨╝╨╡╨╜╤П╨╡╨╝ ╤Б╨╛╤Е╤А╨░╨╜╨╡╨╜╨╜╤Л╨╡ ╤А╨░╨╖╨╝╨╡╤А╤Л ╨╕ ╨┐╨╛╨╖╨╕╤Ж╨╕╤О ╨╛╨║╨╜╨░
        window_cfg = self.config["window"]
        self.setGeometry(
            window_cfg["x"],
            window_cfg["y"],
            window_cfg["width"],
            window_cfg["height"]
        )

        # ╨Я╤А╨╛╨╖╤А╨░╤З╨╜╨╛╨╡ ╨╛╨║╨╜╨╛
        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
        self.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating)
        self.setWindowFlag(Qt.WindowType.FramelessWindowHint)
        self.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint)
        self.setWindowFlag(Qt.WindowType.WindowDoesNotAcceptFocus)

        self.label = QLabel(self)
        self.label.setGeometry(0, 0, window_cfg["width"], window_cfg["height"])

        self._splash_progress(30, "Opening camera...")
        # ╨Ъ╨░╨╝╨╡╤А╨░ (╤В╨╛╨╗╤М╨║╨╛ ╨╛╨┤╨╜╨░ - ╨║╨░╨╝╨╡╤А╨░ 0)
        self.cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
        
        if not self.cap.isOpened():
            print("╨Ю╤И╨╕╨▒╨║╨░: ╨╜╨╡ ╤Г╨┤╨░╨╗╨╛╤Б╤М ╨╛╤В╨║╤А╤Л╤В╤М ╨║╨░╨╝╨╡╤А╤Г")
            sys.exit(1)
            
        self.video_ratio = self.cap.get(cv2.CAP_PROP_FRAME_WIDTH) / self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT)

        # ╨в╨░╨╣╨╝╨╡╤А ╨╛╨▒╨╜╨╛╨▓╨╗╨╡╨╜╨╕╤П ╨║╨░╨┤╤А╨╛╨▓
        self.timer = QTimer()
        self.timer.timeout.connect(self.update_frame)
        self.timer.start(66)  # ~15 FPS

        # ╨Я╤А╨╕╨╝╨╡╨╜╤П╨╡╨╝ ╨╜╨░╤Б╤В╤А╨╛╨╣╨║╨╕ ╨╕╨╖ ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╨╕
        video_cfg = self.config["video"]
        self.video_shape = video_cfg["shape"]
        self.corner_radius = 40
        self.flip_horizontal = video_cfg["flip_horizontal"]
        self.flip_vertical = video_cfg["flip_vertical"]
        
        # ╨н╤Д╤Д╨╡╨║╤В╤Л ╨╕╨╖ ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╨╕
        effects_cfg = self.config["effects"]
        
        # ╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║╤А╨░╤С╨▓
        edge_cfg = effects_cfg["edge_blur"]
        self.edge_blur_enabled = edge_cfg["enabled"]
        self.edge_blur_width = edge_cfg["width"]
        
        # ╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╤Д╨╛╨╜╨░
        blur_cfg = effects_cfg["background_blur"]
        self.background_blur_enabled = blur_cfg["enabled"]
        self.blur_strength = blur_cfg["strength"]
        
        # ╨Я╤А╨╛╨╖╤А╨░╤З╨╜╨╛╤Б╤В╤М ╨╛╨║╨╜╨░
        self.window_opacity = self.config.get("opacity", 1.0)
        self.setWindowOpacity(self.window_opacity)
        
        # ╨г╨╗╤Г╤З╤И╨╡╨╜╨╕╨╡ ╨╝╨░╤Б╨║╨╕
        self.previous_mask = None  # ╨Ф╨╗╤П temporal smoothing
        self.temporal_weight = 0.8  # ╨Т╨╡╤Б ╤В╨╡╨║╤Г╤Й╨╡╨╣ ╨╝╨░╤Б╨║╨╕ (0.8 = ╨▒╨╛╨╗╤М╤И╨╡ ╤Б╤В╨░╨▒╨╕╨╗╤М╨╜╨╛╤Б╤В╨╕)
        self.mask_blur_kernel = 5  # ╨а╨░╨╖╨╝╨╡╤А ╤П╨┤╤А╨░ ╨┤╨╗╤П feathering (╨╜╨╡╤З╤С╤В╨╜╨╛╨╡, ╨╝╨╡╨╜╤М╤И╨╡ = ╤З╨╡╤В╤З╨╡)
        
        # ╨Ю╤В╤Б╨╗╨╡╨╢╨╕╨▓╨░╨╜╨╕╨╡ ╨╗╨╕╤Ж╨░
        face_cfg = effects_cfg["face_tracking"]
        self.face_tracking_enabled = face_cfg["enabled"]
        self.face_zoom_level = face_cfg["zoom_level"]
        self.crop_x = 0.5  # ╨в╨╡╨║╤Г╤Й╨╡╨╡ ╤Б╨╝╨╡╤Й╨╡╨╜╨╕╨╡ ╨║╨░╨┤╤А╨╕╤А╨╛╨▓╨░╨╜╨╕╤П ╨┐╨╛ X
        self.crop_y = 0.5  # ╨в╨╡╨║╤Г╤Й╨╡╨╡ ╤Б╨╝╨╡╤Й╨╡╨╜╨╕╨╡ ╨║╨░╨┤╤А╨╕╤А╨╛╨▓╨░╨╜╨╕╤П ╨┐╨╛ Y
        self.crop_scale = 1.0  # ╨в╨╡╨║╤Г╤Й╨╕╨╣ ╨╝╨░╤Б╤И╤В╨░╨▒
        self.crop_smoothing = 0.07  # ╨б╨║╨╛╤А╨╛╤Б╤В╤М ╨┐╨╗╨░╨▓╨╜╨╛╨│╨╛ ╨┐╨╡╤А╨╡╤Е╨╛╨┤╨░ (╨╝╨╡╨╜╤М╤И╨╡ = ╨┐╨╗╨░╨▓╨╜╨╡╨╡)
        self.last_face_time = 0  # ╨Т╤А╨╡╨╝╤П ╨┐╨╛╤Б╨╗╨╡╨┤╨╜╨╡╨│╨╛ ╨╛╨▒╨╜╨░╤А╤Г╨╢╨╡╨╜╨╕╤П ╨╗╨╕╤Ж╨░
        self.face_lost_timeout = 2.0  # ╨Т╤А╨╡╨╝╤П ╨▓ ╤Б╨╡╨║╤Г╨╜╨┤╨░╤Е ╨┤╨╗╤П ╨▓╨╛╨╖╨▓╤А╨░╤В╨░ ╨║ ╨┐╨╛╨╗╨╜╨╛╨╝╤Г ╨║╨░╨┤╤А╤Г
        self.face_deadzone = 0.03  # ╨Ь╤С╤А╤В╨▓╨░╤П ╨╖╨╛╨╜╨░ тАФ ╨╕╨│╨╜╨╛╤А╨╕╤А╨╛╨▓╨░╤В╤М ╤Б╨╝╨╡╤Й╨╡╨╜╨╕╤П < 3% ╨║╨░╨┤╤А╨░
        self.face_detect_interval = 3  # ╨Ч╨░╨┐╤Г╤Б╨║╨░╤В╤М ╨┤╨╡╤В╨╡╨║╤Ж╨╕╤О ╨║╨░╨╢╨┤╤Л╨╡ N ╨║╨░╨┤╤А╨╛╨▓
        self.face_detect_counter = 0  # ╨б╤З╤С╤В╤З╨╕╨║ ╨║╨░╨┤╤А╨╛╨▓ ╨┤╨╗╤П ╨┤╨╡╤В╨╡╨║╤Ж╨╕╨╕
        self.last_crop_info = None  # ╨Я╨╛╤Б╨╗╨╡╨┤╨╜╨╕╨╣ ╤А╨╡╨╖╤Г╨╗╤М╤В╨░╤В ╨┤╨╡╤В╨╡╨║╤Ж╨╕╨╕ (╨┤╨╗╤П ╨┐╨╛╨▓╤В╨╛╤А╨░ ╨╝╨╡╨╢╨┤╤Г ╨║╨░╨┤╤А╨░╨╝╨╕)
        
        self._splash_progress(50, "Loading AI models...")
        # ╨Ш╨╜╨╕╤Ж╨╕╨░╨╗╨╕╨╖╨░╤Ж╨╕╤П MediaPipe (Tasks API)
        self.segmentation = None
        if MEDIAPIPE_AVAILABLE:
            try:
                # ╨Я╤Г╤В╤М ╨║ ╨╝╨╛╨┤╨╡╨╗╨╕
                model_path = self.download_model_if_needed()
                
                if model_path and model_path.exists():
                    # ╨б╨╛╨╖╨┤╨░╤С╨╝ ╨╛╨┐╤Ж╨╕╨╕ ╨┤╨╗╤П ╤Б╨╡╨│╨╝╨╡╨╜╤В╨░╤Ж╨╕╨╕
                    base_options = python.BaseOptions(model_asset_path=str(model_path))
                    options = vision.ImageSegmenterOptions(
                        base_options=base_options,
                        output_category_mask=True)
                    
                    # ╨б╨╛╨╖╨┤╨░╤С╨╝ ╤Б╨╡╨│╨╝╨╡╨╜╤В╨░╤В╨╛╤А
                    self.segmentation = vision.ImageSegmenter.create_from_options(options)
                    print("ЁЯОи AI-╤Н╤Д╤Д╨╡╨║╤В╤Л ╨│╨╛╤В╨╛╨▓╤Л")
                else:
                    print("тЪая╕П ╨Э╨╡ ╤Г╨┤╨░╨╗╨╛╤Б╤М ╨╖╨░╨│╤А╤Г╨╖╨╕╤В╤М ╨╝╨╛╨┤╨╡╨╗╤М")
                    self.segmentation = None
            except Exception as e:
                print(f"тЪая╕П ╨Э╨╡ ╤Г╨┤╨░╨╗╨╛╤Б╤М ╨╕╨╜╨╕╤Ж╨╕╨░╨╗╨╕╨╖╨╕╤А╨╛╨▓╨░╤В╤М AI-╤Н╤Д╤Д╨╡╨║╤В╤Л: {e}")
                self.segmentation = None
        
        self._splash_progress(75, "Loading face detector...")
        # ╨Ш╨╜╨╕╤Ж╨╕╨░╨╗╨╕╨╖╨░╤Ж╨╕╤П ╨┤╨╡╤В╨╡╨║╤В╨╛╤А╨░ ╨╗╨╕╤Ж MediaPipe
        self.face_detector = None
        if MEDIAPIPE_AVAILABLE:
            try:
                face_model_path = self.download_face_detector_model()
                
                if face_model_path and face_model_path.exists():
                    base_options = python.BaseOptions(model_asset_path=str(face_model_path))
                    options = vision.FaceDetectorOptions(
                        base_options=base_options,
                        min_detection_confidence=0.5)
                    
                    self.face_detector = vision.FaceDetector.create_from_options(options)
                    print("ЁЯСБя╕П ╨Ю╤В╤Б╨╗╨╡╨╢╨╕╨▓╨░╨╜╨╕╨╡ ╨╗╨╕╤Ж ╨│╨╛╤В╨╛╨▓╨╛")
                else:
                    print("тЪая╕П ╨Э╨╡ ╤Г╨┤╨░╨╗╨╛╤Б╤М ╨╖╨░╨│╤А╤Г╨╖╨╕╤В╤М ╨╝╨╛╨┤╨╡╨╗╤М ╨╛╨┐╤А╨╡╨┤╨╡╨╗╨╡╨╜╨╕╤П ╨╗╨╕╤Ж")
                    self.face_detector = None
            except Exception as e:
                print(f"тЪая╕П ╨Э╨╡ ╤Г╨┤╨░╨╗╨╛╤Б╤М ╨╕╨╜╨╕╤Ж╨╕╨░╨╗╨╕╨╖╨╕╤А╨╛╨▓╨░╤В╤М ╨┤╨╡╤В╨╡╨║╤В╨╛╤А ╨╗╨╕╤Ж: {e}")
                self.face_detector = None

        # ╨Ь╤Л╤И╤М
        self.offset = None
        self.resizing = False
        self.resize_margin = 15
        self.resize_start_geometry = None
        self.resize_start_pos = None

        self.min_width = 160
        self.min_height = 120
        self.max_width = 1920
        self.max_height = 1080

        # ╨У╨╗╨╛╨▒╨░╨╗╤М╨╜╤Л╨╡ ╨│╨╛╤А╤П╤З╨╕╨╡ ╨║╨╗╨░╨▓╨╕╤И╨╕
        self.hotkey_id_toggle = 1
        self._register_hotkeys()

        self.setMouseTracking(True)
        self.label.setMouseTracking(True)

        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
        self.customContextMenuRequested.connect(self.show_context_menu)

        self._splash_progress(95, "Almost ready...")
        self.update_background()
        print("ЁЯЪА MiniCamApp ╨╖╨░╨┐╤Г╤Й╨╡╨╜")

    # ---------- ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╤П ----------
    
    def get_text(self, key):
        """╨Я╨╛╨╗╤Г╤З╨╕╤В╤М ╨┐╨╡╤А╨╡╨▓╨╛╨┤ ╨┐╨╛ ╨║╨╗╤О╤З╤Г"""
        return TRANSLATIONS.get(self.current_language, TRANSLATIONS["ru"]).get(key, key)
    
    def save_config(self):
        """╨б╨╛╤Е╤А╨░╨╜╨╕╤В╤М ╤В╨╡╨║╤Г╤Й╨╕╨╡ ╨╜╨░╤Б╤В╤А╨╛╨╣╨║╨╕ ╨▓ ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╤О"""
        # ╨Ю╨▒╨╜╨╛╨▓╨╗╤П╨╡╨╝ ╨║╨╛╨╜╤Д╨╕╨│╤Г╤А╨░╤Ж╨╕╤О ╤В╨╡╨║╤Г╤Й╨╕╨╝╨╕ ╨╖╨╜╨░╤З╨╡╨╜╨╕╤П╨╝╨╕
        self.config["language"] = self.current_language
        
        self.config["window"] = {
            "x": self.x(),
            "y": self.y(),
            "width": self.width(),
            "height": self.height()
        }
        
        self.config["video"] = {
            "shape": self.video_shape,
            "flip_horizontal": self.flip_horizontal,
            "flip_vertical": self.flip_vertical
        }
        
        self.config["effects"] = {
            "face_tracking": {
                "enabled": self.face_tracking_enabled,
                "zoom_level": self.face_zoom_level
            },
            "background_blur": {
                "enabled": self.background_blur_enabled,
                "strength": self.blur_strength
            },
            "edge_blur": {
                "enabled": self.edge_blur_enabled,
                "width": self.edge_blur_width
            }
        }
        
        self.config["opacity"] = self.window_opacity
        
        # ╨б╨╛╤Е╤А╨░╨╜╤П╨╡╨╝ ╨▓ ╤Д╨░╨╣╨╗
        ConfigManager.save_config(self.config)

    # ---------- ╨▓╨╕╨┤╨╡╨╛ ----------
    
    def detect_face_and_calculate_crop(self, frame):
        """╨Ю╨┐╤А╨╡╨┤╨╡╨╗╨╕╤В╤М ╨╗╨╕╤Ж╨╛ ╨╕ ╨▓╤Л╤З╨╕╤Б╨╗╨╕╤В╤М ╨╛╨▒╨╗╨░╤Б╤В╤М ╨║╨░╨┤╤А╨╕╤А╨╛╨▓╨░╨╜╨╕╤П"""
        if not self.face_tracking_enabled or self.face_detector is None:
            return None
        
        # ╨Ю╨│╤А╨░╨╜╨╕╤З╨╡╨╜╨╕╨╡ ╤З╨░╤Б╤В╨╛╤В╤Л ╨┤╨╡╤В╨╡╨║╤Ж╨╕╨╕: ╨╖╨░╨┐╤Г╤Б╨║╨░╨╡╨╝ AI ╨╜╨╡ ╨╜╨░ ╨║╨░╨╢╨┤╨╛╨╝ ╨║╨░╨┤╤А╨╡
        self.face_detect_counter += 1
        if self.face_detect_counter < self.face_detect_interval:
            # ╨Ь╨╡╨╢╨┤╤Г ╨┤╨╡╤В╨╡╨║╤Ж╨╕╤П╨╝╨╕ тАФ ╨▓╨╛╨╖╨▓╤А╨░╤Й╨░╨╡╨╝ ╨┐╨╛╤Б╨╗╨╡╨┤╨╜╨╕╨╣ ╨╕╨╖╨▓╨╡╤Б╤В╨╜╤Л╨╣ ╤А╨╡╨╖╤Г╨╗╤М╤В╨░╤В
            return self.last_crop_info
        self.face_detect_counter = 0
        
        try:
            import time
            
            # ╨Ъ╨╛╨╜╨▓╨╡╤А╤В╨╕╤А╤Г╨╡╨╝ BGR -> RGB ╨┤╨╗╤П MediaPipe
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            
            # ╨б╨╛╨╖╨┤╨░╤С╨╝ MediaPipe Image
            mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=frame_rgb)
            
            # ╨Ю╨▒╨╜╨░╤А╤Г╨╢╨╕╨▓╨░╨╡╨╝ ╨╗╨╕╤Ж╨░
            detection_result = self.face_detector.detect(mp_image)
            
            frame_height, frame_width = frame.shape[:2]
            
            if detection_result.detections:
                # ╨С╨╡╤А╤С╨╝ ╨┐╨╡╤А╨▓╨╛╨╡ (╤Б╨░╨╝╨╛╨╡ ╤Г╨▓╨╡╤А╨╡╨╜╨╜╨╛╨╡) ╨╗╨╕╤Ж╨╛
                detection = detection_result.detections[0]
                bbox = detection.bounding_box
                
                # ╨Ъ╨╛╨╛╤А╨┤╨╕╨╜╨░╤В╤Л ╨╗╨╕╤Ж╨░
                x = bbox.origin_x
                y = bbox.origin_y
                w = bbox.width
                h = bbox.height
                
                # ╨ж╨╡╨╜╤В╤А ╨╗╨╕╤Ж╨░
                face_center_x = x + w / 2
                face_center_y = y + h / 2
                
                # ╨Т╤Л╤З╨╕╤Б╨╗╤П╨╡╨╝ ╤А╨░╨╖╨╝╨╡╤А ╨╛╨▒╨╗╨░╤Б╤В╨╕ ╨║╨░╨┤╤А╨╕╤А╨╛╨▓╨░╨╜╨╕╤П
                # ╨Ш╤Б╨┐╨╛╨╗╤М╨╖╤Г╨╡╨╝ face_zoom_level ╨┤╨╗╤П ╨╛╨┐╤А╨╡╨┤╨╡╨╗╨╡╨╜╨╕╤П ╨╝╨░╤Б╤И╤В╨░╨▒╨░
                face_size = max(w, h)
                target_scale = self.face_zoom_level
                
                # ╨ж╨╡╨╗╨╡╨▓╤Л╨╡ ╨║╨╛╨╛╤А╨┤╨╕╨╜╨░╤В╤Л ╨┤╨╗╤П ╨║╨░╨┤╤А╨╕╤А╨╛╨▓╨░╨╜╨╕╤П (╨╜╨╛╤А╨╝╨░╨╗╨╕╨╖╨╛╨▓╨░╨╜╨╜╤Л╨╡ 0-1)
                target_x = face_center_x / frame_width
                target_y = face_center_y / frame_height
                
                # Dead zone: ╨╕╨│╨╜╨╛╤А╨╕╤А╤Г╨╡╨╝ ╨╝╨╡╨╗╨║╨╕╨╡ ╤Б╨╝╨╡╤Й╨╡╨╜╨╕╤П (╤И╤Г╨╝ bounding box)
                dx = abs(target_x - self.crop_x)
                dy = abs(target_y - self.crop_y)
                if dx < self.face_deadzone and dy < self.face_deadzone:
                    # ╨б╨╝╨╡╤Й╨╡╨╜╨╕╨╡ ╤Б╨╗╨╕╤И╨║╨╛╨╝ ╨╝╨░╨╗╨╛ тАФ ╨╜╨╡ ╨╛╨▒╨╜╨╛╨▓╨╗╤П╨╡╨╝ ╤Ж╨╡╨╗╤М, ╨┐╤А╨╛╨┤╨╛╨╗╨╢╨░╨╡╨╝ ╤В╨╡╨║╤Г╤Й╤Г╤О
                    self.last_face_time = time.time()
                    return self.last_crop_info
                
                # ╨Ю╨▒╨╜╨╛╨▓╨╗╤П╨╡╨╝ ╨▓╤А╨╡╨╝╤П ╨┐╨╛╤Б╨╗╨╡╨┤╨╜╨╡╨│╨╛ ╨╛╨▒╨╜╨░╤А╤Г╨╢╨╡╨╜╨╕╤П
                self.last_face_time = time.time()
                
                crop_info = {
                    'target_x': target_x,
                    'target_y': target_y,
                    'target_scale': target_scale,
                    'face_detected': True
                }
                self.last_crop_info = crop_info
                return crop_info
            else:
                # ╨Ы╨╕╤Ж╨╛ ╨╜╨╡ ╨╜╨░╨╣╨┤╨╡╨╜╨╛ - ╨┐╤А╨╛╨▓╨╡╤А╤П╨╡╨╝ timeout
                current_time = time.time()
                if current_time - self.last_face_time > self.face_lost_timeout:
                    # ╨Т╨╛╨╖╨▓╤А╨░╤Й╨░╨╡╨╝╤Б╤П ╨║ ╨┐╨╛╨╗╨╜╨╛╨╝╤Г ╨║╨░╨┤╤А╤Г
                    crop_info = {
                        'target_x': 0.5,
                        'target_y': 0.5,
                        'target_scale': 1.0,
                        'face_detected': False
                    }
                    self.last_crop_info = crop_info
                    return crop_info
                # ╨Я╤А╨╛╨┤╨╛╨╗╨╢╨░╨╡╨╝ ╨┤╨╡╤А╨╢╨░╤В╤М ╨┐╨╛╤Б╨╗╨╡╨┤╨╜╤О╤О ╨┐╨╛╨╖╨╕╤Ж╨╕╤О
                return self.last_crop_info
        
        except Exception as e:
            print(f"╨Ю╤И╨╕╨▒╨║╨░ ╨╛╨┐╤А╨╡╨┤╨╡╨╗╨╡╨╜╨╕╤П ╨╗╨╕╤Ж╨░: {e}")
            return self.last_crop_info
    
    def apply_smooth_crop(self, frame, crop_info):
        """╨Я╤А╨╕╨╝╨╡╨╜╨╕╤В╤М ╨┐╨╗╨░╨▓╨╜╨╛╨╡ ╨║╨░╨┤╤А╨╕╤А╨╛╨▓╨░╨╜╨╕╨╡ ╨║ ╨║╨░╨┤╤А╤Г"""
        if crop_info is None:
            return frame
        
        frame_height, frame_width = frame.shape[:2]
        
        # ╨Я╨╗╨░╨▓╨╜╨╛ ╨┐╨╡╤А╨╡╤Е╨╛╨┤╨╕╨╝ ╨║ ╤Ж╨╡╨╗╨╡╨▓╤Л╨╝ ╨╖╨╜╨░╤З╨╡╨╜╨╕╤П╨╝
        self.crop_x += (crop_info['target_x'] - self.crop_x) * self.crop_smoothing
        self.crop_y += (crop_info['target_y'] - self.crop_y) * self.crop_smoothing
        self.crop_scale += (crop_info['target_scale'] - self.crop_scale) * self.crop_smoothing
        
        # ╨Т╤Л╤З╨╕╤Б╨╗╤П╨╡╨╝ ╤А╨░╨╖╨╝╨╡╤А ╨╛╨▒╨╗╨░╤Б╤В╨╕ ╨║╨░╨┤╤А╨╕╤А╨╛╨▓╨░╨╜╨╕╤П
        crop_width = int(frame_width / self.crop_scale)
        crop_height = int(frame_height / self.crop_scale)
        
        # ╨Т╤Л╤З╨╕╤Б╨╗╤П╨╡╨╝ ╨┐╨╛╨╖╨╕╤Ж╨╕╤О ╨║╨░╨┤╤А╨░ (╤Ж╨╡╨╜╤В╤А╨╕╤А╨╛╨▓╨░╨╜╨╜╤Г╤О ╨╜╨░ ╨╗╨╕╤Ж╨╡)
        x1 = int(self.crop_x * frame_width - crop_width / 2)
        y1 = int(self.crop_y * frame_height - crop_height / 2)
        
        # ╨Ю╨│╤А╨░╨╜╨╕╤З╨╕╨▓╨░╨╡╨╝ ╨║╨╛╨╛╤А╨┤╨╕╨╜╨░╤В╤Л
        x1 = max(0, min(x1, frame_width - crop_width))
        y1 = max(0, min(y1, frame_height - crop_height))
        x2 = x1 + crop_width
        y2 = y1 + crop_height
        
        # ╨Ъ╨░╨┤╤А╨╕╤А╤Г╨╡╨╝
        cropped = frame[y1:y2, x1:x2]
        
        # ╨Ш╨╖╨╝╨╡╨╜╤П╨╡╨╝ ╤А╨░╨╖╨╝╨╡╤А ╨╛╨▒╤А╨░╤В╨╜╨╛ ╨┤╨╛ ╨╛╤А╨╕╨│╨╕╨╜╨░╨╗╤М╨╜╨╛╨│╨╛
        result = cv2.resize(cropped, (frame_width, frame_height), interpolation=cv2.INTER_LINEAR)
        
        return result

    def update_frame(self):
        ret, frame = self.cap.read()
        if not ret or frame is None:
            return

        # ╨Ч╨╡╤А╨║╨░╨╗╨╕╤А╨╛╨▓╨░╨╜╨╕╨╡
        if self.flip_horizontal:
            frame = cv2.flip(frame, 1)
        if self.flip_vertical:
            frame = cv2.flip(frame, 0)
        
        # ╨Ю╤В╤Б╨╗╨╡╨╢╨╕╨▓╨░╨╜╨╕╨╡ ╨╗╨╕╤Ж╨░ ╨╕ ╨░╨▓╤В╨╛╨╝╨░╤В╨╕╤З╨╡╤Б╨║╨╛╨╡ ╨║╨░╨┤╤А╨╕╤А╨╛╨▓╨░╨╜╨╕╨╡
        if self.face_tracking_enabled:
            crop_info = self.detect_face_and_calculate_crop(frame)
            frame = self.apply_smooth_crop(frame, crop_info)

        # AI-╤Н╤Д╤Д╨╡╨║╤В: ╤А╨░╨╖╨╝╤Л╤В╨╕╨╡ ╤Д╨╛╨╜╨░
        if self.background_blur_enabled and self.segmentation is not None:
            frame = self.apply_background_blur(frame)

        # ╨Ъ╨╛╨╜╨▓╨╡╤А╤В╨░╤Ж╨╕╤П ╨▓ RGB
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        h, w, ch = frame.shape
        qimg = QImage(frame.data, w, h, ch * w, QImage.Format.Format_RGB888).copy()

        src = QPixmap.fromImage(qimg).scaled(
            self.label.width(),
            self.label.height(),
            Qt.AspectRatioMode.KeepAspectRatio,
            Qt.TransformationMode.SmoothTransformation
        )

        self.label.setPixmap(self.apply_shape(src))


    def apply_background_blur(self, frame):
        """╨Я╤А╨╕╨╝╨╡╨╜╨╕╤В╤М ╤А╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║ ╤Д╨╛╨╜╤Г"""
        try:
            # ╨Я╨╛╨╗╤Г╤З╨░╨╡╨╝ ╨╝╨░╤Б╨║╤Г ╤Б╨╡╨│╨╝╨╡╨╜╤В╨░╤Ж╨╕╨╕
            mask_3d = self.get_segmentation_mask(frame)
            if mask_3d is None:
                return frame
            
            # ╨б╨╛╨╖╨┤╨░╤С╨╝ ╤А╨░╨╖╨╝╤Л╤В╤Л╨╣ ╤Д╨╛╨╜
            blurred = cv2.GaussianBlur(frame, (self.blur_strength, self.blur_strength), 0)
            
            # ╨Ъ╨╛╨╝╨▒╨╕╨╜╨╕╤А╤Г╨╡╨╝: mask_3d=1 ╨┤╨╗╤П ╤Д╨╛╨╜╨░, 0 ╨┤╨╗╤П ╤З╨╡╨╗╨╛╨▓╨╡╨║╨░
            output = (frame * mask_3d + blurred * (1 - mask_3d)).astype(np.uint8)
            
            return output
        except Exception as e:
            print(f"╨Ю╤И╨╕╨▒╨║╨░ ╤А╨░╨╖╨╝╤Л╤В╨╕╤П ╤Д╨╛╨╜╨░: {e}")
            import traceback
            traceback.print_exc()
            return frame
    
    def get_segmentation_mask(self, frame):
        """╨Я╨╛╨╗╤Г╤З╨╕╤В╤М ╨╝╨░╤Б╨║╤Г ╤Б╨╡╨│╨╝╨╡╨╜╤В╨░╤Ж╨╕╨╕ ╤Б ╤Г╨╗╤Г╤З╤И╨╡╨╜╨╕╤П╨╝╨╕ (0 = ╤З╨╡╨╗╨╛╨▓╨╡╨║, 1 = ╤Д╨╛╨╜)"""
        try:
            # ╨Ъ╨╛╨╜╨▓╨╡╤А╤В╨╕╤А╤Г╨╡╨╝ BGR -> RGB ╨┤╨╗╤П MediaPipe
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            
            # ╨б╨╛╨╖╨┤╨░╤С╨╝ MediaPipe Image
            mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=frame_rgb)
            
            # ╨Я╨╛╨╗╤Г╤З╨░╨╡╨╝ ╨╝╨░╤Б╨║╤Г ╤Б╨╡╨│╨╝╨╡╨╜╤В╨░╤Ж╨╕╨╕
            segmentation_result = self.segmentation.segment(mp_image)
            
            # ╨Ш╨╖╨▓╨╗╨╡╨║╨░╨╡╨╝ ╨╝╨░╤Б╨║╤Г ╨║╨░╤В╨╡╨│╨╛╤А╨╕╨╣
            category_mask = segmentation_result.category_mask
            mask = category_mask.numpy_view()
            
            # ╨г╨▒╨╕╤А╨░╨╡╨╝ ╨╗╨╕╤И╨╜╨╕╨╡ ╤А╨░╨╖╨╝╨╡╤А╨╜╨╛╤Б╤В╨╕
            mask = np.squeeze(mask)
            
            # ╨Т MediaPipe: 0 = ╤Д╨╛╨╜, 1+ = ╤З╨╡╨╗╨╛╨▓╨╡╨║
            # ╨Ш╤Б╨┐╨╛╨╗╤М╨╖╤Г╨╡╨╝ ╤А╨░╨▒╨╛╤З╤Г╤О ╤Д╨╛╤А╨╝╤Г╨╗╤Г: (mask == 0) ╨┤╨░╤С╤В ╤Д╨╛╨╜ = 1, ╤З╨╡╨╗╨╛╨▓╨╡╨║ = 0
            binary_mask = (mask == 0).astype(np.float32)
            
            # === ╨г╨Ы╨г╨з╨и╨Х╨Э╨Ш╨Х 1: Bilateral Filter (╤Г╨▒╨╕╤А╨░╨╡╤В ╨▒╨╗╨╛╤З╨╜╨╛╤Б╤В╤М) ===
            # ╨б╨│╨╗╨░╨╢╨╕╨▓╨░╨╡╤В "╨▒╨╡╨│╨░╤О╤Й╨╕╨╡ ╨▒╨╗╨╛╨║╨╕", ╤Б╨╛╤Е╤А╨░╨╜╤П╤П ╨│╤А╨░╨╜╨╕╤Ж╤Л
            binary_mask_8bit = (binary_mask * 255).astype(np.uint8)
            binary_mask_8bit = cv2.bilateralFilter(binary_mask_8bit, d=5, sigmaColor=50, sigmaSpace=50)
            binary_mask = binary_mask_8bit.astype(np.float32) / 255.0
            
            # === ╨г╨Ы╨г╨з╨и╨Х╨Э╨Ш╨Х 2: Feathering (╤А╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║╤А╨░╤С╨▓) ===
            # ╨Ь╤П╨│╨║╨╕╨╡ ╨║╤А╨░╤П ╨┤╨╗╤П ╨╡╤Б╤В╨╡╤Б╤В╨▓╨╡╨╜╨╜╨╛╨│╨╛ ╨┐╨╡╤А╨╡╤Е╨╛╨┤╨░
            binary_mask = cv2.GaussianBlur(binary_mask, (self.mask_blur_kernel, self.mask_blur_kernel), 0)
            
            # === ╨г╨Ы╨г╨з╨и╨Х╨Э╨Ш╨Х 3: Temporal Smoothing (╤Б╨│╨╗╨░╨╢╨╕╨▓╨░╨╜╨╕╨╡ ╨┐╨╛ ╨▓╤А╨╡╨╝╨╡╨╜╨╕) ===
            # ╨г╨▒╨╕╤А╨░╨╡╤В ╨┤╤А╨╛╨╢╨░╨╜╨╕╨╡ ╨╝╨░╤Б╨║╨╕
            if self.previous_mask is not None and self.previous_mask.shape == binary_mask.shape:
                # ╨г╤Б╤А╨╡╨┤╨╜╤П╨╡╨╝ ╤Б ╨┐╤А╨╡╨┤╤Л╨┤╤Г╤Й╨╡╨╣ ╨╝╨░╤Б╨║╨╛╨╣
                binary_mask = (self.temporal_weight * binary_mask + 
                             (1 - self.temporal_weight) * self.previous_mask)
            
            # ╨б╨╛╤Е╤А╨░╨╜╤П╨╡╨╝ ╨┤╨╗╤П ╤Б╨╗╨╡╨┤╤Г╤О╤Й╨╡╨│╨╛ ╨║╨░╨┤╤А╨░
            self.previous_mask = binary_mask.copy()
            
            # ╨б╨╛╨╖╨┤╨░╤С╨╝ 3-╨║╨░╨╜╨░╨╗╤М╨╜╤Г╤О ╨╝╨░╤Б╨║╤Г
            mask_3d = np.stack([binary_mask] * 3, axis=-1)
            
            return mask_3d
        except Exception as e:
            print(f"╨Ю╤И╨╕╨▒╨║╨░ ╨┐╨╛╨╗╤Г╤З╨╡╨╜╨╕╤П ╨╝╨░╤Б╨║╨╕: {e}")
            return None
    

    def apply_shape(self, pixmap: QPixmap) -> QPixmap:
        result = QPixmap(pixmap.size())
        result.fill(Qt.GlobalColor.transparent)

        painter = QPainter(result)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)

        path = QPainterPath()
        rect = QRectF(0, 0, pixmap.width(), pixmap.height())

        if self.video_shape == "circle":
            r = min(rect.width(), rect.height())
            rect = QRectF(
                (pixmap.width() - r) / 2,
                (pixmap.height() - r) / 2,
                r, r
            )
            path.addEllipse(rect)

        elif self.video_shape == "rounded":
            radius = min(self.corner_radius, rect.width() / 2, rect.height() / 2)
            path.addRoundedRect(rect, radius, radius)

        else:
            path.addRect(rect)

        painter.setClipPath(path)
        painter.drawPixmap(0, 0, pixmap)
        painter.end()

        if self.edge_blur_enabled:
            result = self.apply_edge_blur(result)

        return result

    def apply_edge_blur(self, pixmap: QPixmap) -> QPixmap:
        """╨Я╤А╨╕╨╝╨╡╨╜╨╕╤В╤М ╤А╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║ ╨║╤А╨░╤П╨╝ ╨╕╨╖╨╛╨▒╤А╨░╨╢╨╡╨╜╨╕╤П"""
        w = pixmap.width()
        h = pixmap.height()
        blur_width = min(self.edge_blur_width, w // 4, h // 4)
        
        mask = QPixmap(pixmap.size())
        mask.fill(Qt.GlobalColor.transparent)
        
        mask_painter = QPainter(mask)
        mask_painter.setRenderHint(QPainter.RenderHint.Antialiasing)
        mask_painter.setPen(Qt.PenStyle.NoPen)
        
        if self.video_shape == "circle":
            r = min(w, h)
            center = QPointF(w / 2, h / 2)
            radius = r / 2
            
            inner_ratio = max(0.7, 1 - blur_width / radius)
            
            gradient = QRadialGradient(center, radius)
            gradient.setColorAt(0.0, QColor(255, 255, 255, 255))
            gradient.setColorAt(inner_ratio, QColor(255, 255, 255, 255))
            gradient.setColorAt(1.0, QColor(255, 255, 255, 0))
            
            mask_painter.setBrush(QBrush(gradient))
            mask_painter.drawEllipse(QRectF((w - r) / 2, (h - r) / 2, r, r))
        
        elif self.video_shape == "rounded":
            radius = min(self.corner_radius, w / 2, h / 2)
            
            inner_rect = QRectF(blur_width, blur_width, 
                               w - 2 * blur_width, h - 2 * blur_width)
            inner_path = QPainterPath()
            inner_path.addRoundedRect(inner_rect, max(0, radius - blur_width), max(0, radius - blur_width))
            
            mask_painter.setBrush(QBrush(QColor(255, 255, 255, 255)))
            mask_painter.drawPath(inner_path)
            
            outer_rect = QRectF(0, 0, w, h)
            outer_path = QPainterPath()
            outer_path.addRoundedRect(outer_rect, radius, radius)
            
            ring_path = QPainterPath()
            ring_path.addPath(outer_path)
            ring_path = ring_path.subtracted(inner_path)
            
            mask_painter.setClipPath(ring_path)
            
            steps = 20
            for i in range(steps):
                alpha = int(255 * (1 - i / steps))
                expand = blur_width * i / steps
                
                temp_rect = QRectF(blur_width - expand, blur_width - expand,
                                  w - 2 * (blur_width - expand), h - 2 * (blur_width - expand))
                temp_path = QPainterPath()
                temp_path.addRoundedRect(temp_rect, max(0, radius - blur_width + expand), 
                                        max(0, radius - blur_width + expand))
                
                mask_painter.setBrush(QBrush(QColor(255, 255, 255, alpha)))
                mask_painter.drawPath(temp_path)
        
        else:
            inner_rect = QRectF(blur_width, blur_width, 
                               w - 2 * blur_width, h - 2 * blur_width)
            inner_path = QPainterPath()
            inner_path.addRect(inner_rect)
            
            mask_painter.setBrush(QBrush(QColor(255, 255, 255, 255)))
            mask_painter.drawPath(inner_path)
            
            outer_rect = QRectF(0, 0, w, h)
            outer_path = QPainterPath()
            outer_path.addRect(outer_rect)
            
            ring_path = QPainterPath()
            ring_path.addPath(outer_path)
            ring_path = ring_path.subtracted(inner_path)
            
            mask_painter.setClipPath(ring_path)
            
            steps = 20
            for i in range(steps):
                alpha = int(255 * (1 - i / steps))
                expand = blur_width * i / steps
                
                temp_rect = QRectF(blur_width - expand, blur_width - expand,
                                  w - 2 * (blur_width - expand), h - 2 * (blur_width - expand))
                temp_path = QPainterPath()
                temp_path.addRect(temp_rect)
                
                mask_painter.setBrush(QBrush(QColor(255, 255, 255, alpha)))
                mask_painter.drawPath(temp_path)
        
        mask_painter.end()
        
        result = QPixmap(pixmap.size())
        result.fill(Qt.GlobalColor.transparent)
        
        result_painter = QPainter(result)
        result_painter.setRenderHint(QPainter.RenderHint.Antialiasing)
        result_painter.drawPixmap(0, 0, pixmap)
        result_painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_DestinationIn)
        result_painter.drawPixmap(0, 0, mask)
        result_painter.end()
        
        return result

    # ---------- ╨╝╨╡╨╜╤О ----------

    def show_context_menu(self, pos):
        menu = QMenu(self)

        # ╨д╨╛╤А╨╝╨░ ╨▓╨╕╨┤╨╡╨╛
        shape_menu = menu.addMenu(self.get_text("video_shape"))

        rect = QAction(self.get_text("rectangle"), self, checkable=True)
        rect.setChecked(self.video_shape == "rectangle")
        rect.triggered.connect(lambda: self.set_video_shape("rectangle"))

        rounded = QAction(self.get_text("rounded_rectangle"), self, checkable=True)
        rounded.setChecked(self.video_shape == "rounded")
        rounded.triggered.connect(lambda: self.set_video_shape("rounded"))

        circle = QAction(self.get_text("circle"), self, checkable=True)
        circle.setChecked(self.video_shape == "circle")
        circle.triggered.connect(lambda: self.set_video_shape("circle"))

        shape_menu.addActions([rect, rounded, circle])

        menu.addSeparator()

        # ╨Ч╨╡╤А╨║╨░╨╗╨╕╤А╨╛╨▓╨░╨╜╨╕╨╡
        flip_h = QAction(self.get_text("flip_horizontal"), self, checkable=True)
        flip_h.setChecked(self.flip_horizontal)
        flip_h.triggered.connect(self.toggle_flip_horizontal)

        flip_v = QAction(self.get_text("flip_vertical"), self, checkable=True)
        flip_v.setChecked(self.flip_vertical)
        flip_v.triggered.connect(self.toggle_flip_vertical)

        menu.addAction(flip_h)
        menu.addAction(flip_v)

        menu.addSeparator()

        # AI-╤Н╤Д╤Д╨╡╨║╤В╤Л ╨╕ ╤А╨░╨╖╨╝╤Л╤В╨╕╨╡
        if MEDIAPIPE_AVAILABLE:
            # ╨Ю╤В╤Б╨╗╨╡╨╢╨╕╨▓╨░╨╜╨╕╨╡ ╨╗╨╕╤Ж╨░ - ╨┐╨╛╨┤╨╝╨╡╨╜╤О ╤Б ╨╜╨░╤Б╤В╤А╨╛╨╣╨║╨░╨╝╨╕
            if self.face_detector is not None:
                face_zoom_menu = menu.addMenu(self.get_text("face_tracking"))
                
                zoom_off = QAction(self.get_text("disabled"), self, checkable=True)
                zoom_off.setChecked(not self.face_tracking_enabled)
                zoom_off.triggered.connect(lambda: self.set_face_zoom(None))
                
                zoom_very_far = QAction(self.get_text("very_far"), self, checkable=True)
                zoom_very_far.setChecked(self.face_tracking_enabled and abs(self.face_zoom_level - 1.2) < 0.1)
                zoom_very_far.triggered.connect(lambda: self.set_face_zoom(1.2))
                
                zoom_far = QAction(self.get_text("far"), self, checkable=True)
                zoom_far.setChecked(self.face_tracking_enabled and abs(self.face_zoom_level - 1.4) < 0.1)
                zoom_far.triggered.connect(lambda: self.set_face_zoom(1.4))
                
                zoom_medium = QAction(self.get_text("medium"), self, checkable=True)
                zoom_medium.setChecked(self.face_tracking_enabled and abs(self.face_zoom_level - 1.8) < 0.1)
                zoom_medium.triggered.connect(lambda: self.set_face_zoom(1.8))
                
                zoom_close = QAction(self.get_text("close"), self, checkable=True)
                zoom_close.setChecked(self.face_tracking_enabled and abs(self.face_zoom_level - 2.5) < 0.1)
                zoom_close.triggered.connect(lambda: self.set_face_zoom(2.5))
                
                face_zoom_menu.addActions([zoom_off, zoom_very_far, zoom_far, zoom_medium, zoom_close])
            
            # ╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╤Д╨╛╨╜╨░ - ╨┐╨╛╨┤╨╝╨╡╨╜╤О ╤Б ╨╜╨░╤Б╤В╤А╨╛╨╣╨║╨░╨╝╨╕
            blur_strength_menu = menu.addMenu(self.get_text("background_blur"))
            
            blur_off = QAction(self.get_text("disabled"), self, checkable=True)
            blur_off.setChecked(not self.background_blur_enabled)
            blur_off.triggered.connect(lambda: self.set_blur_strength(None))
            
            blur_weak = QAction(self.get_text("weak"), self, checkable=True)
            blur_weak.setChecked(self.background_blur_enabled and self.blur_strength == 15)
            blur_weak.triggered.connect(lambda: self.set_blur_strength(15))
            
            blur_medium = QAction(self.get_text("medium"), self, checkable=True)
            blur_medium.setChecked(self.background_blur_enabled and self.blur_strength == 25)
            blur_medium.triggered.connect(lambda: self.set_blur_strength(25))
            
            blur_strong = QAction(self.get_text("strong"), self, checkable=True)
            blur_strong.setChecked(self.background_blur_enabled and self.blur_strength == 45)
            blur_strong.triggered.connect(lambda: self.set_blur_strength(45))
            
            blur_very_strong = QAction(self.get_text("very_strong"), self, checkable=True)
            blur_very_strong.setChecked(self.background_blur_enabled and self.blur_strength == 65)
            blur_very_strong.triggered.connect(lambda: self.set_blur_strength(65))
            
            blur_strength_menu.addActions([blur_off, blur_weak, blur_medium, blur_strong, blur_very_strong])
        
        # ╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║╤А╨░╤С╨▓ - ╨┐╨╛╨┤╨╝╨╡╨╜╤О ╤Б ╨╜╨░╤Б╤В╤А╨╛╨╣╨║╨░╨╝╨╕
        edge_width_menu = menu.addMenu(self.get_text("edge_blur"))
        
        edge_off = QAction(self.get_text("disabled"), self, checkable=True)
        edge_off.setChecked(not self.edge_blur_enabled)
        edge_off.triggered.connect(lambda: self.set_edge_blur_width(None))
        
        edge_narrow = QAction(self.get_text("narrow"), self, checkable=True)
        edge_narrow.setChecked(self.edge_blur_enabled and self.edge_blur_width == 15)
        edge_narrow.triggered.connect(lambda: self.set_edge_blur_width(15))
        
        edge_medium = QAction(self.get_text("medium"), self, checkable=True)
        edge_medium.setChecked(self.edge_blur_enabled and self.edge_blur_width == 30)
        edge_medium.triggered.connect(lambda: self.set_edge_blur_width(30))
        
        edge_wide = QAction(self.get_text("wide"), self, checkable=True)
        edge_wide.setChecked(self.edge_blur_enabled and self.edge_blur_width == 50)
        edge_wide.triggered.connect(lambda: self.set_edge_blur_width(50))
        
        edge_very_wide = QAction(self.get_text("very_wide"), self, checkable=True)
        edge_very_wide.setChecked(self.edge_blur_enabled and self.edge_blur_width == 70)
        edge_very_wide.triggered.connect(lambda: self.set_edge_blur_width(70))
        
        edge_width_menu.addActions([edge_off, edge_narrow, edge_medium, edge_wide, edge_very_wide])

        menu.addSeparator()
        
        # ╨Я╤А╨╛╨╖╤А╨░╤З╨╜╨╛╤Б╤В╤М ╨╛╨║╨╜╨░
        opacity_menu = menu.addMenu(self.get_text("opacity"))
        
        op_100 = QAction(self.get_text("opacity_100"), self, checkable=True)
        op_100.setChecked(abs(self.window_opacity - 1.0) < 0.05)
        op_100.triggered.connect(lambda: self.set_opacity(1.0))
        
        op_75 = QAction(self.get_text("opacity_75"), self, checkable=True)
        op_75.setChecked(abs(self.window_opacity - 0.75) < 0.05)
        op_75.triggered.connect(lambda: self.set_opacity(0.75))
        
        op_50 = QAction(self.get_text("opacity_50"), self, checkable=True)
        op_50.setChecked(abs(self.window_opacity - 0.5) < 0.05)
        op_50.triggered.connect(lambda: self.set_opacity(0.5))
        
        op_25 = QAction(self.get_text("opacity_25"), self, checkable=True)
        op_25.setChecked(abs(self.window_opacity - 0.25) < 0.05)
        op_25.triggered.connect(lambda: self.set_opacity(0.25))
        
        opacity_menu.addActions([op_100, op_75, op_50, op_25])

        menu.addSeparator()
        
        # ╨п╨╖╤Л╨║ - ╨╜╨╛╨▓╤Л╨╣ ╨┐╤Г╨╜╨║╤В ╨╝╨╡╨╜╤О
        language_menu = menu.addMenu(self.get_text("language"))
        
        lang_en = QAction(self.get_text("lang_english"), self, checkable=True)
        lang_en.setChecked(self.current_language == "en")
        lang_en.triggered.connect(lambda: self.set_language("en"))
        
        lang_ru = QAction(self.get_text("lang_russian"), self, checkable=True)
        lang_ru.setChecked(self.current_language == "ru")
        lang_ru.triggered.connect(lambda: self.set_language("ru"))
        
        language_menu.addActions([lang_en, lang_ru])
        
        menu.addSeparator()
        menu.addAction(self.get_text("exit"), self.close)

        menu.exec(self.mapToGlobal(pos))

    # ---------- ╨╗╨╛╨│╨╕╨║╨░ ----------

    def set_video_shape(self, shape):
        self.video_shape = shape
        self.update_background()
        self.save_config()

    def toggle_flip_horizontal(self):
        self.flip_horizontal = not self.flip_horizontal
        self.save_config()

    def toggle_flip_vertical(self):
        self.flip_vertical = not self.flip_vertical
        self.save_config()
    
    def set_language(self, lang_code):
        """╨г╤Б╤В╨░╨╜╨╛╨▓╨╕╤В╤М ╤П╨╖╤Л╨║ ╨╕╨╜╤В╨╡╤А╤Д╨╡╨╣╤Б╨░"""
        self.current_language = lang_code
        self.save_config()
        print(f"ЁЯМН Language changed to: {lang_code}")
        # ╨Ь╨╡╨╜╤О ╨░╨▓╤В╨╛╨╝╨░╤В╨╕╤З╨╡╤Б╨║╨╕ ╨╛╨▒╨╜╨╛╨▓╨╕╤В╤Б╤П ╨┐╤А╨╕ ╤Б╨╗╨╡╨┤╤Г╤О╤Й╨╡╨╝ ╨╛╤В╨║╤А╤Л╤В╨╕╨╕

    def set_opacity(self, value):
        """╨г╤Б╤В╨░╨╜╨╛╨▓╨╕╤В╤М ╨┐╤А╨╛╨╖╤А╨░╤З╨╜╨╛╤Б╤В╤М ╨╛╨║╨╜╨░ (0.0 - 1.0)"""
        self.window_opacity = value
        self.setWindowOpacity(value)
        self.save_config()
        print(f"ЁЯФН ╨Я╤А╨╛╨╖╤А╨░╤З╨╜╨╛╤Б╤В╤М: {int(value * 100)}%")

    def set_face_zoom(self, level):
        """╨г╤Б╤В╨░╨╜╨╛╨▓╨╕╤В╤М ╤Г╤А╨╛╨▓╨╡╨╜╤М ╨┐╤А╨╕╨▒╨╗╨╕╨╢╨╡╨╜╨╕╤П ╨╗╨╕╤Ж╨░ (None = ╨▓╤Л╨║╨╗╤О╤З╨╕╤В╤М)"""
        if level is None:
            # ╨Т╤Л╨║╨╗╤О╤З╨░╨╡╨╝ ╨╛╤В╤Б╨╗╨╡╨╢╨╕╨▓╨░╨╜╨╕╨╡
            self.face_tracking_enabled = False
            print("ЁЯСБя╕П ╨Ю╤В╤Б╨╗╨╡╨╢╨╕╨▓╨░╨╜╨╕╨╡ ╨╗╨╕╤Ж╨░: ╨▓╤Л╨║╨╗╤О╤З╨╡╨╜╨╛")
        else:
            # ╨Т╨║╨╗╤О╤З╨░╨╡╨╝ ╨╛╤В╤Б╨╗╨╡╨╢╨╕╨▓╨░╨╜╨╕╨╡ ╨╕ ╤Г╤Б╤В╨░╨╜╨░╨▓╨╗╨╕╨▓╨░╨╡╨╝ ╨╖╤Г╨╝
            if not self.face_tracking_enabled:
                import time
                self.last_face_time = time.time()
                self.crop_x = 0.5
                self.crop_y = 0.5
                self.crop_scale = 1.0
                self.face_detect_counter = 0
                self.last_crop_info = None
            self.face_tracking_enabled = True
            self.face_zoom_level = level
            print(f"ЁЯСБя╕П ╨Ю╤В╤Б╨╗╨╡╨╢╨╕╨▓╨░╨╜╨╕╨╡ ╨╗╨╕╤Ж╨░: ╨▓╨║╨╗╤О╤З╨╡╨╜╨╛, ╨╖╤Г╨╝ {level}x")
        
        self.save_config()
    
    def set_blur_strength(self, strength):
        """╨г╤Б╤В╨░╨╜╨╛╨▓╨╕╤В╤М ╤Б╨╕╨╗╤Г ╤А╨░╨╖╨╝╤Л╤В╨╕╤П ╤Д╨╛╨╜╨░ (None = ╨▓╤Л╨║╨╗╤О╤З╨╕╤В╤М)"""
        if strength is None:
            # ╨Т╤Л╨║╨╗╤О╤З╨░╨╡╨╝ ╤А╨░╨╖╨╝╤Л╤В╨╕╨╡ ╤Д╨╛╨╜╨░
            self.background_blur_enabled = False
            print("ЁЯОи ╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╤Д╨╛╨╜╨░: ╨▓╤Л╨║╨╗╤О╤З╨╡╨╜╨╛")
        else:
            # ╨Т╨║╨╗╤О╤З╨░╨╡╨╝ ╤А╨░╨╖╨╝╤Л╤В╨╕╨╡ ╤Д╨╛╨╜╨░ ╨╕ ╤Г╤Б╤В╨░╨╜╨░╨▓╨╗╨╕╨▓╨░╨╡╨╝ ╤Б╨╕╨╗╤Г
            # ╨г╨▒╨╡╨┤╨╕╨╝╤Б╤П ╤З╤В╨╛ ╨╖╨╜╨░╤З╨╡╨╜╨╕╨╡ ╨╜╨╡╤З╤С╤В╨╜╨╛╨╡ (╤В╤А╨╡╨▒╨╛╨▓╨░╨╜╨╕╨╡ GaussianBlur)
            if strength % 2 == 0:
                strength += 1
            self.background_blur_enabled = True
            self.blur_strength = strength
            print(f"ЁЯОи ╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╤Д╨╛╨╜╨░: ╨▓╨║╨╗╤О╤З╨╡╨╜╨╛, ╤Б╨╕╨╗╨░ {strength}")
        
        self.save_config()
    
    def set_edge_blur_width(self, width):
        """╨г╤Б╤В╨░╨╜╨╛╨▓╨╕╤В╤М ╤И╨╕╤А╨╕╨╜╤Г ╤А╨░╨╖╨╝╤Л╤В╨╕╤П ╨║╤А╨░╤С╨▓ (None = ╨▓╤Л╨║╨╗╤О╤З╨╕╤В╤М)"""
        if width is None:
            # ╨Т╤Л╨║╨╗╤О╤З╨░╨╡╨╝ ╤А╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║╤А╨░╤С╨▓
            self.edge_blur_enabled = False
            print("ЁЯФ▓ ╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║╤А╨░╤С╨▓: ╨▓╤Л╨║╨╗╤О╤З╨╡╨╜╨╛")
        else:
            # ╨Т╨║╨╗╤О╤З╨░╨╡╨╝ ╤А╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║╤А╨░╤С╨▓ ╨╕ ╤Г╤Б╤В╨░╨╜╨░╨▓╨╗╨╕╨▓╨░╨╡╨╝ ╤И╨╕╤А╨╕╨╜╤Г
            self.edge_blur_enabled = True
            self.edge_blur_width = width
            print(f"ЁЯФ▓ ╨а╨░╨╖╨╝╤Л╤В╨╕╨╡ ╨║╤А╨░╤С╨▓: ╨▓╨║╨╗╤О╤З╨╡╨╜╨╛, ╤И╨╕╤А╨╕╨╜╨░ {width}px")
        
        self.save_config()

    def update_background(self):
        self.label.setStyleSheet("background-color: transparent;")

    # ---------- ╨╝╤Л╤И╤М ----------

    def mousePressEvent(self, event: QMouseEvent):
        if event.button() == Qt.MouseButton.LeftButton:
            pos = event.position()
            x, y = pos.x(), pos.y()

            if self.width() - x <= self.resize_margin and self.height() - y <= self.resize_margin:
                self.resizing = True
                self.resize_start_geometry = self.geometry()
                self.resize_start_pos = event.globalPosition().toPoint()
            else:
                self.offset = event.globalPosition().toPoint() - self.pos()

    def mouseMoveEvent(self, event: QMouseEvent):
        pos = event.position()
        x, y = pos.x(), pos.y()

        if not self.resizing and self.offset is None:
            if self.width() - x <= self.resize_margin and self.height() - y <= self.resize_margin:
                self.setCursor(Qt.CursorShape.SizeFDiagCursor)
            else:
                self.setCursor(Qt.CursorShape.ArrowCursor)

        if self.resizing:
            delta = event.globalPosition().toPoint() - self.resize_start_pos
            new_w = max(self.min_width, self.resize_start_geometry.width() + delta.x())
            new_h = int(new_w / self.video_ratio)

            if new_h < self.min_height:
                new_h = self.min_height
                new_w = int(new_h * self.video_ratio)

            self.resize(new_w, new_h)
            self.label.resize(new_w, new_h)

        elif self.offset:
            self.move(event.globalPosition().toPoint() - self.offset)

    def mouseReleaseEvent(self, event):
        self.offset = None
        self.resizing = False
        self.setCursor(Qt.CursorShape.ArrowCursor)
        # ╨б╨╛╤Е╤А╨░╨╜╤П╨╡╨╝ ╨┐╨╛╨╖╨╕╤Ж╨╕╤О/╤А╨░╨╖╨╝╨╡╤А ╨┐╤А╨╕ ╨╖╨░╨▓╨╡╤А╤И╨╡╨╜╨╕╨╕ ╨┐╨╡╤А╨╡╨╝╨╡╤Й╨╡╨╜╨╕╤П/╨╕╨╖╨╝╨╡╨╜╨╡╨╜╨╕╤П ╤А╨░╨╖╨╝╨╡╤А╨░
        self.save_config()

    def wheelEvent(self, event: QWheelEvent):
        delta = event.angleDelta().y()
        
        if delta > 0:
            scale_factor = 1.1
        else:
            scale_factor = 0.9
        
        current_width = self.width()
        current_height = self.height()
        
        new_width = int(current_width * scale_factor)
        new_height = int(new_width / self.video_ratio)
        
        if new_width < self.min_width or new_height < self.min_height:
            new_height = self.min_height
            new_width = int(new_height * self.video_ratio)
        
        if new_width > self.max_width or new_height > self.max_height:
            new_width = min(new_width, self.max_width)
            new_height = int(new_width / self.video_ratio)
            if new_height > self.max_height:
                new_height = self.max_height
                new_width = int(new_height * self.video_ratio)
        
        if new_width != current_width or new_height != current_height:
            old_center = self.geometry().center()
            
            self.resize(new_width, new_height)
            self.label.resize(new_width, new_height)
            
            new_rect = self.geometry()
            new_rect.moveCenter(old_center)
            self.move(new_rect.topLeft())
            
            # ╨б╨╛╤Е╤А╨░╨╜╤П╨╡╨╝ ╤А╨░╨╖╨╝╨╡╤А ╨┐╤А╨╕ ╨╝╨░╤Б╤И╤В╨░╨▒╨╕╤А╨╛╨▓╨░╨╜╨╕╨╕ ╨║╨╛╨╗╨╡╤Б╨╛╨╝
            self.save_config()
        
        event.accept()

    def showEvent(self, event):
        super().showEvent(event)
        # Win32: ╨┐╤А╨╕╨╝╨╡╨╜╤П╨╡╨╝ NOACTIVATE ╨┐╨╛╤Б╨╗╨╡ ╨┐╨╛╨║╨░╨╖╨░ ╨╛╨║╨╜╨░ (winId() ╨┤╨╛╤Б╤В╤Г╨┐╨╡╨╜ ╤В╨╛╨╗╤М╨║╨╛ ╨╖╨┤╨╡╤Б╤М)
        self._apply_win32_noactivate()
        # ╨в╨░╨╣╨╝╨╡╤А ╨┐╨╡╤А╨╡╤Г╤В╨▓╨╡╤А╨╢╨┤╨╡╨╜╨╕╤П TOPMOST ╨║╨░╨╢╨┤╤Л╨╡ 500╨╝╤Б
        self.topmost_timer = QTimer(self)
        self.topmost_timer.timeout.connect(self._reassert_topmost)
        self.topmost_timer.start(500)

    def resizeEvent(self, event):
        super().resizeEvent(event)

    def closeEvent(self, event):
        # ╨Ю╤В╨╝╨╡╨╜╨░ ╤А╨╡╨│╨╕╤Б╤В╤А╨░╤Ж╨╕╨╕ ╨│╨╛╤А╤П╤З╨╕╤Е ╨║╨╗╨░╨▓╨╕╤И
        ctypes.windll.user32.UnregisterHotKey(None, self.hotkey_id_toggle)
        
        # ╨д╨╕╨╜╨░╨╗╤М╨╜╨╛╨╡ ╤Б╨╛╤Е╤А╨░╨╜╨╡╨╜╨╕╨╡ ╨┐╤А╨╕ ╨╖╨░╨║╤А╤Л╤В╨╕╨╕
        self.save_config()
        print("ЁЯТ╛ ╨Э╨░╤Б╤В╤А╨╛╨╣╨║╨╕ ╤Б╨╛╤Е╤А╨░╨╜╨╡╨╜╤Л")
        
        self.timer.stop()
        self.topmost_timer.stop()
        self.cap.release()
        # MediaPipe Tasks API ╨╜╨╡ ╤В╤А╨╡╨▒╤Г╨╡╤В ╤П╨▓╨╜╨╛╨│╨╛ ╨╖╨░╨║╤А╤Л╤В╨╕╤П
        super().closeEvent(event)

    def _register_hotkeys(self):
        """╨а╨╡╨│╨╕╤Б╤В╤А╨░╤Ж╨╕╤П ╨│╨╗╨╛╨▒╨░╨╗╤М╨╜╤Л╤Е ╨│╨╛╤А╤П╤З╨╕╤Е ╨║╨╗╨░╨▓╨╕╤И"""
        MOD_CONTROL = 0x0002
        MOD_ALT = 0x0001
        MOD_NOREPEAT = 0x4000
        VK_C = 0x43  # ╨║╨╗╨░╨▓╨╕╤И╨░ 'C'
        
        result = ctypes.windll.user32.RegisterHotKey(
            None, self.hotkey_id_toggle,
            MOD_CONTROL | MOD_ALT | MOD_NOREPEAT, VK_C
        )
        
        if result:
            print("тМия╕П ╨У╨╛╤А╤П╤З╨░╤П ╨║╨╗╨░╨▓╨╕╤И╨░: Ctrl+Alt+C (╨┐╨╛╨║╨░╨╖╨░╤В╤М/╤Б╨║╤А╤Л╤В╤М)")
        else:
            print("тЪая╕П ╨Э╨╡ ╤Г╨┤╨░╨╗╨╛╤Б╤М ╨╖╨░╤А╨╡╨│╨╕╤Б╤В╤А╨╕╤А╨╛╨▓╨░╤В╤М Ctrl+Alt+C (╨▓╨╛╨╖╨╝╨╛╨╢╨╜╨╛, ╤Г╨╢╨╡ ╨╕╤Б╨┐╨╛╨╗╤М╨╖╤Г╨╡╤В╤Б╤П)")
        
        # ╨д╨╕╨╗╤М╤В╤А ╨╜╨░ ╤Г╤А╨╛╨▓╨╜╨╡ ╨┐╤А╨╕╨╗╨╛╨╢╨╡╨╜╨╕╤П (╤А╨░╨▒╨╛╤В╨░╨╡╤В ╨┤╨░╨╢╨╡ ╨║╨╛╨│╨┤╨░ ╨╛╨║╨╜╨╛ ╤Б╨║╤А╤Л╤В╨╛)
        self.hotkey_filter = HotkeyFilter(self._on_hotkey)
        QApplication.instance().installNativeEventFilter(self.hotkey_filter)

    def _on_hotkey(self, hotkey_id):
        """╨Ю╨▒╤А╨░╨▒╨╛╤В╨║╨░ ╨╜╨░╨╢╨░╤В╨╕╤П ╨│╨╛╤А╤П╤З╨╡╨╣ ╨║╨╗╨░╨▓╨╕╤И╨╕"""
        if hotkey_id == self.hotkey_id_toggle:
            self.toggle_visibility()

    def toggle_visibility(self):
        """╨Я╨╛╨║╨░╨╖╨░╤В╤М/╤Б╨║╤А╤Л╤В╤М ╨╛╨║╨╜╨╛ ╨║╨░╨╝╨╡╤А╤Л"""
        if self.isVisible():
            self.hide()
            print("ЁЯСБя╕П ╨Ъ╨░╨╝╨╡╤А╨░ ╤Б╨║╤А╤Л╤В╨░ (Ctrl+Alt+C)")
        else:
            self.show()
            print("ЁЯСБя╕П ╨Ъ╨░╨╝╨╡╤А╨░ ╨┐╨╛╨║╨░╨╖╨░╨╜╨░ (Ctrl+Alt+C)")


class SplashScreen(QSplashScreen):
    """Simple splash screen shown while the app is loading"""

    def __init__(self):
        # Create the splash pixmap
        w, h = 400, 220
        pixmap = QPixmap(w, h)

        painter = QPainter(pixmap)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)

        # Background - dark rounded rect
        painter.setPen(Qt.PenStyle.NoPen)
        painter.setBrush(QBrush(QColor(28, 28, 35)))
        painter.drawRect(0, 0, w, h)

        # Accent bar at top
        painter.setBrush(QBrush(QColor(70, 130, 220)))
        painter.drawRect(0, 0, w, 4)

        # Title
        font = QFont("Segoe UI", 22, QFont.Weight.Bold)
        painter.setFont(font)
        painter.setPen(QColor(255, 255, 255))
        painter.drawText(QRectF(0, 30, w, 60), Qt.AlignmentFlag.AlignHCenter, "MiniCamApp")

        # Subtitle
        font.setPointSize(10)
        font.setWeight(QFont.Weight.Normal)
        painter.setFont(font)
        painter.setPen(QColor(140, 150, 170))
        painter.drawText(QRectF(0, 80, w, 30), Qt.AlignmentFlag.AlignHCenter, "AI Webcam Overlay")

        # Status text placeholder (will be updated via showMessage)
        painter.end()

        super().__init__(pixmap)
        self.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint)

        # Progress bar geometry
        self._progress = 0
        self._base_pixmap = pixmap

    def set_progress(self, value: int, message: str):
        """Update progress bar (0-100) and status message"""
        self._progress = value
        w, h = self._base_pixmap.width(), self._base_pixmap.height()

        pixmap = QPixmap(self._base_pixmap)
        painter = QPainter(pixmap)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)

        # Clear status area
        painter.setPen(Qt.PenStyle.NoPen)
        painter.setBrush(QBrush(QColor(28, 28, 35)))
        painter.drawRect(0, 130, w, h - 130)

        # Progress bar track
        bar_x, bar_y, bar_w, bar_h = 40, 145, w - 80, 6
        painter.setBrush(QBrush(QColor(50, 55, 70)))
        painter.drawRoundedRect(bar_x, bar_y, bar_w, bar_h, 3, 3)

        # Progress bar fill
        fill_w = int(bar_w * value / 100)
        if fill_w > 0:
            painter.setBrush(QBrush(QColor(70, 130, 220)))
            painter.drawRoundedRect(bar_x, bar_y, fill_w, bar_h, 3, 3)

        # Percentage
        font = QFont("Segoe UI", 9)
        painter.setFont(font)
        painter.setPen(QColor(70, 130, 220))
        painter.drawText(QRectF(0, 158, w, 20), Qt.AlignmentFlag.AlignHCenter, f"{value}%")

        # Status message
        painter.setPen(QColor(140, 150, 170))
        painter.drawText(QRectF(0, 180, w, 25), Qt.AlignmentFlag.AlignHCenter, message)

        painter.end()
        self.setPixmap(pixmap)
        QApplication.processEvents()


if __name__ == "__main__":
    app = QApplication(sys.argv)

    # Show splash screen
    splash = SplashScreen()
    splash.show()
    QApplication.processEvents()

    splash.set_progress(10, "Initializing...")
    window = VideoWindow(splash)

    splash.set_progress(100, "Ready!")
    window.show()
    splash.finish(window)

    sys.exit(app.exec())