Модели детекции и тракинга лиц

from ultralytics import YOLO
import cv2

# Загружаем модель
model = YOLO('yolov8n-face.pt')

# Обрабатываем одиночное изображение
results = model('path/to/your/image.jpg')

# Обрабатываем видеопоток
cap = cv2.VideoCapture(0)
while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    results = model(frame)
    annotated_frame = results[0].plot()
    cv2.imshow('Face Detection', annotated_frame)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import mediapipe as mp
import cv2

# Инициализируем MediaPipe Face Detection один раз
mp_face_detection = mp.solutions.face_detection
mp_drawing = mp.solutions.drawing_utils

cap = cv2.VideoCapture(0)

# Используем оператор 'with' вне цикла для правильного управления ресурсами
with mp_face_detection.FaceDetection(
    model_selection=0, min_detection_confidence=0.5) as face_detection:

    while cap.isOpened():
        success, image = cap.read()
        if not success:
            print("Игнорируем пустой кадр с камеры.")
            continue

        # Для улучшения производительности, опционально помечаем изображение как нередактируемое
        # для передачи по ссылке.
        image.flags.writeable = False
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        results = face_detection.process(image)

        # Рисуем аннотации детекции лиц на изображении.
        image.flags.writeable = True
        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
        if results.detections:
            for detection in results.detections:
                mp_drawing.draw_detection(image, detection)
        
        cv2.imshow('MediaPipe Face Detection', image)
        if cv2.waitKey(5) & 0xFF == 27:  # ESC key
            break

cap.release()
cv2.destroyAllWindows()

from retinaface import RetinaFace
import cv2
import numpy as np

def detect_faces_retinaface(image_path):
    # Детекция RetinaFace
    faces = RetinaFace.detect_faces(image_path)
    
    if isinstance(faces, dict):
        image = cv2.imread(image_path)
        
        for key in faces.keys():
            face = faces[key]
            facial_area = face["facial_area"]
            
            # Рисуем ограничивающий прямоугольник
            cv2.rectangle(image, 
                         (facial_area[0], facial_area[1]), 
                         (facial_area[2], facial_area[3]), 
                         (0, 255, 0), 2)
            
            # Добавляем показатель уверенности
            confidence = face.get("score", 0)
            cv2.putText(image, f'{confidence:.2f}', 
                       (facial_area[0], facial_area[1]-10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
        
        return image
    
    return None

# Использование
result_image = detect_faces_retinaface('path/to/image.jpg')
if result_image is not None:
    cv2.imshow('RetinaFace Detection', result_image)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

import cv2
from yolox.tracker.byte_tracker import BYTETracker
from ultralytics import YOLO

class VideoTracker:
    def __init__(self):
        self.model = YOLO('yolov8n-face.pt')
        self.tracker = BYTETracker(frame_rate=30)
    
    def track_video(self, video_path):
        cap = cv2.VideoCapture(video_path)
        frame_id = 0
        
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            
            # Детекция
            results = self.model(frame)
            
            # Конвертируем в формат для отслеживания
            detections = []
            if len(results[0].boxes) > 0:
                boxes = results[0].boxes.xyxy.cpu().numpy()
                scores = results[0].boxes.conf.cpu().numpy()
                
                for box, score in zip(boxes, scores):
                    detections.append([*box, score])
            
            # Обновляем трекер
            tracks = self.tracker.update(
                np.array(detections), 
                frame.shape[:2], 
                frame.shape[:2]
            )
            
            # Рисуем треки
            for track in tracks:
                x1, y1, x2, y2, track_id = track[:5]
                cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
                cv2.putText(frame, f'ID: {int(track_id)}', 
                           (int(x1), int(y1)-10),
                           cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
            
            cv2.imshow('Face Tracking', frame)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
            
            frame_id += 1
        
        cap.release()
        cv2.destroyAllWindows()

# Использование
tracker = VideoTracker()
tracker.track_video('path/to/video.mp4')

# Реализация детектора лиц для мобильных устройств.
import mediapipe as mp
import cv2
import numpy as np
import time

class MobileFaceDetector:
    """
    Класс для детекции лиц в видеопотоке, оптимизированный для
    производительности на мобильных устройствах.

    Включает в себя пропуск кадров для достижения целевого FPS и плавную
    отрисовку рамок, чтобы избежать "мерцания".
    """
    def __init__(self, model_selection=0, min_detection_confidence=0.7):
        """
        Инициализирует детектор лиц.

        Args:
            model_selection (int): Выбор модели. 0 для ближнего радиуса (до 2 метров),
                                   1 для дальнего (до 5 метров).
            min_detection_confidence (float): Минимальный порог уверенности для детекции.
        """
        # --- Инициализация MediaPipe Face Detection ---
        # Создаем экземпляр с заданными параметрами.
        self.face_detection = mp.solutions.face_detection.FaceDetection(
            model_selection=model_selection,
            min_detection_confidence=min_detection_confidence,
        )
        
        # --- Переменные для отрисовки и FPS ---
        # Храним последние успешные детекции, чтобы рисовать их на пропущенных кадрах.
        self.last_results = None
        # Сохраняем исходные размеры кадра для корректного масштабирования.
        self.original_width = 0
        self.original_height = 0

    def _draw_detections(self, frame, detections):
        """
        Вспомогательная функция для отрисовки рамок на кадре.
        
        Args:
            frame (np.ndarray): Кадр, на котором нужно рисовать.
            detections: Результаты детекции от MediaPipe.
        """
        if detections:
            for detection in detections:
                # Получаем относительные координаты рамки (от 0.0 до 1.0).
                bboxC = detection.location_data.relative_bounding_box
                
                # Масштабируем координаты обратно к исходному размеру кадра.
                x = int(bboxC.xmin * self.original_width)
                y = int(bboxC.ymin * self.original_height)
                width = int(bboxC.width * self.original_width)
                height = int(bboxC.height * self.original_height)
                
                # Рисуем прямоугольник на оригинальном кадре.
                cv2.rectangle(frame, (x, y), (x + width, y + height), (0, 255, 0), 2)
        return frame

    def process_frame(self, frame, target_width=320):
        """
        Обрабатывает один кадр из видеопотока.

        Args:
            frame (np.ndarray): Входной кадр в формате BGR.
            target_width (int): Целевая ширина для обработки. Кадр будет
                                пропорционально уменьшен до этой ширины.

        Returns:
            np.ndarray: Кадр с нарисованными рамками.
        """
        self.original_height, self.original_width = frame.shape[:2]

        # --- Оптимизация 1: Уменьшение разрешения ---
        # Сохраняем соотношение сторон.
        scale = target_width / self.original_width
        small_frame = cv2.resize(frame, (0, 0), fx=scale, fy=scale, interpolation=cv2.INTER_AREA)

        # --- Оптимизация 2: Конвертация цвета и повышение производительности ---
        # MediaPipe требует RGB. Конвертируем один раз.
        rgb_small_frame = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)
        # Помечаем кадр как "только для чтения" для ускорения.
        rgb_small_frame.flags.writeable = False

        # --- Детекция лиц ---
        results = self.face_detection.process(rgb_small_frame)
        
        # Восстанавливаем флаг, если нужно будет еще работать с кадром.
        rgb_small_frame.flags.writeable = True

        # --- Отрисовка ---
        # Если детекция была успешной, сохраняем результаты.
        if results.detections:
            self.last_results = results.detections
        
        # Рисуем рамки на исходном кадре. Если в текущем кадре лиц не найдено,
        # но они были в предыдущих, используем старые данные для плавности.
        processed_frame = self._draw_detections(frame, self.last_results)
        
        return processed_frame
        
    def close(self):
        """Освобождает ресурсы MediaPipe."""
        self.face_detection.close()

# --- Пример использования с веб-камерой ---
if __name__ == '__main__':
    # Инициализируем детектор
    detector = MobileFaceDetector(min_detection_confidence=0.5)
    
    # Захватываем видео с веб-камеры (0 - обычно встроенная камера)
    cap = cv2.VideoCapture(0)
    
    if not cap.isOpened():
        print("Ошибка: не удалось открыть веб-камеру.")
        exit()

    # Переменные для расчета FPS
    prev_frame_time = 0
    new_frame_time = 0

    try:
        while True:
            # Читаем кадр с камеры
            success, frame = cap.read()
            if not success:
                print("Не удалось получить кадр. Завершение работы.")
                break

            # Переворачиваем кадр для эффекта "зеркала"
            frame = cv2.flip(frame, 1)

            # --- Пропускаем обработку для достижения целевого FPS ---
            # Это менее важно с новой логикой отрисовки, но все еще экономит ресурсы
            # Здесь можно реализовать вашу логику пропуска кадров, если требуется
            
            # Обрабатываем кадр
            processed_frame = detector.process_frame(frame)

            # --- Расчет и отображение FPS ---
            new_frame_time = time.time()
            fps = 1 / (new_frame_time - prev_frame_time)
            prev_frame_time = new_frame_time
            cv2.putText(processed_frame, f'FPS: {int(fps)}', (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            
            # Показываем результат
            cv2.imshow('Mobile Face Detection', processed_frame)

            # Выход по нажатию клавиши 'q'
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
    finally:
        # Освобождаем ресурсы
        print("Освобождение ресурсов...")
        cap.release()
        detector.close()
        cv2.destroyAllWindows()

# Система безопасности с трекингом, верификацией,
# оптимизированным распознаванием и визуализацией.
import cv2
import numpy as np
import time
import os
import pickle
from typing import Dict, List, Any, Optional, Tuple

# --- Предполагается, что эти библиотеки установлены ---
# pip install opencv-python numpy
# pip install insightface
# pip install retinaface-pytorch deep-sort-realtime
#
# Важно: InsightFace требует onnxruntime-gpu. DeepSort также имеет свои зависимости.
# Установка может потребовать дополнительных шагов, включая загрузку моделей.

from retinaface import RetinaFace
from deep_sort_realtime.deepsort_tracker import DeepSort
from insightface.app import FaceAnalysis

class AdvancedSecuritySystem:
    """
    Комплексная система безопасности, объединяющая детекцию, трекинг и
    распознавание лиц с оптимизациями для реального времени.
    """

    def __init__(self, db_path: str, detection_thresh: float = 0.9, recognition_thresh: float = 0.5):
        """
        Инициализация всех компонентов системы.

        Args:
            db_path (str): Путь к файлу базы данных лиц (.pkl).
            detection_thresh (float): Порог уверенности для детектора лиц.
            recognition_thresh (float): Порог сходства для распознавания лиц.
        """
        print("Инициализация системы безопасности...")

        # --- Детектор лиц (RetinaFace) ---
        # RetinaFace хорошо подходит для обнаружения "сложных" лиц.
        # Для CPU можно использовать 'mobilenet', для GPU - 'resnet50'.
        self.detector = RetinaFace(gpu_id=0) # Укажите -1 для использования CPU
        print("Детектор лиц (RetinaFace) инициализирован.")

        # --- Трекер (DeepSort) ---
        # max_age: сколько кадров трек может существовать без детекции.
        # n_init: сколько раз объект должен быть детектирован для старта трекинга.
        self.tracker = DeepSort(max_age=30, n_init=3)
        print("Трекер (DeepSort) инициализирован.")

        # --- Распознаватель лиц (InsightFace) ---
        # Используем CUDA для максимальной производительности.
        self.recognizer = FaceAnalysis(name='buffalo_l', providers=['CUDAExecutionProvider'])
        self.recognizer.prepare(ctx_id=0) # ctx_id=0 для GPU, -1 для CPU
        print("Распознаватель лиц (InsightFace) инициализирован.")
        
        # --- Параметры и база данных ---
        self.detection_thresh = detection_thresh
        self.recognition_thresh = recognition_thresh
        self.face_db = self._load_face_database(db_path)
        
        # Словарь для хранения уже распознанных личностей по track_id
        # {track_id: {"identity": "Name", "verified": True/False}}
        self.tracked_identities: Dict[str, Dict[str, Any]] = {}

    def _load_face_database(self, db_path: str) -> Optional[Dict[str, np.ndarray]]:
        """Загружает предварительно созданную базу данных эмбеддингов."""
        if not os.path.exists(db_path):
            print(f"Ошибка: Файл базы данных не найден по пути: {db_path}")
            print("Пожалуйста, сначала создайте базу данных с помощью create_database_from_folder().")
            return None
        with open(db_path, 'rb') as f:
            db = pickle.load(f)
            print(f"База данных лиц успешно загружена. Найдено {len(db)} личностей.")
            return db

    def _extract_embedding(self, frame: np.ndarray, bbox: np.ndarray) -> Optional[np.ndarray]:
        """Извлекает эмбеддинг (вектор признаков) из области лица."""
        # Безопасно вырезаем лицо, обрезая координаты по границам кадра
        h, w = frame.shape[:2]
        x1, y1, x2, y2 = np.maximum(0, bbox).astype(int)
        x2, y2 = min(x2, w), min(y2, h)
        
        face_img = frame[y1:y2, x1:x2]
        if face_img.size == 0:
            return None
            
        # Используем InsightFace для получения эмбеддинга
        faces = self.recognizer.get(face_img)
        return faces[0].embedding if faces else None

    def _find_match(self, embedding: np.ndarray) -> Tuple[str, float]:
        """Находит наиболее похожее лицо в базе данных."""
        if embedding is None or self.face_db is None:
            return "Unknown", 0.0
            
        best_match = "Unknown"
        best_score = 0.0
        
        # Используем косинусное сходство (скалярное произведение нормализованных векторов)
        for name, db_embed in self.face_db.items():
            score = np.dot(embedding, db_embed) / (np.linalg.norm(embedding) * np.linalg.norm(db_embed))
            if score > self.recognition_thresh and score > best_score:
                best_score = score
                best_match = name
                
        return best_match, best_score

    def process_frame(self, frame: np.ndarray) -> np.ndarray:
        """
        Полный цикл обработки одного кадра: детекция, трекинг, распознавание.

        Returns:
            np.ndarray: Кадр с нарисованной информацией (рамки, ID, имена).
        """
        if self.face_db is None:
            cv2.putText(frame, "Face DB not loaded!", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
            return frame
            
        # --- 1. Детекция ---
        # RetinaFace возвращает словарь, который нужно преобразовать
        detections_raw = self.detector.detect(frame, threshold=self.detection_thresh)
        
        # Конвертация в формат, понятный для DeepSort: [[x1, y1, x2, y2], confidence]
        deepsort_detections = []
        for face_data in detections_raw:
            x1, y1, x2, y2, conf = face_data
            deepsort_detections.append(([x1, y1, x2, y2], conf, "face"))

        # --- 2. Трекинг ---
        tracks = self.tracker.update_tracks(deepsort_detections, frame=frame)
        
        # --- 3. Распознавание и Визуализация ---
        for track in tracks:
            if not track.is_confirmed():
                continue
            
            track_id = track.track_id
            bbox = track.to_tlbr() # (x1, y1, x2, y2)
            
            identity_info = self.tracked_identities.get(track_id)
            
            # ОПТИМИЗАЦИЯ: Распознаем только новые треки
            if identity_info is None:
                embedding = self._extract_embedding(frame, bbox)
                name, score = self._find_match(embedding)
                self.tracked_identities[track_id] = {"identity": name, "score": score}
                identity_info = self.tracked_identities[track_id]

            # --- Визуализация ---
            name = identity_info.get("identity", "Unknown")
            score = identity_info.get("score", 0.0)
            
            color = (0, 255, 0) if name != "Unknown" else (0, 0, 255)
            # Рисуем рамку
            cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), color, 2)
            # Формируем текст для подписи
            label = f"ID: {track_id} | {name} ({score:.2f})"
            # Рисуем подпись
            cv2.putText(frame, label, (int(bbox[0]), int(bbox[1]) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
            
        return frame

    def create_database_from_folder(self, folder_path: str, output_db_path: str):
        """
        Создает базу данных эмбеддингов из папки с изображениями.
        Структура папки:
        - folder_path/
          - person_1/
            - image1.jpg
            - image2.png
          - person_2/
            - photo.jpg
        """
        face_db = {}
        print(f"Создание базы данных из папки: {folder_path}")
        for person_name in os.listdir(folder_path):
            person_folder = os.path.join(folder_path, person_name)
            if not os.path.isdir(person_folder):
                continue
            
            embeddings = []
            for image_name in os.listdir(person_folder):
                image_path = os.path.join(person_folder, image_name)
                img = cv2.imread(image_path)
                if img is None:
                    continue
                
                # Получаем эмбеддинг для первого найденного лица на фото
                faces = self.recognizer.get(img)
                if faces:
                    embeddings.append(faces[0].embedding)
            
            if embeddings:
                # Усредняем эмбеддинги для большей устойчивости
                face_db[person_name] = np.mean(embeddings, axis=0)
                print(f"-> Найдено и обработано лицо: {person_name}")

        # Сохраняем базу в файл
        with open(output_db_path, 'wb') as f:
            pickle.dump(face_db, f)
        print(f"База данных успешно создана и сохранена в: {output_db_path}")

# --- Пример использования ---
if __name__ == '__main__':
    DB_FILE = "face_db.pkl"
    DB_SOURCE_FOLDER = "face_images" # Папка с фото для создания БД
    
    # --- Шаг 1: Создание базы данных (выполняется один раз) ---
    # Для этого шага нужно создать папку face_images и в ней подпапки с именами
    # людей, содержащие их фотографии.
    if not os.path.exists(DB_FILE):
        print("База данных не найдена. Запуск процесса создания...")
        # Создаем временную папку для примера, если ее нет
        if not os.path.exists(DB_SOURCE_FOLDER):
            os.makedirs(os.path.join(DB_SOURCE_FOLDER, "person_example"))
            print(f"Создана папка для примера: {DB_SOURCE_FOLDER}/person_example")
            print("Пожалуйста, поместите туда файлы .jpg с лицами и перезапустите скрипт.")
            exit()
            
        # Инициализируем систему только для создания БД
        temp_system = AdvancedSecuritySystem(db_path=DB_FILE)
        temp_system.create_database_from_folder(DB_SOURCE_FOLDER, DB_FILE)
        print("-" * 30)

    # --- Шаг 2: Запуск системы на видеопотоке ---
    system = AdvancedSecuritySystem(db_path=DB_FILE)
    cap = cv2.VideoCapture(0) # 0 для веб-камеры или путь к видеофайлу

    if not cap.isOpened():
        print("Ошибка: не удалось открыть видеопоток.")
        exit()

    prev_time = 0
    try:
        while True:
            success, frame = cap.read()
            if not success:
                break
            
            # Обработка кадра
            processed_frame = system.process_frame(frame)

            # Расчет и отображение FPS
            curr_time = time.time()
            fps = 1 / (curr_time - prev_time)
            prev_time = curr_time
            cv2.putText(processed_frame, f"FPS: {int(fps)}", (20, 80), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            
            cv2.imshow("Advanced Security System", processed_frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
    finally:
        print("Завершение работы и освобождение ресурсов.")
        cap.release()
        cv2.destroyAllWindows()

# Реализация детекции и трекинга лиц для Edge-устройств
# с использованием TensorFlow Lite.

import cv2
import numpy as np
import time
import argparse
from typing import List, Dict, Any, Tuple, Optional

# Для работы этого скрипта требуется tflite_runtime.
# Установка: pip install tflite-runtime
try:
    from tflite_runtime.interpreter import Interpreter
except ImportError:
    print("Ошибка: tflite_runtime не найден. Пожалуйста, установите его:")
    print("pip install tflite-runtime")
    exit()

class EdgeFacePipeline:
    """
    Класс для детекции и трекинга лиц на Edge-устройствах с использованием TFLite.
    Включает аппаратные оптимизации и легковесный IOU-трекер.
    """
    def __init__(self, model_path: str, device: str = 'cpu', conf_thresh: float = 0.7):
        """
        Инициализация пайплайна.

        Args:
            model_path (str): Путь к файлу модели .tflite.
            device (str): Устройство для выполнения ('cpu' или 'npu').
            conf_thresh (float): Порог уверенности для детекции лиц.
        """
        print(f"Загрузка TFLite модели из: {model_path}")
        self.interpreter = Interpreter(model_path=model_path)
        self.interpreter.allocate_tensors()

        self.input_details = self.interpreter.get_input_details()
        self.output_details = self.interpreter.get_output_details()
        
        # Важно: получаем точные размеры, которые требует модель
        self.input_height = self.input_details[0]['shape'][1]
        self.input_width = self.input_details[0]['shape'][2]

        self.conf_thresh = conf_thresh
        self.tracked_faces: List[Dict[str, Any]] = []
        self.next_track_id = 0
        self.iou_thresh = 0.4 # Порог IOU для трекинга

        self._configure_device(device)
        print(f"Пайплайн инициализирован для устройства: {device}")

    def _configure_device(self, device: str):
        """Применяет аппаратно-специфичные оптимизации."""
        cv2.setUseOptimized(True)
        # Настройки для нейропроцессора (NPU)
        if device == 'npu':
            # Здесь могут быть специфичные делегаты для NPU, например, 'libedgetpu.so.1'
            # self.interpreter = Interpreter(model_path=self.model_path,
            #                                experimental_delegates=[load_delegate('libedgetpu.so.1')])
            self.interpreter.set_num_threads(1)
            print("Оптимизации для NPU применены (упрощенная конфигурация).")
        # Оптимизации для CPU
        else:
            self.interpreter.set_num_threads(4)
            print("Оптимизации для CPU применены (4 потока).")

    def _preprocess(self, frame: np.ndarray) -> np.ndarray:
        """
        Подготовка кадра для нейросети: изменение размера и нормализация.
        """
        # Ресайз к точному размеру входа модели ---
        resized_frame = cv2.resize(frame, (self.input_width, self.input_height))
        
        # Преобразование в RGB, если модель этого требует
        rgb_frame = cv2.cvtColor(resized_frame, cv2.COLOR_BGR2RGB)
        
        # Нормализация и добавление batch-измерения
        # Многие модели TFLite ожидают float32 в диапазоне [-1, 1] или [0, 1]
        # или uint8 [0, 255]. Проверяйте документацию к вашей модели.
        # Здесь мы предполагаем float32 [0, 1].
        input_data = np.expand_dims(rgb_frame, axis=0).astype(np.float32) / 255.0
        return input_data

    def process_frame(self, frame: np.ndarray) -> List[Dict[str, Any]]:
        """
        Полный цикл обработки: детекция и трекинг.

        Args:
            frame (np.ndarray): Входной кадр в формате BGR.

        Returns:
            List[Dict[str, Any]]: Список отслеживаемых лиц с их ID и координатами.
        """
        original_h, original_w = frame.shape[:2]
        
        # 1. Предобработка кадра
        input_data = self._preprocess(frame)
        
        # 2. Инференс модели
        self.interpreter.set_tensor(self.input_details[0]['index'], input_data)
        self.interpreter.invoke()
        
        # 3. Получение и постобработка результатов
        # Формат выхода может отличаться для разных моделей.
        # Предполагаем, что модель возвращает [boxes, scores].
        boxes = self.interpreter.get_tensor(self.output_details[0]['index'])[0]
        scores = self.interpreter.get_tensor(self.output_details[1]['index'])[0]

        current_detections = []
        for i, score in enumerate(scores):
            if score > self.conf_thresh:
                # Координаты возвращаются в нормализованном виде [ymin, xmin, ymax, xmax]
                ymin, xmin, ymax, xmax = boxes[i]
                
                # Масштабирование координат к исходному размеру кадра
                abs_xmin = int(xmin * original_w)
                abs_ymin = int(ymin * original_h)
                abs_xmax = int(xmax * original_w)
                abs_ymax = int(ymax * original_h)
                
                current_detections.append({
                    'bbox': (abs_xmin, abs_ymin, abs_xmax, abs_ymax),
                    'score': float(score)
                })
        
        # 4. Обновление трекера
        self._update_tracker(current_detections)
        return self.tracked_faces

    def _update_tracker(self, new_detections: List[Dict[str, Any]]):
        """Обновляет треки на основе новых детекций, используя IOU."""
        if not self.tracked_faces:
            # Если треков нет, инициализируем их из новых детекций
            for det in new_detections:
                det['track_id'] = self.next_track_id
                det['age'] = 0 # Счётчик "возраста" трека
                self.tracked_faces.append(det)
                self.next_track_id += 1
            return

        matched_indices = set()
        
        # Попытка сопоставить новые детекции с существующими треками
        for i, track in enumerate(self.tracked_faces):
            best_match_iou = 0
            best_match_idx = -1
            for j, det in enumerate(new_detections):
                if j in matched_indices:
                    continue
                iou = self._calculate_iou(track['bbox'], det['bbox'])
                if iou > self.iou_thresh and iou > best_match_iou:
                    best_match_iou = iou
                    best_match_idx = j
            
            if best_match_idx != -1:
                # Обновляем трек
                track['bbox'] = new_detections[best_match_idx]['bbox']
                track['age'] = 0 # Сбрасываем возраст, т.к. трек найден
                matched_indices.add(best_match_idx)
            else:
                # Увеличиваем возраст, если трек не найден
                track['age'] += 1

        # Добавляем новые треки для не сопоставленных детекций
        for j, det in enumerate(new_detections):
            if j not in matched_indices:
                det['track_id'] = self.next_track_id
                det['age'] = 0
                self.tracked_faces.append(det)
                self.next_track_id += 1
        
        # Удаляем старые треки, которые не были видны некоторое время
        self.tracked_faces = [t for t in self.tracked_faces if t['age'] < 15]

    @staticmethod
    def _calculate_iou(box1: Tuple, box2: Tuple) -> float:
        """Вычисляет Intersection over Union (IOU) для двух рамок."""
        x1, y1, x2, y2 = box1
        x3, y3, x4, y4 = box2
        
        xi1, yi1 = max(x1, x3), max(y1, y3)
        xi2, yi2 = min(x2, x4), min(y2, y4)
        
        inter_area = max(0, xi2 - xi1) * max(0, yi2 - yi1)
        box1_area = (x2 - x1) * (y2 - y1)
        box2_area = (x4 - x3) * (y4 - y3)
        
        union_area = box1_area + box2_area - inter_area
        return inter_area / union_area if union_area > 0 else 0.0

def draw_results(frame: np.ndarray, faces: List[Dict[str, Any]]):
    """Отрисовывает результаты на кадре."""
    for face in faces:
        # Используем координаты для отрисовки
        xmin, ymin, xmax, ymax = face['bbox']
        track_id = face['track_id']
        
        cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2)
        label = f"ID: {track_id}"
        cv2.putText(frame, label, (xmin, ymin - 10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)

# Пример использования
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Face Detection on Edge Devices")
    parser.add_argument("--model", type=str, required=True, help="Path to the .tflite model file.")
    parser.add_argument("--device", type=str, default='cpu', choices=['cpu', 'npu'], help="Device to run inference on.")
    parser.add_argument("--video", type=str, help="Path to video file. If not provided, uses webcam.")
    args = parser.parse_args()

    pipeline = EdgeFacePipeline(model_path=args.model, device=args.device)
    
    cap = cv2.VideoCapture(args.video if args.video else 0)
    if not cap.isOpened():
        print(f"Ошибка: не удалось открыть видеоисточник.")
        exit()
        
    prev_time = 0
    try:
        while True:
            ret, frame = cap.read()
            if not ret:
                break
                
            # Обработка кадра
            tracked_faces = pipeline.process_frame(frame)
            
            # Визуализация результатов
            draw_results(frame, tracked_faces)
            
            # Отображение FPS
            curr_time = time.time()
            fps = 1 / (curr_time - prev_time)
            prev_time = curr_time
            cv2.putText(frame, f"FPS: {int(fps)}", (10, 30),
                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
            
            cv2.imshow('Edge Face Detection', frame)
            
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
    finally:
        print("Завершение работы и освобождение ресурсов.")
        cap.release()
        cv2.destroyAllWindows()

# Создание виртуального окружения
python -m venv face_detection_env
source face_detection_env/bin/activate

# Базовые зависимости
pip install opencv-python mediapipe ultralytics

# Для продвинутых моделей
pip install insightface retinaface-pytorch deepface

# Для трекинга
pip install yolox filterpy scikit-image

import gc
import torch

def optimize_gpu_memory():
    """Очистка GPU памяти после обработки"""
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
        gc.collect()

def batch_processing(image_list, model, batch_size=4):
    """Пакетная обработка для оптимизации пропускной способности"""
    results = []
    
    for i in range(0, len(image_list), batch_size):
        batch = image_list[i:i+batch_size]
        batch_results = model(batch)
        results.extend(batch_results)
        
        # Очистка памяти после каждого батча
        optimize_gpu_memory()
    
    return results

import threading
from queue import Queue
import time

class ThreadedVideoProcessor:
    def __init__(self, model):
        self.model = model
        self.frame_queue = Queue(maxsize=10)
        self.result_queue = Queue(maxsize=10)
        self.processing = True
        
    def frame_reader(self, video_source):
        cap = cv2.VideoCapture(video_source)
        while self.processing:
            ret, frame = cap.read()
            if not ret:
                break
            
            if not self.frame_queue.full():
                self.frame_queue.put(frame)
        cap.release()
    
    def frame_processor(self):
        while self.processing:
            if not self.frame_queue.empty():
                frame = self.frame_queue.get()
                result = self.model(frame)
                
                if not self.result_queue.full():
                    self.result_queue.put((frame, result))

# Пример: фреймворк тестирования предвзятости
def evaluate_model_bias(model, test_datasets):
    """
    Оценка производительности модели по демографическим группам
    """
    results = {}
    
    for group_name, dataset in test_datasets.items():
        detections = []
        for image_path in dataset['images']:
            result = model(image_path)
            detections.append(result)
        
        # Вычисляем метрики для этой демографической группы
        accuracy = calculate_accuracy(detections, dataset['ground_truth'])
        results[group_name] = {
            'accuracy': accuracy,
            'sample_size': len(dataset['images'])
        }
    
    return results

# Пример использования
demographic_results = evaluate_model_bias(model, {
    'young': young_adult_dataset,
    'elderly': elderly_dataset,
    'diverse': diverse_dataset
})

class ConsentAwareFaceTracker:
    def __init__(self):
        self.user_consent = self.check_user_consent()
        self.tracking_enabled = False
        
    def check_user_consent(self):
        # Проверяем сохраненные пользовательские предпочтения
        # Возвращаем статус согласия и временную метку
        pass
    
    def request_consent(self):
        """
        Представляем четкий диалог согласия пользователю
        """
        consent_text = """
        Это приложение использует детекцию лиц для:
        - Улучшения твоего опыта с AR фильтрами
        - Автоматической фокусировки камеры на лицах
        
        Твои данные лица:
        - Обрабатываются полностью на твоем устройстве
        - Никогда не сохраняются и не передаются
        - Могут быть отключены в любое время в настройках
        
        Согласен ли ты на детекцию лиц? [Да/Нет]
        """
        return self.present_consent_dialog(consent_text)
    
    def process_with_consent(self, frame):
        if not self.user_consent['granted']:
            return frame  # Возвращаем необработанный кадр
        
        if self.consent_expired():
            self.user_consent = self.request_consent()
        
        return self.detect_faces(frame) if self.user_consent['granted'] else frame