Python и OpenCV для распознавания и обнаружения лиц

# Пример загрузки и использования каскадного классификатора в OpenCV
import cv2
 
# Загружаем каскад Хаара для лиц из встроенных в OpenCV
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
 
# Функция для обнаружения лиц на изображении
def detect_faces(image_path):
    # Загружаем изображение
    image = cv2.imread(image_path)
    # Конвертируем в оттенки серого (Хаар работает с одноканальными изображениями)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    # Обнаруживаем лица
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)
    return faces, image

# Пример использования HOG-дескрипторов в OpenCV
import cv2
import numpy as np
from skimage.feature import hog
from skimage import exposure
 
def extract_hog_features(image_path):
    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
    # Параметры HOG
    pixels_per_cell = (8, 8)
    cells_per_block = (2, 2)
    # Вычисляем HOG-дескрипторы
    features, hog_image = hog(image, pixels_per_cell=pixels_per_cell, 
                            cells_per_block=cells_per_block, visualize=True)
    # Улучшаем контрастность для визуализации
    hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 10))
    return features, hog_image_rescaled

# Пример простой CNN для распознавания лиц с использованием TensorFlow/Keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
 
def create_face_recognition_model():
    model = Sequential([
        # Первый свёрточный блок
        Conv2D(32, (3, 3), activation='relu', input_shape=(96, 96, 3)),
        MaxPooling2D(2, 2),
        
        # Второй свёрточный блок
        Conv2D(64, (3, 3), activation='relu'),
        MaxPooling2D(2, 2),
        
        # Третий свёрточный блок
        Conv2D(128, (3, 3), activation='relu'),
        MaxPooling2D(2, 2),
        
        # Выравнивание и полносвязные слои
        Flatten(),
        Dense(512, activation='relu'),
        Dropout(0.5),  # Для предотвращения переобучения
        Dense(128, activation='relu'),
        Dense(10, activation='softmax')  # 10 классов (лиц) для распознавания
    ])
    
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    return model

import cv2
import numpy as np
import matplotlib.pyplot as plt
from skimage import data
 
# Проверка OpenCV
print(f"OpenCV версии: {cv2.__version__}")
 
# Создаем тестовое изображение
img = np.zeros((200, 200, 3), dtype=np.uint8)
img[50:150, 50:150, 0] = 255  # Красный квадрат
 
# Отображаем его с помощью OpenCV
cv2.imshow('Тестовое изображение', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
 
# Альтернативный способ отображения через matplotlib
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Тестовое изображение через Matplotlib')
plt.show()

import cv2
 
# Открываем веб-камеру (0 - это обычно встроенная камера)
cap = cv2.VideoCapture(0)
 
# Проверяем, открылась ли камера успешно
if not cap.isOpened():
print("Ошибка: не удалось открыть веб-камеру")
exit()
 
# Захватываем и отображаем кадры в течение 5 секунд
start_time = cv2.getTickCount()
while (cv2.getTickCount() - start_time) / cv2.getTickFrequency() < 5:
ret, frame = cap.read()
if not ret:
    print("Не удалось получить кадр")
    break
    
cv2.imshow('Тест веб-камеры', frame)
    
# Нажатие клавиши 'q' для преждевременного выхода
if cv2.waitKey(1) & 0xFF == ord('q'):
    break
 
# Освобождаем ресурсы
cap.release()
cv2.destroyAllWindows()

# Пример сохранения видео с разными кодеками
def record_video(codec='XVID', output_file='output.avi', duration=10):
cap = cv2.VideoCapture(0)
# Получаем разрешение камеры
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
# Создаем 4-х символьный код кодека
fourcc = cv2.VideoWriter_fourcc(*codec)
# Создаем объект для записи
out = cv2.VideoWriter(output_file, fourcc, 20.0, (width, height))
    
start_time = cv2.getTickCount()
while (cv2.getTickCount() - start_time) / cv2.getTickFrequency() < duration:
ret, frame = cap.read()
if not ret:
    break
        
# Записываем кадр
out.write(frame)
        
# Показываем, что записываем
cv2.imshow('Recording', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
    break
    
cap.release()
out.release()
cv2.destroyAllWindows()

# Оптимизированная обработка видеопотока
def optimized_video_processing():
cap = cv2.VideoCapture(0)
    
while True:
ret, frame = cap.read()
if not ret:
    break
        
# Уменьшаем размер для ускорения обработки
small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
        
# Конвертируем в оттенки серого для экономии памяти
gray = cv2.cvtColor(small_frame, cv2.COLOR_BGR2GRAY)
        
# Здесь будет обработка...
        
# Показываем результат, но из оригинального кадра
cv2.imshow('Processed Video', frame)
        
if cv2.waitKey(1) & 0xFF == ord('q'):
    break
    
cap.release()
cv2.destroyAllWindows()

cap = cv2.VideoCapture(0)
# Установка разрешения 640x480
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

# Установка частоты кадров
cap.set(cv2.CAP_PROP_FPS, 20)

# Установка автоэкспозиции
cap.set(cv2.CAP_PROP_AUTO_EXPOSURE, 0.75)  # 0.75 - авторежим
# Или ручной режим
cap.set(cv2.CAP_PROP_EXPOSURE, -5)  # Значения обычно от -10 до 0
 
# Установка фокуса (если камера поддерживает)
cap.set(cv2.CAP_PROP_AUTOFOCUS, 0)  # Отключаем автофокус
cap.set(cv2.CAP_PROP_FOCUS, 50)  # Значения обычно от 0 до 255

import cv2
import numpy as np
 
# Загружаем предобученный классификатор
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
 
# Запускаем веб-камеру
cap = cv2.VideoCapture(0)
 
while True:
    # Захватываем кадр
    ret, frame = cap.read()
    if not ret:
        break
    
    # Преобразуем в оттенки серого
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # Обнаруживаем лица
    faces = face_cascade.detectMultiScale(
        gray,
        scaleFactor=1.1,  # Параметр масштабирования
        minNeighbors=5,   # Минимальное число соседей
        minSize=(30, 30)  # Минимальный размер объекта
    )
    
    # Рисуем прямоугольники вокруг лиц
    for (x, y, w, h) in faces:
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
    
    # Отображаем результат
    cv2.imshow('Face Detection', frame)
    
    # Выход по клавише 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
 
# Освобождаем ресурсы
cap.release()
cv2.destroyAllWindows()

# Загружаем классификатор для глаз
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')
 
# В цикле обнаружения лиц добавляем:
for (x, y, w, h) in faces:
    roi_gray = gray[y:y+h, x:x+w]
    roi_color = frame[y:y+h, x:x+w]
    
    # Ищем глаза внутри области лица
    eyes = eye_cascade.detectMultiScale(roi_gray)
    
    # Если нашли хотя бы один глаз, считаем, что это действительно лицо
    if len(eyes) > 0:
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

# Список для хранения последних обнаруженных лиц
last_faces = []
# Сколько кадров хранить
memory_frames = 5
 
# В основном цикле:
# Добавляем текущие лица в список
last_faces.append(faces)
# Удаляем старые данные
if len(last_faces) > memory_frames:
    last_faces.pop(0)
 
# Фильтруем лица, которые встречаются на большинстве последних кадров
stable_faces = []
for current_face in faces:
    x1, y1, w1, h1 = current_face
    face_center = (x1 + w1//2, y1 + h1//2)
    
    # Счётчик "стабильности" этого лица
    stability = 0
    
    # Проверяем, насколько близко это лицо к лицам на предыдущих кадрах
    for past_faces in last_faces[:-1]:  # Исключаем текущий кадр
        for past_face in past_faces:
            x2, y2, w2, h2 = past_face
            past_center = (x2 + w2//2, y2 + h2//2)
            
            # Вычисляем расстояние между центрами
            distance = np.sqrt((face_center[0] - past_center[0])[B]2 + 
                            (face_center[1] - past_center[1])[/B]2)
            
            # Если центры достаточно близко, увеличиваем счётчик
            if distance < 30:  # Порог расстояния в пикселях
                stability += 1
                break
    
    # Если лицо стабильно присутствует на нескольких кадрах
    if stability >= memory_frames // 2:
        stable_faces.append(current_face)

# Адаптивное масштабирование окна поиска
def adaptive_face_detection(frame, prev_faces=None):
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # Если у нас есть информация о предыдущих лицах
    if prev_faces is not None and len(prev_faces) > 0:
        # Вычисляем средний размер лица по предыдущему кадру
        avg_width = sum([w for (x, y, w, h) in prev_faces]) / len(prev_faces)
        avg_height = sum([h for (x, y, w, h) in prev_faces]) / len(prev_faces)
        
        # Устанавливаем минимальный размер как 70% от среднего
        min_size = (int(avg_width * 0.7), int(avg_height * 0.7))
        # Максимальный размер - 130% от среднего
        max_size = (int(avg_width * 1.3), int(avg_height * 1.3))
    else:
        # Если нет предыдущих данных, используем стандартные значения
        min_size = (30, 30)
        max_size = (300, 300)
    
    # Обнаруживаем лица с адаптивными параметрами
    faces = face_cascade.detectMultiScale(
        gray,
        scaleFactor=1.1,
        minNeighbors=5,
        minSize=min_size,
        maxSize=max_size
    )
    
    return faces

import threading
import queue
import time
 
# Очереди для передачи данных между потоками
frame_queue = queue.Queue(maxsize=5)  # Очередь для необработанных кадров
result_queue = queue.Queue(maxsize=5)  # Очередь для обработанных результатов
 
# Функция захвата кадров (будет выполняться в отдельном потоке)
def capture_frames(cap):
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        
        # Если очередь полна, удаляем старый кадр
        if frame_queue.full():
            try:
                frame_queue.get_nowait()
            except queue.Empty:
                pass
        
        # Добавляем новый кадр в очередь
        frame_queue.put(frame)
        time.sleep(0.01)  # Небольшая задержка для стабильности
 
# Функция обработки кадров (будет выполняться в отдельном потоке)
def process_frames():
    while True:
        if not frame_queue.empty():
            # Получаем кадр из очереди
            frame = frame_queue.get()
            
            # Обнаруживаем лица
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            faces = face_cascade.detectMultiScale(gray, 1.1, 5)
            
            # Добавляем результат в очередь
            result_queue.put((frame, faces))
        time.sleep(0.01)  # Небольшая задержка
 
# Основной поток для отображения результатов
def display_results():
    while True:
        if not result_queue.empty():
            # Получаем результат из очереди
            frame, faces = result_queue.get()
            
            # Отображаем результат
            for (x, y, w, h) in faces:
                cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
            
            cv2.imshow('Multithreaded Face Detection', frame)
            
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

# Инициализируем камеру
cap = cv2.VideoCapture(0)
 
# Создаем и запускаем потоки
capture_thread = threading.Thread(target=capture_frames, args=(cap,))
process_thread = threading.Thread(target=process_frames)
 
# Устанавливаем флаг daemon=True, чтобы потоки автоматически завершались при выходе из программы
capture_thread.daemon = True
process_thread.daemon = True
 
# Запускаем потоки
capture_thread.start()
process_thread.start()
 
# Запускаем отображение в основном потоке
display_results()
 
# Освобождаем ресурсы
cap.release()
cv2.destroyAllWindows()

import cv2
import os
import time
 
def collect_face_samples(person_name, num_samples=20):
# Создаем директорию для хранения изображений этого человека
person_dir = f"dataset/{person_name}"
os.makedirs(person_dir, exist_ok=True)
 
# Инициализируем камеру и детектор лиц
cap = cv2.VideoCapture(0)
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
 
# Счетчик собранных образцов
count = 0
print(f"Начинаем сбор образцов для {person_name}...")
 
while count < num_samples:
    ret, frame = cap.read()
    if not ret:
        break
    
    # Обнаруживаем лица
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    
    # Если лицо обнаружено
    for (x, y, w, h) in faces:
        # Рисуем рамку вокруг лица
        cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
        
        # Вырезаем лицо и сохраняем
        face_roi = gray[y:y+h, x:x+w]
        # Стандартизируем размер
        face_roi = cv2.resize(face_roi, (200, 200))
        
        # Сохраняем изображение
        img_path = os.path.join(person_dir, f"{person_name}_{count}.jpg")
        cv2.imwrite(img_path, face_roi)
        
        count += 1
        print(f"Собрано образцов: {count}/{num_samples}")
        
        # Небольшая пауза между снимками
        time.sleep(0.5)
    
    # Отображаем процесс
    cv2.imshow('Сбор данных', frame)
    
    # Выход по клавише 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
 
cap.release()
cv2.destroyAllWindows()
print(f"Сбор образцов для {person_name} завершен!")

import cv2
import os
import numpy as np
from PIL import Image
 
def train_face_recognizer():
# Директория с данными
data_dir = "dataset"
 
# Получаем список подпапок (людей)
people = [d for d in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, d))]
    
# Списки для хранения лиц и меток
faces = []
labels = []
label_dict = {}  # Словарь для сопоставления имен и номеров
    
# Для каждого человека загружаем изображения
for i, person in enumerate(people):
    label_dict[i] = person  # Сохраняем соответствие имени и номера
    person_dir = os.path.join(data_dir, person)
        
    for image_name in os.listdir(person_dir):
        if image_name.endswith(('.jpg', '.jpeg', '.png')):
            image_path = os.path.join(person_dir, image_name)
            # Загружаем изображение и конвертируем в оттенки серого
            face_image = Image.open(image_path).convert('L')
            # Преобразуем в массив numpy
            face_array = np.array(face_image, 'uint8')
                
            # Добавляем в обучающую выборку
            faces.append(face_array)
            labels.append(i)
    
# Создаем и обучаем распознаватель LBPH
recognizer = cv2.face.LBPHFaceRecognizer_create()
recognizer.train(faces, np.array(labels))
    
# Сохраняем модель и словарь соответствия
recognizer.write('face_recognizer_model.yml')
np.save('face_labels.npy', label_dict)
    
print("Обучение завершено!")
return recognizer, label_dict

import cv2
import numpy as np
 
def recognize_faces():
# Загружаем обученную модель и словарь меток
recognizer = cv2.face.LBPHFaceRecognizer_create()
recognizer.read('face_recognizer_model.yml')
label_dict = np.load('face_labels.npy', allow_pickle=True).item()
 
# Инициализируем детектор лиц
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
 
# Запускаем камеру
cap = cv2.VideoCapture(0)
 
while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # Конвертируем в оттенки серого
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    
    # Находим лица
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    
    for (x, y, w, h) in faces:
        # Вырезаем лицо
        face_roi = gray[y:y+h, x:x+w]
        # Стандартизируем размер
        face_roi = cv2.resize(face_roi, (200, 200))
        
        # Распознаем лицо
        label, confidence = recognizer.predict(face_roi)
        
        # Определяем имя и уверенность
        name = label_dict.get(label, "Неизвестный")
        confidence_text = f"{100 - confidence:.1f}%"
        
        # Отображаем результат
        color = (0, 255, 0) if confidence < 70 else (0, 0, 255)  # Зеленый, если уверены
        cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
        cv2.putText(frame, name, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, color, 2)
        cv2.putText(frame, confidence_text, (x, y+h+25), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
    
    # Показываем результат
    cv2.imshow('Face Recognition', frame)
    
    # Выход по клавише 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
 
cap.release()
cv2.destroyAllWindows()

def normalize_illumination(image):
# Метод 1: Эквализация гистограммы
equalized = cv2.equalizeHist(image)
 
# Метод 2: CLAHE (Contrast Limited Adaptive Histogram Equalization)
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
clahe_image = clahe.apply(image)
 
# Метод 3: Гамма-коррекция
gamma = 1.5  # Значение > 1 осветляет темные участки
gamma_corrected = np.array(255 * (image / 255) ** gamma, dtype='uint8')
 
return clahe_image  # Возвращаем один из методов, CLAHE обычно даёт лучшие результаты

def align_face(image):
# Используем dlib для обнаружения ключевых точек лица
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
 
# Находим лицо и его ключевые точки
faces = detector(image)
if not faces:
    return None
 
landmarks = predictor(image, faces[0])
 
# Получаем координаты глаз
left_eye = ((landmarks.part(36).x + landmarks.part(39).x) // 2,
          (landmarks.part(36).y + landmarks.part(39).y) // 2)
right_eye = ((landmarks.part(42).x + landmarks.part(45).x) // 2,
           (landmarks.part(42).y + landmarks.part(45).y) // 2)
 
# Вычисляем угол для выравнивания глаз по горизонтали
dY = right_eye[1] - left_eye[1]
dX = right_eye[0] - left_eye[0]
angle = np.degrees(np.arctan2(dY, dX))
 
# Вычисляем масштаб (расстояние между глазами)
eye_distance = np.sqrt((dX [B] 2) + (dY [/B] 2))
desired_distance = 100  # Желаемое расстояние между глазами
scale = desired_distance / eye_distance
 
# Вычисляем центр вращения (между глазами)
center = ((left_eye[0] + right_eye[0]) // 2, (left_eye[1] + right_eye[1]) // 2)
 
# Создаем матрицу преобразования
M = cv2.getRotationMatrix2D(center, angle, scale)
 
# Добавляем смещение, чтобы центр оказался посередине изображения
target_size = (200, 200)
M[0, 2] += (target_size[0] / 2) - center[0]
M[1, 2] += (target_size[1] / 2) - center[1]
 
# Применяем аффинное преобразование
aligned_face = cv2.warpAffine(image, M, target_size, flags=cv2.INTER_CUBIC)
 
return aligned_face

from sklearn.metrics import precision_score, recall_score, f1_score, confusion_matrix
 
# Предположим, у нас есть:
# y_true - истинные метки людей
[H2]y_pred - предсказанные системой метки[/H2]
 
precision = precision_score(y_true, y_pred, average='weighted')
recall = recall_score(y_true, y_pred, average='weighted')
f1 = f1_score(y_true, y_pred, average='weighted')
 
print(f"Точность: {precision:.3f}")
print(f"Полнота: {recall:.3f}")
print(f"F1-мера: {f1:.3f}")
 
# Визуализация матрицы путаниц
cm = confusion_matrix(y_true, y_pred)
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)
plt.xlabel('Предсказанные метки')
plt.ylabel('Истинные метки')
plt.title('Матрица путаниц')
plt.show()

# Создание LBPH-классификатора с настраиваемыми параметрами
recognizer = cv2.face.LBPHFaceRecognizer_create(
    radius=2,          # Стандартное значение: 1
    neighbors=16,      # Стандартное значение: 8
    grid_x=10,         # Стандартное значение: 8
    grid_y=10,         # Стандартное значение: 8
    threshold=70.0     # Порог уверенности (чем меньше, тем строже)
)

# Уменьшаем изображение для ускорения обработки
frame_small = cv2.resize(frame, (0, 0), fx=0.5, fy=0.5)
# Обнаруживаем лица на уменьшеном изображении
faces = face_cascade.detectMultiScale(frame_small, 1.1, 5)
# Масштабируем координаты обратно
faces = [(int(x * 2), int(y * 2), int(w * 2), int(h * 2)) for (x, y, w, h) in faces]

try:
    # Пробуем использовать GPU-ускорение, если доступно
    net = cv2.dnn.readNetFromCaffe("deploy.prototxt", "model.caffemodel")
    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)
except:
    # Если не получилось, возвращаемся к CPU
    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_DEFAULT)
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)

# Кэш для хранения результатов распознавания
face_cache = {}
 
def recognize_with_cache(face_image, recognizer):
    # Создаем простой хеш изображения
    face_hash = hashlib.md5(face_image.tobytes()).hexdigest()
    
    # Проверяем, есть ли результат в кэше
    if face_hash in face_cache:
        return face_cache[face_hash]
    
    # Если нет - распознаем и сохраняем в кэш
    label, confidence = recognizer.predict(face_image)
    face_cache[face_hash] = (label, confidence)
    
    # Ограничиваем размер кэша
    if len(face_cache) > 1000:
        # Удаляем старые записи
        old_keys = list(face_cache.keys())[:100]
        for key in old_keys:
            del face_cache[key]
    
    return label, confidence

# Аугментация обучающих данных
def augment_face(face_image):
    augmented_faces = [face_image]  # Оригинальное изображение
    
    # Небольшие повороты
    for angle in [-15, -10, -5, 5, 10, 15]:
        rows, cols = face_image.shape
        M = cv2.getRotationMatrix2D((cols/2, rows/2), angle, 1)
        rotated = cv2.warpAffine(face_image, M, (cols, rows))
        augmented_faces.append(rotated)
    
    return augmented_faces

def adaptive_confidence_threshold(face_recognizer, test_faces, labels):
    # Находим оптимальный порог на основе тестовой выборки
    confidences = []
    for face, true_label in zip(test_faces, labels):
        pred_label, conf = face_recognizer.predict(face)
        if pred_label == true_label:
            # Для правильных распознаваний сохраняем уверенность
            confidences.append(conf)
    
    if not confidences:
        return 70.0  # Стандартное значение
    
    # Вычисляем среднее + 2 стандартных отклонения
    mean_conf = np.mean(confidences)
    std_conf = np.std(confidences)
    threshold = mean_conf + 2 * std_conf
    
    return min(threshold, 100.0)  # Ограничиваем максимум

# Инициализация трекера особых точек
tracker = cv2.TrackerKCF_create()  # KCF-трекер (Kernelized Correlation Filters)
 
# Словарь для хранения трекеров для каждого лица
face_trackers = {}
 
def track_multiple_faces(frame, face_cascade, recognizer, label_dict):
 # Периодически (например, каждые 10 кадров) выполняем полное распознавание
 global frame_count
 frame_count += 1
 
 gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
 # Обнаруживаем лица только периодически для экономии ресурсов
 if frame_count % 10 == 0:
     # Очищаем старые трекеры
     face_trackers.clear()
     
     # Обнаруживаем лица
     faces = face_cascade.detectMultiScale(gray, 1.3, 5)
     
     # Инициализируем новые трекеры для каждого лица
     for i, (x, y, w, h) in enumerate(faces):
         # Распознаем лицо
         face_roi = gray[y:y+h, x:x+w]
         face_roi = cv2.resize(face_roi, (200, 200))
         label, confidence = recognizer.predict(face_roi)
         
         # Создаем новый трекер
         tracker = cv2.TrackerKCF_create()
         tracker.init(frame, (x, y, w, h))
         
         # Сохраняем трекер вместе с информацией о лице
         face_trackers[i] = {
             'tracker': tracker,
             'name': label_dict.get(label, "Неизвестный"),
             'confidence': confidence
         }
 
 # Обновляем положение всех отслеживаемых лиц
 faces_to_remove = []
 for face_id, face_data in face_trackers.items():
     success, box = face_data['tracker'].update(frame)
     
     if success:
         x, y, w, h = [int(v) for v in box]
         # Рисуем рамку и информацию
         cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
         cv2.putText(frame, face_data['name'], (x, y-10), 
                  cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
     else:
         # Если трекер потерял лицо, отмечаем для удаления
         faces_to_remove.append(face_id)
 
 # Удаляем потерянные лица
 for face_id in faces_to_remove:
     del face_trackers[face_id]
     
 return frame

# Здесь мы показываем концептуальную структуру использования DeepSORT
[H2]В реальном коде требуется установка и импорт deep_sort пакета[/H2]
 
from deep_sort.tracker import Tracker
from deep_sort.detection import Detection
from deep_sort import nn_matching
 
# Инициализация DeepSORT
max_cosine_distance = 0.4
nn_budget = None
metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget)
tracker = Tracker(metric)
 
def process_frame_with_deepsort(frame, detector, encoder):
 # Обнаруживаем лица
 detections = detector.detect(frame)
 
 # Извлекаем визуальные дескрипторы
 features = encoder.get_features(frame, detections)
 
 # Конвертируем в формат DeepSORT
 detection_list = []
 for i, (bbox, score) in enumerate(detections):
     detection_list.append(Detection(bbox, score, features[i]))
 
 # Обновляем трекер
 tracker.predict()
 tracker.update(detection_list)
 
 # Рисуем результаты трекинга
 for track in tracker.tracks:
     if not track.is_confirmed() or track.time_since_update > 1:
         continue
     bbox = track.to_tlbr()
     cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), 
                 (255, 0, 0), 2)
     cv2.putText(frame, f"ID: {track.track_id}", (int(bbox[0]), int(bbox[1])-10), 
                cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)
 
 return frame

def handle_backlight(image):
 # Конвертируем в LAB цветовое пространство
 lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
 
 # Разделяем каналы
 l, a, b = cv2.split(lab)
 
 # Применяем CLAHE к каналу яркости
 clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
 cl = clahe.apply(l)
 
 # Объединяем каналы обратно
 limg = cv2.merge((cl, a, b))
 
 # Конвертируем обратно в BGR
 enhanced = cv2.cvtColor(limg, cv2.COLOR_LAB2BGR)
 
 return enhanced

def capture_hdr_frames(cap):
 # Сохраняем текущее значение экспозиции
 original_exposure = cap.get(cv2.CAP_PROP_EXPOSURE)
 
 # Захватываем кадры с разной экспозицией
 exposures = [-7, -3, 0]  # В логарифмической шкале, обычно от -10 до 0
 frames = []
 
 for exp in exposures:
     cap.set(cv2.CAP_PROP_EXPOSURE, exp)
     # Даем камере время на адаптацию
     time.sleep(0.1)
     
     ret, frame = cap.read()
     if ret:
         frames.append(frame)
 
 # Возвращаем исходное значение
 cap.set(cv2.CAP_PROP_EXPOSURE, original_exposure)
 
 # Создаем HDR изображение
 if len(frames) >= 2:
     # Конвертируем кадры в float32
     frames_float32 = [np.float32(frame) for frame in frames]
     
     # Объединяем кадры в HDR изображение
     merge_mertens = cv2.createMergeMertens()
     hdr = merge_mertens.process(frames_float32)
     
     # Конвертируем обратно в 8-битный формат
     hdr_8bit = np.clip(hdr * 255, 0, 255).astype('uint8')
     
     return hdr_8bit
 
 # Если что-то пошло не так, возвращаем первый кадр
 return frames[0] if frames else None

from flask import Flask, render_template, Response, request, jsonify
import cv2
import numpy as np
import os
import time
import threading
import queue
 
app = Flask(__name__)
 
# Глобальные переменные
camera = None
face_cascade = None
recognizer = None
label_dict = None
frame_queue = queue.Queue(maxsize=10)
processing_thread = None
processing_active = False
 
@app.route('/')
def index():
    """Главная страница приложения"""
    return render_template('index.html')
 
def initialize_system():
    """Инициализация компонентов системы распознавания"""
    global face_cascade, recognizer, label_dict, camera
    
    # Загружаем детектор лиц
    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
    
    # Загружаем распознаватель, если модель существует
    try:
        recognizer = cv2.face.LBPHFaceRecognizer_create()
        recognizer.read('face_recognizer_model.yml')
        label_dict = np.load('face_labels.npy', allow_pickle=True).item()
    except:
        print("Модель распознавания не найдена. Доступен только режим обнаружения.")
    
    # Инициализируем камеру
    camera = cv2.VideoCapture(0)
    camera.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

def process_frames():
    """Обработка кадров в отдельном потоке"""
    global processing_active
    
    while processing_active:
        if not camera.isOpened():
            break
            
        ret, frame = camera.read()
        if not ret:
            break
            
        # Обнаружение и распознавание лиц
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray, 1.3, 5)
        
        for (x, y, w, h) in faces:
            # Рисуем прямоугольник вокруг лица
            cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
            
            # Если распознаватель загружен, пытаемся идентифицировать лицо
            if recognizer is not None and label_dict is not None:
                face_roi = cv2.resize(gray[y:y+h, x:x+w], (200, 200))
                label, confidence = recognizer.predict(face_roi)
                
                if confidence < 70:  # Порог уверенности
                    name = label_dict.get(label, "Неизвестный")
                    cv2.putText(frame, f"{name} ({100-confidence:.1f}%)", 
                                (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
                else:
                    cv2.putText(frame, "Неизвестный", 
                                (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
        
        # Добавляем обработанный кадр в очередь
        if not frame_queue.full():
            frame_queue.put(frame)
        else:
            # Если очередь заполнена, удаляем старый кадр
            try:
                frame_queue.get_nowait()
                frame_queue.put(frame)
            except:
                pass
 
def generate_frames():
    """Генератор для потокового видео"""
    while True:
        if not frame_queue.empty():
            frame = frame_queue.get()
            # Конвертируем изображение в формат, подходящий для веб-потока
            ret, jpeg = cv2.imencode('.jpg', frame)
            if ret:
                yield (b'--frame\r\n'
                      b'Content-Type: image/jpeg\r\n\r\n' + jpeg.tobytes() + b'\r\n\r\n')
        else:
            time.sleep(0.01)

@app.route('/video_feed')
def video_feed():
    """Маршрут для потоковой передачи видео"""
    return Response(generate_frames(),
                   mimetype='multipart/x-mixed-replace; boundary=frame')
 
@app.route('/start_recognition', methods=['POST'])
def start_recognition():
    """Запуск процесса распознавания"""
    global processing_thread, processing_active
    
    if processing_thread is None or not processing_thread.is_alive():
        processing_active = True
        processing_thread = threading.Thread(target=process_frames)
        processing_thread.daemon = True
        processing_thread.start()
        return jsonify({"status": "success", "message": "Распознавание запущено"})
    
    return jsonify({"status": "error", "message": "Распознавание уже запущено"})
 
@app.route('/stop_recognition', methods=['POST'])
def stop_recognition():
    """Остановка процесса распознавания"""
    global processing_active
    
    processing_active = False
    return jsonify({"status": "success", "message": "Распознавание остановлено"})
 
@app.route('/train', methods=['POST'])
def train_new_face():
    """Обучение на новом лице"""
    name = request.form.get('name')
    if not name:
        return jsonify({"status": "error", "message": "Имя не указано"})
    
    # Здесь будет код сбора образцов лица и обучения модели
    # ...
    
    return jsonify({"status": "success", "message": f"Обучение для {name} завершено"})

if __name__ == '__main__':
    initialize_system()
    app.run(host='0.0.0.0', port=5000, debug=True)

import sqlite3
 
def init_database():
    """Инициализация базы данных"""
    conn = sqlite3.connect('face_recognition.db')
    cursor = conn.cursor()
    
    # Создаём таблицу для пользователей
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )
    ''')
    
    # Таблица для хранения векторов лиц (embeddings)
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS face_embeddings (
        id INTEGER PRIMARY KEY,
        user_id INTEGER,
        embedding BLOB NOT NULL,
        FOREIGN KEY (user_id) REFERENCES users (id)
    )
    ''')
    
    conn.commit()
    conn.close()

@app.route('/train', methods=['POST'])
def train_new_face():
    name = request.form.get('name')
    if not name:
        return jsonify({"status": "error", "message": "Имя не указано"})
    
    # Получаем изображения лица с фронтенда
    face_images = request.files.getlist('face_images')
    if not face_images:
        return jsonify({"status": "error", "message": "Изображения не предоставлены"})
    
    # Сохраняем пользователя в БД
    conn = sqlite3.connect('face_recognition.db')
    cursor = conn.cursor()
    cursor.execute("INSERT INTO users (name) VALUES (?)", (name,))
    user_id = cursor.lastrowid
    
    # Обрабатываем каждое изображение
    for img_file in face_images:
        img_array = np.frombuffer(img_file.read(), np.uint8)
        img = cv2.imdecode(img_array, cv2.IMREAD_GRAYSCALE)
        
        # Нормализуем размер
        img = cv2.resize(img, (200, 200))
        
        # Извлекаем векторное представление лица (embedding)
        # В случае LBPH это просто само изображение
        embedding = img.tobytes()
        
        # Сохраняем в БД
        cursor.execute("INSERT INTO face_embeddings (user_id, embedding) VALUES (?, ?)",
                      (user_id, embedding))
    
    conn.commit()
    conn.close()
    
    # Обновляем модель распознавания
    update_recognition_model()
    
    return jsonify({"status": "success", "message": f"Обучение для {name} завершено"})