Билеты по Компьютерному Зрению

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt # Для более удобного отображения

# Загрузка изображения в оттенках серого
# В качестве примера создадим простое изображение с квадратом
original_image = np.zeros((200, 200), dtype=np.uint8)
original_image[75:125, 75:125] = 255 # Белый квадрат в центре

# if original_image is None:
# print('Ошибка: Не удалось загрузить изображение.')
# exit()

# Преобразование в float32, т.к. dft работает с этим типом
image_float32 = np.float32(original_image)

# Выполнение ДПФ. cv2.DFT_COMPLEX_OUTPUT возвращает комплексный результат
dft_result = cv2.dft(image_float32, flags=cv2.DFT_COMPLEX_OUTPUT)

# Сдвиг компоненты с нулевой частотой (DC component) из левого верхнего угла в центр спектра
# Это делается для более интуитивной визуализации
dft_shifted = np.fft.fftshift(dft_result)

# Вычисление магнитудного спектра
# dft_shifted[:,:,0] - реальная часть, dft_shifted[:,:,1] - мнимая часть
magnitude_spectrum = 20 * np.log(cv2.magnitude(dft_shifted[:, :, 0], dft_shifted[:, :, 1]) + 1e-9) # +1e-9 для избежания log(0)

# Визуализация
# plt.figure(figsize=(10, 5))
# plt.subplot(121), plt.imshow(original_image, cmap='gray')
# plt.title('Исходное изображение'), plt.xticks([]), plt.yticks([])
# plt.subplot(122), plt.imshow(magnitude_spectrum, cmap='gray')
# plt.title('Магнитудный спектр (логарифм)'), plt.xticks([]), plt.yticks([])
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# original_image = cv2.imread('noisy_image.jpg', cv2.IMREAD_GRAYSCALE)
# if original_image is None: print('Ошибка загрузки'); exit()

# Для примера создадим изображение и добавим периодический шум
img_size = 256
original_image = np.zeros((img_size, img_size), dtype=np.uint8)
original_image[100:150, 100:150] = 200 # Квадрат
# Добавим синусоидальный шум
for i in range(img_size):
    original_image[i,:] = np.clip(original_image[i,:] + 30 * np.sin(i / 5.0), 0, 255)

image_float32 = np.float32(original_image)
dft_result = cv2.dft(image_float32, flags=cv2.DFT_COMPLEX_OUTPUT)
dft_shifted = np.fft.fftshift(dft_result)

# Создание маски для фильтра (например, ФНЧ - пропускаем низкие частоты)
rows, cols = original_image.shape
crow, ccol = rows // 2 , cols // 2 # Центр

# Маска для ФНЧ (круговая)
radius_lpf = 30
mask_lpf = np.zeros((rows, cols, 2), np.float32) # Маска должна быть того же типа и размера, что и dft_shifted
cv2.circle(mask_lpf, (ccol, crow), radius_lpf, (1,1), -1) # (1,1) для реальной и мнимой части

# Применение маски ФНЧ
filtered_dft_shifted_lpf = dft_shifted * mask_lpf

# Маска для режекторного фильтра (удаление периодического шума)
# Предположим, мы знаем координаты пиков шума в спектре (относительно центра)
# (эти точки нужно найти, посмотрев на спектр зашумленного изображения)
# Для нашего примера шум горизонтальный, пики будут на вертикальной линии от центра
mask_notch = np.ones((rows, cols, 2), np.float32)
noise_freq_offset = int(img_size / (2 * 5.0)) # Примерная частота нашего синусоидального шума
notch_width = 5
cv2.rectangle(mask_notch, (ccol - notch_width//2, crow - noise_freq_offset - notch_width//2), 
              (ccol + notch_width//2, crow - noise_freq_offset + notch_width//2), (0,0), -1)
cv2.rectangle(mask_notch, (ccol - notch_width//2, crow + noise_freq_offset - notch_width//2), 
              (ccol + notch_width//2, crow + noise_freq_offset + notch_width//2), (0,0), -1)

# Применение режекторной маски
filtered_dft_shifted_notch = dft_shifted * mask_notch

# Обратное преобразование Фурье для ФНЧ
f_ishift_lpf = np.fft.ifftshift(filtered_dft_shifted_lpf)
img_back_lpf = cv2.idft(f_ishift_lpf)
img_back_lpf = cv2.magnitude(img_back_lpf[:, :, 0], img_back_lpf[:, :, 1])
img_back_lpf = cv2.normalize(img_back_lpf, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)

# Обратное преобразование Фурье для режекторного фильтра
f_ishift_notch = np.fft.ifftshift(filtered_dft_shifted_notch)
img_back_notch = cv2.idft(f_ishift_notch)
img_back_notch = cv2.magnitude(img_back_notch[:, :, 0], img_back_notch[:, :, 1])
img_back_notch = cv2.normalize(img_back_notch, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)

# Магнитудный спектр исходного и отфильтрованных
magnitude_spectrum_original = 20 * np.log(cv2.magnitude(dft_shifted[:,:,0], dft_shifted[:,:,1]) + 1e-9)
magnitude_spectrum_lpf_filtered = 20 * np.log(cv2.magnitude(filtered_dft_shifted_lpf[:,:,0], filtered_dft_shifted_lpf[:,:,1]) + 1e-9)
magnitude_spectrum_notch_filtered = 20 * np.log(cv2.magnitude(filtered_dft_shifted_notch[:,:,0], filtered_dft_shifted_notch[:,:,1]) + 1e-9)

# Визуализация
# plt.figure(figsize=(15, 10))
# plt.subplot(231), plt.imshow(original_image, cmap='gray'), plt.title('Исходное (с шумом)')
# plt.subplot(232), plt.imshow(img_back_lpf, cmap='gray'), plt.title('После ФНЧ (размытие)')
# plt.subplot(233), plt.imshow(img_back_notch, cmap='gray'), plt.title('После режекторного фильтра')
# plt.subplot(234), plt.imshow(magnitude_spectrum_original, cmap='gray'), plt.title('Спектр исходного')
# plt.subplot(235), plt.imshow(magnitude_spectrum_lpf_filtered, cmap='gray'), plt.title('Спектр после ФНЧ')
# plt.subplot(236), plt.imshow(magnitude_spectrum_notch_filtered, cmap='gray'), plt.title('Спектр после режекторного')
# plt.show()

Пример кода:

import cv2
import numpy as np

# Координаты 4-х точек на исходном изображении (например, углы листа бумаги)
# Представим, что это углы прямоугольника размером 300x200 пикселей
# Точки должны быть в формате float32
# Порядок точек важен и должен соответствовать порядку pts_dst
# Например: верхний-левый, верхний-правый, нижний-правый, нижний-левый
pts_src = np.array([[50, 50],       # Точка 1 (верхний-левый угол исходного объекта)
                      [250, 50],      # Точка 2 (верхний-правый)
                      [250, 200],     # Точка 3 (нижний-правый)
                      [50, 200]],     # Точка 4 (нижний-левый)
                     dtype="float32")

# Координаты этих же 4-х точек на целевом изображении (куда мы хотим их трансформировать)
# Например, после перспективного искажения они стали выглядеть так:
pts_dst = np.array([[10, 100],      # Точка 1 на целевом изображении
                      [280, 80],      # Точка 2
                      [300, 250],     # Точка 3
                      [30, 200]],     # Точка 4
                     dtype="float32")

# Вычисление матрицы гомографии H с использованием 4-х пар точек
# Эта функция решает систему линейных уравнений для 8 неизвестных элементов матрицы H.
H_matrix = cv2.getPerspectiveTransform(pts_src, pts_dst)

# print("Вычисленная матрица гомографии H:\n", H_matrix)
# Пример выходных данных:
# [[ 1.20588235e+00  4.11764706e-01 -5.70588235e+01]
#  [ 1.17647059e-01  1.11764706e+00  2.52941176e+01]
#  [ 4.70588235e-04  1.17647059e-03  1.00000000e+00]]

Пример кода:

import cv2
import numpy as np

# Создадим простое исходное изображение с цветным прямоугольником
src_image = np.zeros((250, 300, 3), dtype=np.uint8)
# Рисуем зеленый прямоугольник, соответствующий нашим pts_src из предыдущего примера
cv2.rectangle(src_image, (50, 50), (250, 200), (0, 255, 0), -1) # Зеленый
# cv2.imshow('Исходное изображение', src_image)

# Используем те же точки, что и в предыдущем примере для H_matrix
pts_src = np.array([[50, 50], [250, 50], [250, 200], [50, 200]], dtype="float32")
pts_dst = np.array([[10, 100], [280, 80], [300, 250], [30, 200]], dtype="float32")
H_matrix = cv2.getPerspectiveTransform(pts_src, pts_dst)

# Задаем размеры выходного изображения (куда будет трансформировано исходное)
output_width = 350
output_height = 300

# Применение проективного преобразования (варпинг)
warped_image = cv2.warpPerspective(src_image, H_matrix, (output_width, output_height))

# Отображение результата
# cv2.imshow('Трансформированное изображение', warped_image)
# cv2.waitKey(0)
# cv2.destroyAllWindows()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка изображения или создание тестового
# image_bgr = cv2.imread('chessboard.png') # Хорошо подходит шахматная доска
# if image_bgr is None: print('Ошибка загрузки'); exit()

# Создадим тестовое изображение с углами
image_bgr = np.zeros((200, 250, 3), dtype=np.uint8)
image_bgr.fill(200) # Светло-серый фон
cv2.rectangle(image_bgr, (50, 50), (150, 150), (50, 50, 50), -1) # Темный квадрат
cv2.putText(image_bgr, "ABC", (170, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 2)

gray_image = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)

# Преобразование в float32, так как cornerHarris работает с этим типом
gray_image_float = np.float32(gray_image)

# Применение детектора Харриса
# blockSize: Размер окна для вычисления матрицы M (например, 2x2 или 5x5).
# ksize: Размер (апертура) ядра Собеля для вычисления производных (должен быть нечетным, например, 3, 5).
# k: Свободный параметр в формуле Харриса (обычно 0.04 - 0.06).
harris_response_map = cv2.cornerHarris(gray_image_float, blockSize=2, ksize=3, k=0.04)

# Результат harris_response_map - это карта 'угловатости'. Углы будут иметь высокие значения.
# Для визуализации можно расширить (dilate) найденные отклики, чтобы точки были заметнее.
harris_response_map_dilated = cv2.dilate(harris_response_map, None)

# Создаем копию исходного цветного изображения для отрисовки результатов
image_with_corners = image_bgr.copy()

# Пороговая фильтрация для выделения сильных углов
# Мы помечаем пиксели на исходном изображении, где значение в harris_response_map_dilated
# превышает определенный процент от максимального значения отклика.
threshold_harris = 0.01 * harris_response_map_dilated.max()
image_with_corners[harris_response_map_dilated > threshold_harris] = [0, 0, 255] # Пометить углы красным (BGR)

# Визуализация
# plt.figure(figsize=(12, 6))
# plt.subplot(131), plt.imshow(cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)), plt.title('Исходное')
# plt.subplot(132), plt.imshow(harris_response_map_dilated, cmap='gray'), plt.title('Отклик Харриса (расширенный)')
# plt.subplot(133), plt.imshow(cv2.cvtColor(image_with_corners, cv2.COLOR_BGR2RGB)), plt.title('Найденные углы Харриса')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка изображения или создание тестового
# image_bgr = cv2.imread('sudoku.png')
# if image_bgr is None: print('Ошибка загрузки'); exit()

# Создадим тестовое изображение с линиями
image_bgr = np.zeros((200, 200, 3), dtype=np.uint8)
image_bgr.fill(255) # Белый фон
cv2.line(image_bgr, (50, 20), (150, 180), (0,0,0), 2) # Наклонная линия
cv2.line(image_bgr, (20, 100), (180, 100), (0,0,0), 2) # Горизонтальная линия

gray_image = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)

# Обнаружение краев с помощью детектора Canny
edges = cv2.Canny(gray_image, threshold1=50, threshold2=150, apertureSize=3)

# Применение стандартного преобразования Хаффа
# rho: разрешение по расстоянию ρ в пикселях (обычно 1).
# theta: разрешение по углу θ в радианах (обычно np.pi/180, т.е. 1 градус).
# threshold: минимальное количество голосов (пересечений в аккумуляторе) для признания линии.
lines = cv2.HoughLines(edges, rho=1, theta=np.pi/180, threshold=60)

image_with_lines = image_bgr.copy()
if lines is not None:
    for line_params in lines:
        rho, theta = line_params[0] # Берем параметры первой (и единственной в данном случае) линии из массива
        a = np.cos(theta)
        b = np.sin(theta)
        x0 = a * rho
        y0 = b * rho
        # Находим две точки на линии для отрисовки (x1,y1) и (x2,y2)
        # (смещаемся от точки (x0,y0) вдоль и против перпендикуляра к линии)
        x1 = int(x0 + 1000 * (-b))
        y1 = int(y0 + 1000 * (a))
        x2 = int(x0 - 1000 * (-b))
        y2 = int(y0 - 1000 * (a))
        cv2.line(image_with_lines, (x1, y1), (x2, y2), (0, 0, 255), 1) # Рисуем красную линию

# Визуализация
# plt.figure(figsize=(10, 5))
# plt.subplot(121), plt.imshow(edges, cmap='gray'), plt.title('Края (Canny)')
# plt.subplot(122), plt.imshow(cv2.cvtColor(image_with_lines, cv2.COLOR_BGR2RGB)), plt.title('Найденные линии (HoughLines)')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Используем то же изображение и края, что и в предыдущем примере
image_bgr = np.zeros((200, 200, 3), dtype=np.uint8); image_bgr.fill(255)
cv2.line(image_bgr, (50, 20), (150, 180), (0,0,0), 2)
cv2.line(image_bgr, (20, 100), (180, 100), (0,0,0), 2)
gray_image = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray_image, 50, 150, apertureSize=3)

# Применение вероятностного преобразования Хаффа
# minLineLength: Минимальная длина отрезка в пикселях. Отрезки короче этого значения отбрасываются.
# maxLineGap: Максимальный допустимый разрыв между сегментами линии, чтобы считать их одной линией.
lines_p = cv2.HoughLinesP(edges, rho=1, theta=np.pi/180, threshold=30, 
                            minLineLength=20, maxLineGap=5)

image_with_lines_p = image_bgr.copy()
if lines_p is not None:
    for line_segment in lines_p:
        x1, y1, x2, y2 = line_segment[0]
        cv2.line(image_with_lines_p, (x1, y1), (x2, y2), (0, 255, 0), 2) # Рисуем зеленый отрезок

# Визуализация
# plt.figure(figsize=(10, 5))
# plt.subplot(121), plt.imshow(edges, cmap='gray'), plt.title('Края (Canny)')
# plt.subplot(122), plt.imshow(cv2.cvtColor(image_with_lines_p, cv2.COLOR_BGR2RGB)), plt.title('Найденные отрезки (HoughLinesP)')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка изображения или создание тестового
# image_bgr = cv2.imread('coins.png')
# if image_bgr is None: print('Ошибка загрузки'); exit()

# Создадим тестовое изображение с кругами
image_bgr = np.zeros((250, 350, 3), dtype=np.uint8)
image_bgr.fill(220) # Светло-серый фон
cv2.circle(image_bgr, (100, 100), 40, (50, 150, 50), -1) # Зеленый круг
cv2.circle(image_bgr, (250, 150), 60, (150, 50, 50), 2)  # Синий контур круга

gray_image = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)

# Для лучшего результата часто применяют размытие, чтобы убрать шум и мелкие детали
gray_blurred = cv2.medianBlur(gray_image, 5) # Медианный фильтр хорошо убирает "соль и перец"

# Применение преобразования Хаффа для окружностей
# dp: обратное отношение разрешения аккумулятора к разрешению изображения (1 - то же, >1 - меньше, например, 2 - аккум. в 2 раза меньше).
# minDist: минимальное расстояние между центрами найденных окружностей. Если круги близко, будет найден только один.
# param1: верхний порог для внутреннего детектора Canny (используется в Hough Gradient Method).
# param2: порог аккумулятора для центров окружностей. Чем меньше, тем больше окружностей будет найдено (включая ложные).
# minRadius, maxRadius: диапазон радиусов для поиска (в пикселях).
circles = cv2.HoughCircles(gray_blurred, method=cv2.HOUGH_GRADIENT, dp=1.2, minDist=50,
                               param1=100, param2=35, minRadius=10, maxRadius=100)

image_with_circles = image_bgr.copy()
if circles is not None:
    circles = np.uint16(np.around(circles)) # Преобразуем координаты и радиус в целые числа
    for i in circles[0, :]: # circles[0,:] - это массив найденных кругов [[x,y,r], [x,y,r]...]
        # Рисуем внешнюю окружность (контур найденного круга)
        cv2.circle(image_with_circles, (i[0], i[1]), i[2], (0, 255, 0), 2) # Зеленый контур
        # Рисуем центр окружности
        cv2.circle(image_with_circles, (i[0], i[1]), 2, (0, 0, 255), 3)    # Красная точка в центре

# Визуализация
# plt.figure(figsize=(10, 5))
# plt.subplot(121), plt.imshow(gray_blurred, cmap='gray'), plt.title('Размытое серое изображение')
# plt.subplot(122), plt.imshow(cv2.cvtColor(image_with_circles, cv2.COLOR_BGR2RGB)), plt.title('Найденные окружности')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Создадим изображение с резкими краями
original_image = np.zeros((200, 200), dtype=np.uint8)
original_image[50:150, 50:150] = 255 # Белый квадрат на черном фоне

# Применение Гауссова размытия
# ksize: размер ядра Гаусса (ширина, высота). Должен быть нечетным и положительным (например, (5,5), (3,3)).
# sigmaX: стандартное отклонение Гауссова ядра по оси X. Если 0, оно вычисляется из ksize.
# sigmaY (опционально): стандартное отклонение по Y. Если 0, равно sigmaX. Если оба 0, вычисляются из ksize.
kernel_size = (7, 7)
blurred_image = cv2.GaussianBlur(original_image, kernel_size, sigmaX=0)

# plt.figure(figsize=(10, 5))
# plt.subplot(121), plt.imshow(original_image, cmap='gray'), plt.title('Исходное изображение')
# plt.subplot(122), plt.imshow(blurred_image, cmap='gray'), plt.title(f'Гауссово размытие (ядро {kernel_size})')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# original_image = cv2.imread('high_res_image.jpg')
# if original_image is None: print('Ошибка загрузки'); exit()
original_image = np.zeros((200, 300, 3), dtype=np.uint8)
cv2.putText(original_image, "OpenCV", (30, 100), cv2.FONT_HERSHEY_SIMPLEX, 2, (255,255,255), 3)

# Уменьшение изображения в 2 раза по каждой оси
# dstsize (опционально): желаемый размер выходного изображения. По умолчанию (ширина/2, высота/2).
downsampled_image = cv2.pyrDown(original_image)

# print(f"Размер исходного изображения: {original_image.shape}")
# print(f"Размер уменьшенного изображения: {downsampled_image.shape}")

# plt.figure(figsize=(12, 6))
# plt.subplot(121), plt.imshow(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)), plt.title('Исходное')
# plt.subplot(122), plt.imshow(cv2.cvtColor(downsampled_image, cv2.COLOR_BGR2RGB)), plt.title('Уменьшенное (pyrDown)')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# small_image = cv2.imread('low_res_image.jpg')
# if small_image is None: print('Ошибка загрузки'); exit()
small_image = np.zeros((100, 150, 3), dtype=np.uint8)
cv2.putText(small_image, "CV", (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 2, (255,0,255), 3)

# Увеличение изображения в 2 раза по каждой оси
# dstsize (опционально): желаемый размер выходного изображения. По умолчанию (ширина*2, высота*2).
upsampled_image = cv2.pyrUp(small_image)

# print(f"Размер исходного (маленького) изображения: {small_image.shape}")
# print(f"Размер увеличенного изображения: {upsampled_image.shape}")

# plt.figure(figsize=(12, 6))
# plt.subplot(121), plt.imshow(cv2.cvtColor(small_image, cv2.COLOR_BGR2RGB)), plt.title('Маленькое исходное')
# plt.subplot(122), plt.imshow(cv2.cvtColor(upsampled_image, cv2.COLOR_BGR2RGB)), plt.title('Увеличенное (pyrUp)')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# original_image = cv2.imread('lena.png')
# if original_image is None: print('Ошибка загрузки'); exit()

# Создадим тестовое изображение
original_image = np.zeros((256, 256, 3), dtype=np.uint8)
original_image.fill(128) # Серый фон
cv2.rectangle(original_image, (50,50), (200,200), (255,255,255), -1) # Белый квадрат
cv2.putText(original_image, "Hi", (80,150), cv2.FONT_HERSHEY_SIMPLEX, 2, (0,0,0), 3)

# G0 - исходное изображение (нулевой уровень Гауссовой пирамиды)
G0 = original_image.copy()

# G1 - следующий уровень Гауссовой пирамиды
G1 = cv2.pyrDown(G0)

# expand(G1) - апсэмплинг G1 до размера G0
# Важно, чтобы размеры точно совпадали. pyrUp может дать размер чуть меньше, если исходный был нечетным.
# Поэтому лучше явно указать dstsize.
G1_expanded = cv2.pyrUp(G1, dstsize=(G0.shape[1], G0.shape[0]))

# L0 - нулевой уровень Лапласовой пирамиды
# cv2.subtract обеспечивает корректную обработку значений (насыщение)
L0 = cv2.subtract(G0, G1_expanded)

# Для визуализации L0 может потребоваться сдвиг, т.к. он содержит отрицательные значения
# L0_display = cv2.add(L0, np.array([128,128,128], dtype=np.uint8)) # Сдвиг на 128 для отображения
L0_display = cv2.normalize(L0, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)

# plt.figure(figsize=(15, 5))
# plt.subplot(131), plt.imshow(cv2.cvtColor(G0, cv2.COLOR_BGR2RGB)), plt.title('G0 (Исходное)')
# plt.subplot(132), plt.imshow(cv2.cvtColor(G1_expanded, cv2.COLOR_BGR2RGB)), plt.title('expand(G1)')
# plt.subplot(133), plt.imshow(cv2.cvtColor(L0_display, cv2.COLOR_BGR2RGB)), plt.title('L0 (Уровень Лапласиана)')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# original_image_gray = cv2.imread('textured_surface.jpg', cv2.IMREAD_GRAYSCALE)
# if original_image_gray is None: print('Ошибка загрузки'); exit()

# Создадим тестовое изображение с текстурой (горизонтальные линии)
original_image_gray = np.zeros((200, 200), dtype=np.uint8)
for i in range(0, 200, 10):
    cv2.line(original_image_gray, (0, i), (199, i), 255, 2)

# Параметры для ядра Габора
ksize = 31        # Размер ядра (должен быть нечетным). Чем больше, тем точнее, но медленнее.
sigma = 4.0       # Стандартное отклонение гауссовой огибающей.
theta_rad = np.pi / 2 # Ориентация: 0 для вертикальных, np.pi/2 для горизонтальных линий.
lamda = 10.0      # Длина волны синусоидального фактора.
gamma = 0.5       # Коэффициент пространственного соотношения (эллиптичность). 1 - круг, <1 - вытянутый.
phi = 0           # Фазовый сдвиг (в радианах). 0 и np.pi/2 дают четный и нечетный фильтры.

# Создание ядра Габора
gabor_kernel = cv2.getGaborKernel((ksize, ksize), sigma, theta_rad, lamda, gamma, phi, ktype=cv2.CV_32F)

# Применение фильтра Габора к изображению
# ddepth=-1 означает, что выходное изображение будет иметь ту же глубину, что и входное.
filtered_image_gabor = cv2.filter2D(original_image_gray, cv2.CV_32F, gabor_kernel)

# Для визуализации ядра и результата
kernel_display = cv2.normalize(gabor_kernel, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
filtered_display = cv2.normalize(filtered_image_gabor, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)

# plt.figure(figsize=(15, 5))
# plt.subplot(131), plt.imshow(original_image_gray, cmap='gray'), plt.title('Исходное серое')
# plt.subplot(132), plt.imshow(kernel_display, cmap='gray'), plt.title('Ядро Габора (theta=pi/2)')
# plt.subplot(133), plt.imshow(filtered_display, cmap='gray'), plt.title('Отклик фильтра Габора')
# plt.show()

Пример кода:

from skimage.feature import local_binary_pattern # skimage предоставляет удобную реализацию
import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка изображения или создание текстурного
# texture_image_gray = cv2.imread('fabric_texture.jpg', cv2.IMREAD_GRAYSCALE)
# if texture_image_gray is None: print('Ошибка загрузки'); exit()

# Создадим простое текстурное изображение
texture_image_gray = np.zeros((128, 128), dtype=np.uint8)
for r_idx, r_val in enumerate(range(0, 128, 16)):
    for c_idx, c_val in enumerate(range(0, 128, 16)):
        val = 50 + ((r_idx + c_idx) % 2) * 150 # Шахматный узор
        texture_image_gray[r_val:r_val+16, c_val:c_val+16] = val

# Параметры для LBP
radius = 1      # Радиус окружности, на которой берутся соседи (1 - ближайшие 8 соседей)
n_points = 8 * radius # Количество точек-соседей (обычно 8, 16, 24)

# Вычисление LBP
# method='uniform': использует только "однородные" шаблоны (не более двух переходов 0->1 или 1->0 в бинарной строке).
# Это делает дескриптор более робастным к вращению и значительно уменьшает количество возможных LBP-кодов.
lbp_image = local_binary_pattern(texture_image_gray, n_points, radius, method='uniform')
lbp_image_display = lbp_image.astype(np.uint8) # Для визуализации (значения LBP могут быть > 255)

# Гистограмма LBP кодов как дескриптор текстуры
# Для 'uniform' метода с P точками, будет P+2 уникальных значения LBP
# (P однородных шаблонов, 1 для всех неоднородных, и 1 для центрального пикселя, если его сравнивают)
# Однако, skimage.feature.local_binary_pattern возвращает коды от 0 до n_points (для 'uniform'),
# и n_points+1 для всех неоднородных. Таким образом, n_bins = n_points + 2.
num_bins_lbp = int(lbp_image.max() + 1)
hist_lbp, _ = np.histogram(lbp_image.ravel(), bins=num_bins_lbp, range=(0, num_bins_lbp))

# Нормализация гистограммы (чтобы сумма была равна 1)
hist_lbp = hist_lbp.astype("float")
hist_lbp /= (hist_lbp.sum() + 1e-7) # + малое число для избежания деления на ноль

# print(f"LBP гистограмма (первые 10 бинов): {hist_lbp[:10]}")
# print(f"Всего бинов в LBP гистограмме: {len(hist_lbp)}")

# Визуализация
# plt.figure(figsize=(12, 6))
# plt.subplot(131), plt.imshow(texture_image_gray, cmap='gray'), plt.title('Исходная текстура')
# plt.subplot(132), plt.imshow(lbp_image_display, cmap='gray'), plt.title('LBP изображение')
# plt.subplot(133), plt.bar(np.arange(num_bins_lbp), hist_lbp), plt.title('LBP гистограмма')
# plt.tight_layout()
# plt.show()

Пример кода:

# OpenCV не имеет встроенной функции для "квилтинга" патчей.
# Это более сложный алгоритм, требующий отдельной реализации или использования специализированных библиотек.
# Ниже представлен псевдокод, описывающий основную идею.

"""
Функция PatchQuilting(образец_текстуры, размер_выходной_текстуры, размер_патча, размер_перекрытия):
  1. Инициализировать пустое выходное_изображение нужного размера.
  2. Скопировать случайный патч из образца_текстуры в левый верхний угол выходного_изображения.

  3. Для каждого следующего места под патч в выходном_изображении (проходя по нему, например, слева направо, сверху вниз):
     a. Определить область(и) перекрытия с уже размещенными патчами.
     b. Найти в образце_текстуры все патчи, которые могли бы подойти.
     c. Для каждого кандидата из образца, вычислить ошибку (например, сумму квадратов разностей пикселей) 
        в области(ях) перекрытия с уже синтезированной частью выходного_изображения.
     d. Выбрать патч-кандидат из образца, который дает минимальную ошибку (или один из нескольких лучших случайным образом).

     e. Если есть перекрытие (например, слева и/или сверху):
        i.  В области перекрытия между выбранным патчем-кандидатом и существующей частью 
            выходного_изображения, найти путь минимальной ошибки (шов). Это можно сделать 
            с помощью динамического программирования (похоже на поиск кратчайшего пути в графе).
        ii. Скопировать пиксели из патча-кандидата в выходное_изображение, используя найденный шов, 
            чтобы плавно соединить новый патч с существующим.
     f. Иначе (если нет перекрытия, например, для первого патча в строке/столбце, кроме самого первого):
        Просто скопировать выбранный патч-кандидат.

  4. Вернуть синтезированное выходное_изображение.
"""
# print("Метод квилтинга патчей концептуальный и требует кастомной реализации.")

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка изображения или создание тестового
# image_bgr = cv2.imread('book_in_scene.jpg')
# if image_bgr is None: print('Ошибка загрузки'); exit()

# Создадим тестовое изображение
image_bgr = np.zeros((300, 400, 3), dtype=np.uint8)
image_bgr.fill(200) # Светло-серый фон
cv2.ellipse(image_bgr, (150,150), (80,40), 30, 0, 360, (50,100,150), -1)
cv2.putText(image_bgr, "SIFT", (180, 180), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255,255,255), 3)

gray_image = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)

# Для использования SIFT может потребоваться установка opencv-contrib-python:
# pip install opencv-contrib-python
# В некоторых версиях OpenCV, SIFT и SURF могут быть недоступны из-за патентов,
# или находиться в модуле xfeatures2d.

image_with_sift_keypoints = image_bgr.copy()
try:
    # Пытаемся создать SIFT детектор
    sift = cv2.SIFT_create() # Для OpenCV 4.4+ (если есть contrib)
    # Если ошибка, пробуем старый путь для xfeatures2d (OpenCV 3.x, или 4.x с полным contrib)
    # if 'xfeatures2d' not in cv2.__dict__:
    #     sift = cv2.xfeatures2d.SIFT_create()

    # Обнаружение ключевых точек и вычисление дескрипторов
    # keypoints: список объектов cv2.KeyPoint
    # descriptors: NumPy массив, где каждая строка — 128-мерный вектор-дескриптор
    keypoints, descriptors = sift.detectAndCompute(gray_image, None) # None - без маски

    # Отрисовка ключевых точек на изображении
    # Флаг DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS рисует круги с размером и ориентацией
    image_with_sift_keypoints = cv2.drawKeypoints(gray_image, keypoints, image_bgr.copy(), 
                                            flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
    # print(f"Найдено SIFT ключевых точек: {len(keypoints)}")
    # if descriptors is not None:
    #     print(f"Размерность SIFT дескрипторов: {descriptors.shape}")

except AttributeError as e:
    print(f"SIFT не доступен в вашей сборке OpenCV: {e}. Пропускаем пример SIFT.")
    keypoints, descriptors = [], None # Устанавливаем пустые значения
except cv2.error as e: # Ловим cv2.error, если sift.create() не найден
    print(f"Ошибка при создании SIFT (возможно, модуль xfeatures2d не найден или SIFT запатентован): {e}")
    keypoints, descriptors = [], None

# Визуализация
# if keypoints: # Если точки были найдены
#    plt.figure(figsize=(8, 6))
#    plt.imshow(cv2.cvtColor(image_with_sift_keypoints, cv2.COLOR_BGR2RGB))
#    plt.title('SIFT Ключевые точки')
#    plt.show()
# else:
#    print("SIFT точки не были найдены или SIFT недоступен.")

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Используем то же тестовое изображение, что и для SIFT
image_bgr = np.zeros((300, 400, 3), dtype=np.uint8); image_bgr.fill(180)
cv2.ellipse(image_bgr, (200,150), (100,50), -20, 0, 360, (80,120,180), -1)
cv2.putText(image_bgr, "ORB", (80, 100), cv2.FONT_HERSHEY_SIMPLEX, 1.8, (255,255,0), 3)
gray_image = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)

# Инициализация ORB детектора
# nfeatures: Максимальное количество признаков для обнаружения (по умолчанию 500).
# scaleFactor: Коэффициент масштабирования пирамиды (по умолчанию 1.2).
# nlevels: Количество уровней пирамиды (по умолчанию 8).
# edgeThreshold: Размер границы, где признаки не детектируются.
# وغيرها من المعلمات...
orb = cv2.ORB_create(nfeatures=1000)

# Обнаружение ключевых точек и вычисление дескрипторов
# С ORB, detectAndCompute() является предпочтительным, так как он эффективнее, чем вызов detect() и compute() по отдельности.
keypoints_orb, descriptors_orb = orb.detectAndCompute(gray_image, None) # None - без маски

# Отрисовка ключевых точек ORB
image_with_orb_keypoints = cv2.drawKeypoints(gray_image, keypoints_orb, image_bgr.copy(), 
                                           color=(0,255,0), flags=0) # color - зеленый, flags=0 - простые круги

# print(f"Найдено ORB ключевых точек: {len(keypoints_orb)}")
# if descriptors_orb is not None:
#    print(f"Размерность ORB дескрипторов: {descriptors_orb.shape} (бинарные, 32 байта = 256 бит)")

# Визуализация
# plt.figure(figsize=(8, 6))
# plt.imshow(cv2.cvtColor(image_with_orb_keypoints, cv2.COLOR_BGR2RGB))
# plt.title('ORB Ключевые точки')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Создадим два "изображения" и извлечем из них ORB-признаки (для примера)
img1_gray = np.zeros((200,200), np.uint8); cv2.putText(img1_gray, "CV1", (50,100), cv2.FONT_HERSHEY_SIMPLEX, 2, 255, 3)
img2_gray = np.zeros((200,200), np.uint8); cv2.putText(img2_gray, "CV1", (60,110), cv2.FONT_HERSHEY_SIMPLEX, 2, 180, 3) # Чуть смещено и тусклее
cv2.circle(img2_gray, (150,50), 30, 120, -1) # Добавим лишний элемент

orb = cv2.ORB_create()
keypoints1, descriptors1 = orb.detectAndCompute(img1_gray, None)
keypoints2, descriptors2 = orb.detectAndCompute(img2_gray, None)

matches_list = []
if descriptors1 is not None and descriptors2 is not None and len(descriptors1)>0 and len(descriptors2)>0:
    # Инициализация BFMatcher.
    # cv2.NORM_HAMMING используется для бинарных дескрипторов (ORB, BRIEF, BRISK).
    # cv2.NORM_L1 или cv2.NORM_L2 для вещественных дескрипторов (SIFT, SURF).
    # crossCheck=True: Улучшает качество совпадений. Совпадение (i,j) считается, только если
    # дескриптор i из первого набора является лучшим совпадением для j из второго, И
    # дескриптор j из второго набора является лучшим совпадением для i из первого.
    bf_matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)

    # Сопоставление дескрипторов
    # matches = bf_matcher.match(queryDescriptors, trainDescriptors)
    matches_list = bf_matcher.match(descriptors1, descriptors2)

    # Сортировка совпадений по расстоянию (чем меньше расстояние, тем лучше совпадение)
    matches_list = sorted(matches_list, key=lambda x: x.distance)

    # Взять, например, 15 лучших совпадений для отрисовки
    num_good_matches_to_draw = min(len(matches_list), 15)
    
    # Отрисовка совпадений (для этого нужны исходные цветные изображения или их серые версии)
    # img_matches = cv2.drawMatches(img1_gray, keypoints1, img2_gray, keypoints2, 
    #                               matches_list[:num_good_matches_to_draw], None, 
    #                               flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
    # plt.figure(figsize=(10,5)), plt.imshow(img_matches), plt.title('Лучшие совпадения (BFMatcher, crossCheck=True)')
    # plt.show()
else:
    print("Недостаточно дескрипторов для сопоставления.")

# print(f"Найдено {len(matches_list)} совпадений после crossCheck.")

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Предположим, у нас есть 'matches_list' (отфильтрованный список DMatch объектов),
# 'keypoints1' и 'keypoints2' (списки KeyPoint объектов)
# Для примера, воспользуемся результатами из предыдущего кода
# (создадим img1_gray, img2_gray, kp1, des1, kp2, des2, matches_list как в примере выше)
img1_gray = np.zeros((200,200), np.uint8); cv2.putText(img1_gray, "CV1", (50,100), cv2.FONT_HERSHEY_SIMPLEX, 2, 255, 3)
img2_gray = np.zeros((200,200), np.uint8); cv2.putText(img2_gray, "CV1", (60,110), cv2.FONT_HERSHEY_SIMPLEX, 2, 180, 3)
cv2.circle(img2_gray, (150,50), 30, 120, -1)
orb = cv2.ORB_create(); kp1, des1 = orb.detectAndCompute(img1_gray, None); kp2, des2 = orb.detectAndCompute(img2_gray, None)
matches_list = []
if des1 is not None and des2 is not None and len(des1)>0 and len(des2)>0:
    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True); matches_list = bf.match(des1, des2)
    matches_list = sorted(matches_list, key=lambda x: x.distance)

MIN_MATCH_COUNT = 4 # Минимальное количество совпадений для вычисления гомографии
H_matrix = None
mask_ransac = None

if len(matches_list) >= MIN_MATCH_COUNT:
    # Извлечение координат сопоставленных точек
    src_pts = np.float32([ kp1[m.queryIdx].pt for m in matches_list ]).reshape(-1,1,2)
    dst_pts = np.float32([ kp2[m.trainIdx].pt for m in matches_list ]).reshape(-1,1,2)

    # Вычисление матрицы гомографии с использованием RANSAC
    # reprojThresh: Максимальное расстояние перепроекции (в пикселях) для اعتبار точки инлайером.
    #               Обычно от 1 до 10. Зависит от точности локализации признаков.
    # maxIters: Максимальное количество итераций RANSAC.
    # confidence: Желаемый уровень уверенности (0.0-1.0).
    H_matrix, mask_ransac = cv2.findHomography(src_pts, dst_pts, method=cv2.RANSAC, 
                                               reprojectionThreshold=5.0)

    # if H_matrix is not None:
    #     print("Матрица гомографии H, найденная с RANSAC:\n", H_matrix)
    #     num_inliers = np.sum(mask_ransac)
    #     print(f"Найдено инлайеров: {num_inliers} из {len(matches_list)}")

        # Пример отрисовки только инлайеров
        # draw_params = dict(matchColor = (0,255,0), # draw matches in green color
        #            singlePointColor = None,
        #            matchesMask = mask_ransac.ravel().tolist(), # draw only inliers
        #            flags = 2)
        # img_inliers = cv2.drawMatches(img1_gray,kp1,img2_gray,kp2,matches_list,None,**draw_params)
        # plt.imshow(img_inliers, 'gray'),plt.show()
    # else:
    #     print("Гомографию найти не удалось (RANSAC).")
else:
    print(f"Недостаточно совпадений для вычисления гомографии (найдено {len(matches_list)}, нужно {MIN_MATCH_COUNT})")

Пример кода:

import cv2
import numpy as np
import glob # Для поиска файлов по шаблону

# Концептуальный пример, так как реальная калибровка требует набора изображений
# и точного нахождения точек на них.

# 1. Подготовка: Определяем размеры шахматной доски (количество внутренних углов)
chessboard_size = (9, 6) # Например, 9x6 внутренних углов

# 2. Создание 3D-координат для точек объекта (углов шахматной доски в ее системе координат)
# Предполагаем, что доска лежит на плоскости Z=0, размеры квадратов, например, 1 (в любых единицах)
objp = np.zeros((chessboard_size[0] * chessboard_size[1], 3), np.float32)
objp[:,:2] = np.mgrid[0:chessboard_size[0], 0:chessboard_size[1]].T.reshape(-1,2)

# Массивы для хранения 3D-точек объекта и 2D-точек изображения со всех калибровочных изображений
object_points_list = [] # 3D точки в реальном мире
image_points_list = []  # 2D точки на плоскости изображения

# Загрузка калибровочных изображений (замените 'path/to/your/calibration_images/*.jpg' на реальный путь)
# image_files = glob.glob('path/to/your/calibration_images/*.jpg') 
# if not image_files: print("Не найдены изображения для калибровки."); exit()

# for fname in image_files: # Цикл по всем калибровочным изображениям
#     img = cv2.imread(fname)
#     gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#     # Найти углы шахматной доски
#     ret_corners, corners = cv2.findChessboardCorners(gray, chessboard_size, None)

#     # Если углы найдены, добавить точки объекта и точки изображения (после уточнения)
#     if ret_corners == True:
#         object_points_list.append(objp)
#         # Уточнение координат углов для большей точности
#         corners_refined = cv2.cornerSubPix(gray, corners, (11,11), (-1,-1), 
#                                          (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001))
#         image_points_list.append(corners_refined)
        
#         # Отрисовка найденных углов (опционально, для проверки)
#         # cv2.drawChessboardCorners(img, chessboard_size, corners_refined, ret_corners)
#         # cv2.imshow('Найденные углы', img)
#         # cv2.waitKey(500)

# cv2.destroyAllWindows()

# if len(object_points_list) > 0 and len(image_points_list) > 0:
#     # Выполнение калибровки камеры
#     # gray.shape[::-1] - это (ширина, высота) изображения
#     ret_calib, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera(
#         object_points_list, image_points_list, gray.shape[::-1], None, None
#     )

#     if ret_calib:
#         print("Камера успешно откалибрована.")
#         print("Матрица камеры (K):\n", camera_matrix)
#         print("Коэффициенты дисторсии (k1,k2,p1,p2,k3):\n", dist_coeffs)
#         # rvecs (rotation vectors) и tvecs (translation vectors) - внешние параметры для каждого изображения
#     else:
#         print("Калибровка не удалась.")
# else:
#     print("Недостаточно данных для калибровки (не найдены углы или нет изображений).")

print("Это концептуальный код. Для реальной калибровки нужны изображения шаблона.")
print("Пример camera_matrix: [[fx, 0, cx], [0, fy, cy], [0, 0, 1]]")
print("Пример dist_coeffs: [[k1, k2, p1, p2, k3]]")

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка изображения с искажениями
# distorted_image = cv2.imread('distorted_photo.jpg')
# if distorted_image is None: print('Ошибка загрузки'); exit()

# Создадим "искаженное" изображение для примера (линии должны стать прямыми после коррекции)
distorted_image = np.zeros((300,400,3), np.uint8); distorted_image.fill(255)
for i in range(0, 400, 40): cv2.line(distorted_image, (i,0), (int(i + i*0.1 - 20) ,299), (0,0,0), 1)
for i in range(0, 300, 40): cv2.line(distorted_image, (0,i), (399, int(i + i*0.1 - 15)), (0,0,0), 1)

# Предположим, у нас есть camera_matrix (K) и dist_coeffs из калибровки
# (Используйте реальные значения, полученные из cv2.calibrateCamera)
# Примерные значения (могут не соответствовать созданному выше изображению)
cam_matrix = np.array([[500., 0., 200.],[0., 500., 150.],[0.,0.,1.]], dtype=np.float32)
# k1, k2, p1, p2, k3 (пример сильной бочкообразной дисторсии)
dist_coeffs = np.array([[-0.5, 0.2, 0.001, 0.001, 0.05]], dtype=np.float32)

h, w = distorted_image.shape[:2]

# Оптимизация матрицы камеры для лучшего отображения после коррекции
# alpha=0: обрезает изображение, чтобы остались только валидные пиксели без черных областей.
# alpha=1: сохраняет все пиксели исходного изображения, могут появиться черные области по краям.
# roi (Region Of Interest) - это прямоугольник, который можно использовать для обрезки.
optimal_new_camera_matrix, roi = cv2.getOptimalNewCameraMatrix(cam_matrix, dist_coeffs, 
                                                              (w,h), alpha=1, newImgSize=(w,h))

# Устранение искажений
undistorted_img = cv2.undistort(distorted_image, cam_matrix, dist_coeffs, None, optimal_new_camera_matrix)

# Обрезка изображения по ROI, если alpha=0 или если хотим убрать черные края при alpha=1
# x_roi, y_roi, w_roi, h_roi = roi
# undistorted_img_cropped = undistorted_img[y_roi:y_roi+h_roi, x_roi:x_roi+w_roi]

# Визуализация
# plt.figure(figsize=(12, 6))
# plt.subplot(121), plt.imshow(cv2.cvtColor(distorted_image, cv2.COLOR_BGR2RGB)), plt.title('Искаженное изображение')
# plt.subplot(122), plt.imshow(cv2.cvtColor(undistorted_img, cv2.COLOR_BGR2RGB)), plt.title('Исправленное изображение')
# plt.show()
# Если используется undistorted_img_cropped, отображайте его.

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# 1. Подготовка данных (извлечение признаков)
# Предположим, у нас есть массив 'feature_vectors', где каждая строка - это вектор признаков для одного изображения.
# Для примера, создадим фиктивные 2D-данные, имитирующие 3 кластера.
np.random.seed(42) # для воспроизводимости
cluster1_data = np.random.randn(50, 2) + np.array([2, 2])  # 50 точек вокруг (2,2)
cluster2_data = np.random.randn(50, 2) + np.array([-2, -2]) # 50 точек вокруг (-2,-2)
cluster3_data = np.random.randn(50, 2) + np.array([2, -2]) # 50 точек вокруг (2,-2)

feature_vectors = np.vstack((cluster1_data, cluster2_data, cluster3_data))
# Данные должны быть типа float32 для cv2.kmeans
feature_vectors_float32 = np.float32(feature_vectors)

# 2. Применение K-Means
# Определение количества кластеров
K = 3

# Определение критериев остановки алгоритма:
# (тип_критерия, максимальное_число_итераций, желаемая_точность_эпсилон)
# cv2.TERM_CRITERIA_EPS: остановить, если центроиды сместились меньше чем на эпсилон.
# cv2.TERM_CRITERIA_MAX_ITER: остановить после макс. числа итераций.
# Здесь: остановить после 20 итераций ИЛИ если смещение < 0.5.
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 20, 0.5)

# Количество запусков алгоритма с разными начальными центроидами
# (выбирается лучший результат по компактности)
attempts = 10

# Флаг инициализации центроидов (можно cv2.KMEANS_RANDOM_CENTERS или cv2.KMEANS_PP_CENTERS)
# KMEANS_PP_CENTERS (k-means++) обычно дает лучшие результаты, чем случайная инициализация.
init_flag = cv2.KMEANS_PP_CENTERS

# Запуск K-Means
# compactness: Сумма квадратов расстояний от каждой точки до ее центра (чем меньше, тем лучше).
# labels: Массив меток кластеров (0, 1, ..., K-1) для каждой входной точки.
# centers: Координаты центров найденных кластеров.
compactness, labels, centers = cv2.kmeans(data=feature_vectors_float32, 
                                          K=K, 
                                          bestLabels=None,  # Выходной массив для меток, можно None
                                          criteria=criteria, 
                                          attempts=attempts, 
                                          flags=init_flag)

# print(f"Компактность (сумма кв. расстояний): {compactness:.2f}")
# print(f"Метки кластеров (первые 10): {labels.ravel()[:10]}")
# print(f"Центры кластеров:\n {centers}")

# 3. Визуализация результатов (для 2D-данных)
# plt.figure(figsize=(8, 6))
# colors_map = ['r', 'g', 'b', 'y', 'c', 'm'] # Цвета для кластеров
# for i in range(K):
#     # Выбираем точки, принадлежащие текущему кластеру i
#     cluster_points = feature_vectors_float32[labels.ravel() == i]
#     plt.scatter(cluster_points[:, 0], cluster_points[:, 1], 
#                 s=50, c=colors_map[i], label=f'Кластер {i+1}')

# plt.scatter(centers[:, 0], centers[:, 1], s=200, c='yellow', 
#             marker='X', edgecolors='black', label='Центроиды')
# plt.title('Результаты K-Means кластеризации')
# plt.xlabel('Признак 1'); plt.ylabel('Признак 2')
# plt.legend()
# plt.grid(True)
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# --- Шаг 1: Имитация извлечения дескрипторов из обучающего набора ---
# В реальном приложении здесь был бы цикл по изображениям и извлечение SIFT/ORB
np.random.seed(0)
num_training_images = 5
descriptors_per_image = 10
descriptor_dim = 64 # Для примера, ORB дескрипторы (обычно 32 байта, но для float kmeans лучше float дескрипторы)

all_descriptors_list = []
for _ in range(num_training_images):
    # Генерируем случайные float дескрипторы для имитации SIFT/SURF
    # (для ORB были бы uint8, но kmeans в OpenCV ожидает float32)
    # Если используете ORB, их нужно будет конвертировать в float32 для kmeans
    # или использовать матчер, работающий с NORM_HAMMING для назначения слов
    # Здесь для простоты используем float32
    img_descriptors = np.random.rand(descriptors_per_image, descriptor_dim).astype(np.float32)
    all_descriptors_list.append(img_descriptors)

# Объединяем все дескрипторы в один большой массив для кластеризации
if not all_descriptors_list:
    print("Нет дескрипторов для построения словаря.")
    exit()

all_descriptors_stacked = np.vstack(all_descriptors_list)

# --- Шаг 2: Создание визуального словаря с помощью K-Means ---
K_vocab_size = 10  # Размер словаря (количество визуальных слов)
if all_descriptors_stacked.shape[0] < K_vocab_size:
    print(f"Количество дескрипторов ({all_descriptors_stacked.shape[0]}) меньше размера словаря ({K_vocab_size}). Уменьшите размер словаря или добавьте дескрипторы.")
    exit()
    
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 20, 0.1)
compactness, labels_vocab, vocabulary = cv2.kmeans(all_descriptors_stacked, K_vocab_size, None, 
                                                 criteria, 10, cv2.KMEANS_PP_CENTERS)
# vocabulary - это наши визуальные слова (центроиды кластеров), размером (K_vocab_size, descriptor_dim)
# print(f"Словарь построен. Размер: {vocabulary.shape}")

# --- Шаг 3: Функция для представления изображения в виде BoVW-гистограммы ---
def compute_bovw_histogram(image_descriptors, vocabulary_centroids):
    if image_descriptors is None or len(image_descriptors) == 0:
        return np.zeros(len(vocabulary_centroids), dtype=np.float32)
    
    # Для каждого дескриптора изображения находим ближайшее слово в словаре
    # BFMatcher с NORM_L2 для float дескрипторов (SIFT, SURF-подобные)
    bf = cv2.BFMatcher(cv2.NORM_L2) 
    # Если бы vocabulary был из ORB (uint8), то NORM_HAMMING
    
    matches = bf.match(image_descriptors, vocabulary_centroids) 
    # bf.match() для каждого image_descriptor находит одно лучшее совпадение в vocabulary_centroids
    
    histogram = np.zeros(len(vocabulary_centroids), dtype=np.float32)
    for m in matches:
        # m.trainIdx - это индекс слова в словаре (т.к. vocabulary_centroids был 'trainDescriptors')
        histogram[m.trainIdx] += 1
    
    # Нормализация гистограммы (L1-норма)
    if np.sum(histogram) > 0:
      histogram /= np.sum(histogram)
    return histogram

# --- Пример использования для одного "нового" изображения ---
# Допустим, у нас есть дескрипторы для нового изображения
new_image_descriptors = np.random.rand(15, descriptor_dim).astype(np.float32) 
bovw_hist_for_new_image = compute_bovw_histogram(new_image_descriptors, vocabulary)

# print(f"BoVW гистограмма для нового изображения (первые {K_vocab_size} бинов):\n {bovw_hist_for_new_image}")

# plt.figure(figsize=(8,4))
# plt.bar(np.arange(K_vocab_size), bovw_hist_for_new_image)
# plt.title('BoVW гистограмма для нового изображения')
# plt.xlabel('Индекс визуального слова')
# plt.ylabel('Нормализованная частота')
# plt.show()

Пример кода:

from sklearn.svm import SVC # Support Vector Classifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np

# --- Имитация данных: BoVW-гистограммы и метки классов ---
# Предположим, у нас есть X_bovw (массив BoVW-гистограмм) и y_labels (массив меток)
# vocab_size должен соответствовать K_vocab_size из предыдущего шага
vocab_size_from_prev_step = 10 # K_vocab_size
num_total_images = 100

# Создаем фиктивные BoVW гистограммы
X_bovw = np.random.rand(num_total_images, vocab_size_from_prev_step)

# Создаем фиктивные метки классов (например, 2 класса: 0 и 1)
y_labels = np.array([0] * (num_total_images // 2) + [1] * (num_total_images - num_total_images // 2))
np.random.shuffle(y_labels) # Перемешиваем метки для реалистичности

# --- Разделение данных на обучающую и тестовую выборки ---
X_train, X_test, y_train, y_test = train_test_split(X_bovw, y_labels, 
                                                    test_size=0.25, # 25% данных на тест
                                                    random_state=42, # для воспроизводимости
                                                    stratify=y_labels) # для сохранения пропорций классов

# print(f"Размер обучающей выборки: {X_train.shape}, меток: {y_train.shape}")
# print(f"Размер тестовой выборки: {X_test.shape}, меток: {y_test.shape}")

# --- Инициализация и обучение SVM классификатора ---
# C: параметр регуляризации. Меньшее C - более "мягкая" граница, большее C - стремится классифицировать все точки правильно.
# kernel: тип ядра. 'linear', 'poly', 'rbf' (часто хороший выбор по умолчанию), 'sigmoid'.
# gamma: коэффициент ядра для 'rbf', 'poly', 'sigmoid'. 'scale' (1 / (n_features * X.var())) или 'auto' (1 / n_features).
svm_classifier = SVC(kernel='rbf', C=1.0, gamma='scale', probability=True, random_state=42)

# Обучение модели
svm_classifier.fit(X_train, y_train)

# --- Оценка качества модели на тестовой выборке ---
y_pred_test = svm_classifier.predict(X_test)
accuracy = accuracy_score(y_test, y_pred_test)
# print(f"Точность SVM на тестовой выборке: {accuracy:.4f}")

# --- Предсказание для нового изображения (представленного BoVW-гистограммой) ---
# Допустим, new_image_bovw_hist - это BoVW-гистограмма нового изображения
# (должна быть той же размерности vocab_size_from_prev_step)
# new_image_bovw_hist = np.random.rand(1, vocab_size_from_prev_step) 
# predicted_class = svm_classifier.predict(new_image_bovw_hist)
# predicted_probabilities = svm_classifier.predict_proba(new_image_bovw_hist)
# print(f"Предсказанный класс для нового изображения: {predicted_class[0]}")
# print(f"Вероятности классов для нового изображения: {predicted_probabilities[0]}")

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка изображения или создание тестового
# image_bgr = cv2.imread('colorful_image.jpg')
# if image_bgr is None: print('Ошибка загрузки'); exit()

# Создадим тестовое изображение
image_bgr = np.zeros((200, 300, 3), dtype=np.uint8)
# Левая треть - синяя
image_bgr[:, :100] = [255, 50, 50]  # BGR: Преимущественно синий
# Средняя треть - зеленая
image_bgr[:, 100:200] = [50, 255, 50] # BGR: Преимущественно зеленый
# Правая треть - красная
image_bgr[:, 200:] = [50, 50, 255]   # BGR: Преимущественно красный

# Параметры для гистограммы
num_bins_per_channel = 32  # Количество бинов (корзин) для каждого канала
color_channels = (0, 1, 2) # Индексы каналов (0-B, 1-G, 2-R)
color_ranges = [0, 256]    # Диапазон значений пикселей для каждого канала

# Вычисление гистограммы для каждого канала и их конкатенация
global_feature_vector = []

# plt.figure(figsize=(12, 4))
# colors = ('b', 'g', 'r')

for i, channel_index in enumerate(color_channels):
    # cv2.calcHist([images], [channels], mask, [histSize], [ranges])
    hist_channel = cv2.calcHist([image_bgr],          # Изображение (в списке)
                                [channel_index],      # Индекс канала
                                None,                 # Маска (None - по всему изображению)
                                [num_bins_per_channel], # Количество бинов
                                color_ranges)         # Диапазон значений
    
    # Нормализация гистограммы (L2 норма, чтобы вектор имел единичную длину)
    cv2.normalize(hist_channel, hist_channel, norm_type=cv2.NORM_L2)
    global_feature_vector.extend(hist_channel.flatten()) # Добавляем к общему вектору

    # Отрисовка гистограммы для текущего канала (опционально)
    # plt.subplot(1, len(color_channels), i + 1)
    # plt.plot(hist_channel, color=colors[i])
    # plt.xlim(color_ranges)
    # plt.title(f'Гистограмма канала {colors[i].upper()}')

# global_feature_vector теперь содержит конкатенированные нормализованные гистограммы
# Его длина будет num_bins_per_channel * len(color_channels)
global_feature_vector = np.array(global_feature_vector)

# print(f"Размер глобального вектора признаков (цвет. гистограмма): {global_feature_vector.shape[0]}")
# print(f"Первые 10 значений: {global_feature_vector[:10]}")

# plt.tight_layout()
# plt.show()

Пример кода:

from skimage.feature import hog # scikit-image предоставляет удобную реализацию HOG
from skimage import data, color, transform
import cv2 # Для загрузки и изменения размера, если нужно
import numpy as np
import matplotlib.pyplot as plt

# Загрузка тестового изображения из skimage или своего
# image_rgb = data.astronaut() # Пример из skimage
# image_rgb = cv2.imread('person_silhouette.jpg') # Загрузить свое
# if image_rgb is None: print('Ошибка загрузки'); exit()

# Создадим простое изображение с четкими градиентами
image_rgb = np.zeros((128, 64, 3), dtype=np.uint8)
image_rgb.fill(100)
cv2.rectangle(image_rgb, (10,10), (54, 118), (200,200,200), -1)

# HOG обычно работает с изображениями в градациях серого
image_gray = cv2.cvtColor(image_rgb, cv2.COLOR_BGR2GRAY) if len(image_rgb.shape) == 3 and image_rgb.shape[2] == 3 else image_rgb

# Опционально: изменение размера до фиксированного (часто делается для HOG)
# Например, классический HOG для детекции пешеходов использует размер 64x128
# resized_image_gray = transform.resize(image_gray, (128, 64)) # skimage.transform
resized_image_gray = cv2.resize(image_gray, (64, 128), interpolation=cv2.INTER_AREA)

# Вычисление HOG дескриптора
# orientations: Количество бинов для ориентаций градиента (обычно 8-9).
# pixels_per_cell: Размер ячейки в пикселях (например, (8, 8) или (16, 16)).
# cells_per_block: Количество ячеек в блоке для локальной нормализации контраста (например, (2, 2) или (3, 3)).
# block_norm: Метод нормализации ('L1', 'L2', 'L2-Hys' - L2 с последующим клиппингом и повторной нормализацией, часто лучший).
# visualize=True: также возвращает изображение для визуализации HOG.
fd, hog_image_visualization = hog(resized_image_gray, 
                                  orientations=9, 
                                  pixels_per_cell=(8, 8),
                                  cells_per_block=(2, 2), 
                                  visualize=True, 
                                  block_norm='L2-Hys',
                                  transform_sqrt=True) # Применение гамма-коррекции (sqrt)

# fd - это одномерный вектор признаков HOG для всего изображения (или окна)
# print(f"Размер HOG дескриптора: {fd.shape[0]}")
# print(f"Первые 10 значений HOG: {fd[:10]}")

# Визуализация HOG (если visualize=True)
# plt.figure(figsize=(10, 5))
# plt.subplot(121), plt.imshow(resized_image_gray, cmap='gray'), plt.title('Изображение (серое, изм. размер)')
# plt.subplot(122), plt.imshow(hog_image_visualization, cmap='gray'), plt.title('Визуализация HOG')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Создадим два изображения для сравнения
imageA = np.zeros((100, 100), dtype=np.uint8)
imageA[25:75, 25:75] = 150 # Серый квадрат

imageB_identical = imageA.copy() # Идентичное изображение

imageB_slightly_different = imageA.copy()
imageB_slightly_different[50,50] = 160 # Одно отличие в пикселе

imageB_very_different = np.zeros((100, 100), dtype=np.uint8)
imageB_very_different[0:50, 0:50] = 200 # Другой квадрат

imageB_shifted = np.roll(imageA, 5, axis=1) # Сдвинутое изображение

def calculate_mse(img1, img2):
    # Убедимся, что изображения одного размера
    if img1.shape != img2.shape:
        # print("Изображения должны быть одного размера для MSE.")
        # Можно добавить изменение размера, но это повлияет на MSE
        h,w = img1.shape[:2]
        img2 = cv2.resize(img2, (w,h))
        # return float('inf') # Или вызвать ошибку

    # MSE - это сумма квадратов разностей, деленная на количество пикселей
    err = np.sum((img1.astype("float") - img2.astype("float")) ** 2)
    err /= float(img1.shape[0] * img1.shape[1])
    return err

mse_identical = calculate_mse(imageA, imageB_identical)
mse_slight = calculate_mse(imageA, imageB_slightly_different)
mse_very_diff = calculate_mse(imageA, imageB_very_different)
mse_shifted = calculate_mse(imageA, imageB_shifted)

# print(f"MSE (ImageA vs Identical): {mse_identical:.2f}")
# print(f"MSE (ImageA vs Slightly Different): {mse_slight:.2f}")
# print(f"MSE (ImageA vs Very Different): {mse_very_diff:.2f}")
# print(f"MSE (ImageA vs Shifted): {mse_shifted:.2f}")

# plt.figure(figsize=(12,3))
# plt.subplot(141), plt.imshow(imageA, cmap='gray'), plt.title(f'A (MSE vs B_slight: {mse_slight:.0f})')
# plt.subplot(142), plt.imshow(imageB_slightly_different, cmap='gray'), plt.title('B_slight')
# plt.subplot(143), plt.imshow(imageB_very_different, cmap='gray'), plt.title(f'B_v_diff (MSE vs A: {mse_very_diff:.0f})')
# plt.subplot(144), plt.imshow(imageB_shifted, cmap='gray'), plt.title(f'B_shifted (MSE vs A: {mse_shifted:.0f})')
# plt.show()

Пример кода:

from skimage.metrics import structural_similarity as ssim_skimage # Используем skimage
import cv2
import numpy as np
import matplotlib.pyplot as plt

# Используем те же изображения, что и для MSE
imageA = np.zeros((100, 100), dtype=np.uint8); imageA[25:75, 25:75] = 150
imageB_identical = imageA.copy()
imageB_slightly_different = imageA.copy(); imageB_slightly_different[50,50] = 160
imageB_very_different = np.zeros((100, 100), dtype=np.uint8); imageB_very_different[0:50, 0:50] = 200
imageB_shifted = np.roll(imageA, 5, axis=1)

# Для SSIM из skimage, изображения должны быть как минимум 7x7 пикселей.
# data_range: диапазон значений пикселей (255 для uint8). Если None, оценивается из данных.
ssim_A_vs_identical, _ = ssim_skimage(imageA, imageB_identical, full=True, data_range=255)
ssim_A_vs_slight, diff_slight = ssim_skimage(imageA, imageB_slightly_different, full=True, data_range=255)
ssim_A_vs_very_diff, diff_very_diff = ssim_skimage(imageA, imageB_very_different, full=True, data_range=255)
ssim_A_vs_shifted, diff_shifted = ssim_skimage(imageA, imageB_shifted, full=True, data_range=255)

# print(f"SSIM (ImageA vs Identical): {ssim_A_vs_identical:.4f}")
# print(f"SSIM (ImageA vs Slightly Different): {ssim_A_vs_slight:.4f}")
# print(f"SSIM (ImageA vs Very Different): {ssim_A_vs_very_diff:.4f}")
# print(f"SSIM (ImageA vs Shifted): {ssim_A_vs_shifted:.4f}")

# Визуализация изображений разницы (diff_image)
# diff_image показывает, где SSIM обнаружил наибольшие структурные различия.
# Оно нормализовано skimage к диапазону [0,1], поэтому умножаем на 255 для отображения.
# diff_slight_display = (diff_slight * 255).astype("uint8")
# diff_very_diff_display = (diff_very_diff * 255).astype("uint8")
# diff_shifted_display = (diff_shifted * 255).astype("uint8")

# plt.figure(figsize=(12,6))
# plt.subplot(231), plt.imshow(imageA, cmap='gray'), plt.title(f'A (SSIM vs B_slight: {ssim_A_vs_slight:.2f})')
# plt.subplot(232), plt.imshow(imageB_slightly_different, cmap='gray'), plt.title('B_slight')
# plt.subplot(233), plt.imshow(diff_slight_display, cmap='gray'), plt.title('Diff A vs B_slight')
# plt.subplot(234), plt.imshow(imageB_shifted, cmap='gray'), plt.title(f'B_shifted (SSIM vs A: {ssim_A_vs_shifted:.2f})')
# plt.subplot(235), plt.imshow(diff_shifted_display, cmap='gray'), plt.title('Diff A vs B_shifted')
# plt.tight_layout()
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Создадим два "изображения" для демонстрации
img1_gray = np.zeros((200,200), np.uint8); cv2.putText(img1_gray, "OBJECT", (30,100), cv2.FONT_HERSHEY_SIMPLEX, 1.5, 255, 3)

img2_contains_object = img1_gray.copy() # img2 содержит тот же объект
img2_contains_object = np.roll(img2_contains_object, (10,15), axis=(0,1)) # немного сдвинем
img2_contains_object = cv2.resize(img2_contains_object, (180,180)) # немного изменим масштаб
noise = np.random.randint(0,50, size=img2_contains_object.shape, dtype=np.uint8)
img2_contains_object = cv2.add(img2_contains_object, noise) # добавим шум

img3_different = np.zeros((200,200), np.uint8); cv2.circle(img3_different, (100,100), 50, 200, -1)

# Инициализация детектора/дескриптора (например, ORB)
orb = cv2.ORB_create(nfeatures=500)

# Нахождение ключевых точек и дескрипторов
kp1, des1 = orb.detectAndCompute(img1_gray, None)
kp2, des2 = orb.detectAndCompute(img2_contains_object, None)
kp3, des3 = orb.detectAndCompute(img3_different, None)

def compare_by_features(d1, d2, kp_list1, kp_list2, img_ref1, img_ref2, ratio_thresh=0.75, draw_matches=False):
    if d1 is None or d2 is None or len(d1) == 0 or len(d2) == 0:
        return 0, None # Нет дескрипторов, сходство 0

    # Сопоставление с помощью BFMatcher и Lowe's Ratio Test
    bf = cv2.BFMatcher(cv2.NORM_HAMMING) # NORM_HAMMING для ORB
    matches_knn = bf.knnMatch(d1, d2, k=2) # Находим k=2 лучших совпадений

    good_matches = []
    for m, n in matches_knn:
        if len(matches_knn[0]) > 1 and m.distance < ratio_thresh * n.distance:
            good_matches.append(m)
    
    similarity_score = len(good_matches)
    
    drawn_matches_img = None
    if draw_matches:
        drawn_matches_img = cv2.drawMatches(img_ref1, kp_list1, img_ref2, kp_list2, 
                                            good_matches, None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
    return similarity_score, drawn_matches_img

# Сравнение img1 с img2 (должны быть похожи)
score12, matches_img12 = compare_by_features(des1, des2, kp1, kp2, img1_gray, img2_contains_object, draw_matches=True)
# print(f"Сходство (img1 vs img2_contains_object): {score12} хороших совпадений")

# Сравнение img1 с img3 (должны быть не похожи)
score13, matches_img13 = compare_by_features(des1, des3, kp1, kp3, img1_gray, img3_different, draw_matches=True)
# print(f"Сходство (img1 vs img3_different): {score13} хороших совпадений")

# Визуализация (если draw_matches=True)
# if matches_img12 is not None:
#    plt.figure(figsize=(10,5)), plt.imshow(matches_img12), plt.title(f'Matches 1-2 (Score: {score12})')
#    plt.show()
# if matches_img13 is not None:
#    plt.figure(figsize=(10,5)), plt.imshow(matches_img13), plt.title(f'Matches 1-3 (Score: {score13})')
#    plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка изображения
# image_bgr = cv2.imread('group_photo.jpg') # Загрузите фото с лицами
# if image_bgr is None: print('Ошибка загрузки изображения'); exit()

# Создадим тестовое изображение с "лицами"
image_bgr = np.zeros((300, 400, 3), dtype=np.uint8)
image_bgr.fill(180) # Фон
# "Лицо" 1
cv2.rectangle(image_bgr, (50, 50), (150, 180), (120,120,120), -1)
cv2.circle(image_bgr, (80,90), 10, (0,0,0), -1); cv2.circle(image_bgr, (120,90), 10, (0,0,0), -1)
# "Лицо" 2
cv2.rectangle(image_bgr, (220, 80), (300, 200), (100,100,100), -1)
cv2.circle(image_bgr, (240,120), 8, (0,0,0), -1); cv2.circle(image_bgr, (280,120), 8, (0,0,0), -1)

gray_image = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)

# Загрузка предварительно обученного каскада Хаара для детекции лиц
# Файлы .xml обычно находятся в директории данных OpenCV.
# Путь может отличаться в зависимости от вашей установки OpenCV.
# cv2.data.haarcascades должен указывать на правильную папку.
face_cascade_path = cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'

face_cascade = cv2.CascadeClassifier()
if not face_cascade.load(cv2.samples.findFile(face_cascade_path)):
    print(f"--! Ошибка загрузки каскада Хаара из: {face_cascade_path}")
    print("Убедитесь, что путь к файлу XML корректен и OpenCV установлен правильно.")
    exit(0)

# Детекция лиц на изображении
# scaleFactor: Насколько уменьшается размер изображения на каждом шаге масштабирования (e.g., 1.1 = 10%).
#              Меньшие значения увеличивают точность, но и время работы.
# minNeighbors: Сколько "соседей" (перекрывающихся обнаружений) должно быть у каждого кандидата,
#               чтобы он считался действительным лицом. Увеличивает надежность, убирает ложные срабатывания.
# minSize: Минимальный размер детектируемого объекта (ширина, высота) в пикселях.
faces_rects = face_cascade.detectMultiScale(gray_image, 
                                          scaleFactor=1.1, 
                                          minNeighbors=5, 
                                          minSize=(30, 30))

# print(f"Найдено {len(faces_rects)} лиц(а).")

# Отрисовка прямоугольников вокруг найденных лиц
image_with_detections = image_bgr.copy()
for (x, y, w, h) in faces_rects:
    cv2.rectangle(image_with_detections, (x, y), (x+w, y+h), (0, 255, 0), 2) # Зеленая рамка

# Визуализация
# plt.figure(figsize=(8, 6))
# plt.imshow(cv2.cvtColor(image_with_detections, cv2.COLOR_BGR2RGB))
# plt.title('Детекция лиц с помощью каскада Хаара')
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Этот код является концептуальным и требует наличия файлов модели:
# - .weights (веса модели)
# - .cfg (конфигурация архитектуры сети)
# - .names (файл с именами классов, по одному на строку)
# Эти файлы можно скачать для популярных моделей, таких как YOLOv3, YOLOv4-tiny и т.д.

# Пути к файлам модели (ЗАМЕНИТЕ НА СВОИ АКТУАЛЬНЫЕ ПУТИ)
# weights_path = "yolov3-tiny.weights" 
# config_path = "yolov3-tiny.cfg"
# names_path = "coco.names"

# image_path = "street_scene.jpg" # Загрузите изображение с объектами

# try:
#     net = cv2.dnn.readNet(weights_path, config_path) # Загрузка сети
#     with open(names_path, "r") as f: # Загрузка имен классов
#         classes = [line.strip() for line in f.readlines()]
# except cv2.error as e:
#     print(f"Ошибка загрузки модели YOLO: {e}")
#     print("Убедитесь, что пути к .weights и .cfg файлам верны и файлы существуют.")
#     exit()

# # Получение имен всех слоев сети и определение выходных слоев
# layer_names = net.getLayerNames()
# # В старых версиях OpenCV getUnconnectedOutLayers() возвращал массив массивов [[idx]], в новых - просто массив [idx]
# output_layers_indices = net.getUnconnectedOutLayers()
# if isinstance(output_layers_indices, np.ndarray) and output_layers_indices.ndim > 1:
#     output_layers_indices = output_layers_indices.flatten()
# output_layers = [layer_names[i - 1] for i in output_layers_indices]

# image = cv2.imread(image_path)
# if image is None: print(f"Ошибка загрузки изображения: {image_path}"); exit()
# height, width, _ = image.shape

# # Создание blob из изображения (предобработка для YOLO)
# # (0.00392 = 1/255 - нормализация, (416,416) - типичный размер входа для YOLO, swapRB=True т.к. OpenCV BGR)
# blob = cv2.dnn.blobFromImage(image, scalefactor=0.00392, size=(416, 416), mean=(0, 0, 0), swapRB=True, crop=False)
# net.setInput(blob)
# outs = net.forward(output_layers) # Прямой проход, получение предсказаний

# # Обработка результатов (декодирование выходов сети)
# class_ids = []
# confidences = []
# boxes = []
# conf_threshold = 0.5 # Порог уверенности для детекции
# nms_threshold = 0.4  # Порог для Non-Maximum Suppression

# for out_detection_layer in outs: # outs - это список выходов с каждого output_layer
#     for detection in out_detection_layer: # detection - вектор предсказаний для одной рамки
#         # detection[0:4] - координаты рамки (center_x, center_y, width, height) - нормированные
#         # detection[4] - уверенность в наличии объекта (objectness score)
#         # detection[5:] - уверенности для каждого класса
#         scores = detection[5:]
#         class_id = np.argmax(scores)
#         confidence = scores[class_id]
#         if confidence > conf_threshold:
#             center_x = int(detection[0] * width)
#             center_y = int(detection[1] * height)
#             w_box = int(detection[2] * width)
#             h_box = int(detection[3] * height)
#             x_box = int(center_x - w_box / 2)
#             y_box = int(center_y - h_box / 2)
#             boxes.append([x_box, y_box, w_box, h_box])
#             confidences.append(float(confidence))
#             class_ids.append(class_id)

# # Применение Non-Maximum Suppression для удаления дублирующихся рамок
# indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_threshold, nms_threshold)

# image_with_dnn_detections = image.copy()
# if len(indices) > 0:
#     # В старых версиях OpenCV indices мог быть массивом массивов
#     final_indices = indices.flatten() if isinstance(indices, np.ndarray) and indices.ndim > 1 else indices
#     for i in final_indices:
#         box = boxes[i]
#         x, y, w, h = box[0], box[1], box[2], box[3]
#         label = str(classes[class_ids[i]])
#         confidence_val = confidences[i]
#         color = (0, 255, 0) # Зеленый
#         cv2.rectangle(image_with_dnn_detections, (x, y), (x + w, y + h), color, 2)
#         cv2.putText(image_with_dnn_detections, f"{label} {confidence_val:.2f}", (x, y - 10 if y > 20 else y + h + 15), 
#                     cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)

# plt.figure(figsize=(10, 8))
# plt.imshow(cv2.cvtColor(image_with_dnn_detections, cv2.COLOR_BGR2RGB))
# plt.title('Детекция объектов с помощью YOLO (OpenCV DNN)')
# plt.show()

print("Это концептуальный код для YOLO/SSD с OpenCV DNN. Требуются файлы модели.")

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка изображения или создание тестового
# gray_image = cv2.imread('document_scan.png', cv2.IMREAD_GRAYSCALE)
# if gray_image is None: print('Ошибка загрузки'); exit()

# Создадим тестовое изображение с объектом на фоне разной яркости
gray_image = np.zeros((200, 300), dtype=np.uint8)
gray_image[:, :150] = 80 # Левая часть фона темнее
gray_image[:, 150:] = 160 # Правая часть фона светлее
# Объект (темнее фона слева, светлее фона справа)
cv2.rectangle(gray_image, (50,50), (250,150), 120, -1)

# 1. Простая глобальная пороговая обработка
# ret: само пороговое значение (здесь оно задано нами как 127)
# thresh_binary: результат - бинарное изображение
# cv2.THRESH_BINARY: если пиксель > порога, то max_val, иначе 0
# cv2.THRESH_BINARY_INV: если пиксель > порога, то 0, иначе max_val
global_threshold_value = 100
max_pixel_value = 255
ret, thresh_binary_global = cv2.threshold(gray_image, global_threshold_value, max_pixel_value, cv2.THRESH_BINARY)

# 2. Адаптивная пороговая обработка
# Порог вычисляется для каждого пикселя на основе его небольшой окрестности.
# Это хорошо работает для изображений с изменяющимися условиями освещения.
# cv2.ADAPTIVE_THRESH_MEAN_C: порог - среднее значение окрестности минус константа C.
# cv2.ADAPTIVE_THRESH_GAUSSIAN_C: порог - Гауссово взвешенное среднее окрестности минус C.
# blockSize: размер окрестности (должен быть нечетным, >1).
# C: константа, вычитаемая из среднего или взвешенной суммы.
block_size_adaptive = 15 # Должен быть нечетным
constant_C = 5
thresh_adaptive_mean = cv2.adaptiveThreshold(gray_image, max_pixel_value, 
                                            cv2.ADAPTIVE_THRESH_MEAN_C, 
                                            cv2.THRESH_BINARY, 
                                            block_size_adaptive, constant_C)

# 3. Метод Оцу (Otsu's Binarization)
# Автоматически вычисляет оптимальное глобальное пороговое значение из гистограммы изображения.
# Хорошо работает, если гистограмма имеет два пика (бимодальная).
# Возвращает оптимальный порог (ret_otsu) и бинарное изображение.
ret_otsu, thresh_otsu = cv2.threshold(gray_image, 0, max_pixel_value, 
                                      cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# print(f"Оптимальный порог по Оцу: {ret_otsu}")

# Визуализация
# titles = ['Исходное серое', f'Глобальный порог ({global_threshold_value})', 
#           f'Адаптивный средний (Блок {block_size_adaptive}, C={constant_C})', f'Оцу (Порог={ret_otsu:.0f})']
# images_to_show = [gray_image, thresh_binary_global, thresh_adaptive_mean, thresh_otsu]
# plt.figure(figsize=(15, 5))
# for i in range(len(images_to_show)):
#     plt.subplot(1, len(images_to_show), i + 1)
#     plt.imshow(images_to_show[i], cmap='gray')
#     plt.title(titles[i])
#     plt.xticks([]), plt.yticks([])
# plt.tight_layout()
# plt.show()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Этот код является концептуальным и требует наличия файла обученной модели U-Net
# (например, .pb, .onnx) и понимания ее входных/выходных форматов.

# Путь к модели (ЗАМЕНИТЕ НА СВОЙ АКТУАЛЬНЫЙ ПУТЬ К МОДЕЛИ U-NET)
# model_path = "path/to/your/u-net-model.onnx"
# image_path = "image_for_segmentation.jpg"

# # Предполагаемые параметры модели (могут отличаться для вашей модели)
# INPUT_WIDTH = 256
# INPUT_HEIGHT = 256
# NUM_CLASSES = 2 # Например, фон + объект

# try:
#     net = cv2.dnn.readNet(model_path) # Загрузка сети (для ONNX: cv2.dnn.readNetFromONNX)
# except cv2.error as e:
#     print(f"Ошибка загрузки модели U-Net: {e}")
#     exit()

# original_image = cv2.imread(image_path)
# if original_image is None: print(f"Ошибка загрузки изображения: {image_path}"); exit()
# h_orig, w_orig = original_image.shape[:2]

# # 1. Предобработка изображения
# # Изменение размера до ожидаемого моделью, нормализация, создание blob
# blob = cv2.dnn.blobFromImage(original_image, scalefactor=1.0/255.0, 
#                                size=(INPUT_WIDTH, INPUT_HEIGHT), 
#                                mean=(0,0,0), swapRB=True, crop=False)
# net.setInput(blob)

# # 2. Прямой проход через сеть
# # Выходной слой U-Net обычно имеет форму (batch_size, num_classes, height, width)
# output_logits = net.forward() # Имя выходного слоя может потребоваться явно указать для некоторых моделей

# # 3. Постобработка выхода
# # output_logits[0] - берем предсказания для первого (и единственного) изображения в батче
# # np.argmax(output_logits[0], axis=0) - для каждого пикселя находим класс с максимальной вероятностью
# class_map = np.argmax(output_logits[0], axis=0) # (height_out, width_out)

# # Изменение размера карты классов обратно к исходному размеру изображения
# # Используем cv2.INTER_NEAREST, чтобы не вводить промежуточные значения классов
# class_map_resized = cv2.resize(class_map.astype(np.uint8), 
#                                  (w_orig, h_orig), 
#                                  interpolation=cv2.INTER_NEAREST)

# # 4. Визуализация (раскрашивание сегментов)
# # Создадим палитру цветов для классов (здесь для NUM_CLASSES=2: фон-черный, объект-зеленый)
# colors = np.array([[0,0,0], [0,255,0]], dtype=np.uint8) if NUM_CLASSES == 2 else 
#          np.random.randint(0, 255, size=(NUM_CLASSES, 3), dtype=np.uint8)

# segmented_visualization = colors[class_map_resized]

# # Наложение маски на исходное изображение для наглядности
# alpha = 0.6
# blended_image = cv2.addWeighted(original_image, alpha, segmented_visualization, 1-alpha, 0)

# plt.figure(figsize=(12, 6))
# plt.subplot(121), plt.imshow(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)), plt.title('Исходное изображение')
# plt.subplot(122), plt.imshow(cv2.cvtColor(blended_image, cv2.COLOR_BGR2RGB)), plt.title('Семантическая сегментация (U-Net)')
# plt.show()

print("Это концептуальный код для семантической сегментации с U-Net. Требует обученной модели.")

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Загрузка видео или создание двух кадров для примера
# cap = cv2.VideoCapture('slow_traffic_small.mp4')
# ret, old_frame_bgr = cap.read()
# if not ret: print('Не удалось прочитать видео/кадр'); exit()
# old_gray = cv2.cvtColor(old_frame_bgr, cv2.COLOR_BGR2GRAY)

# Создадим два кадра: old_gray и new_gray со смещенным объектом
old_frame_bgr = np.zeros((200, 300, 3), dtype=np.uint8); old_frame_bgr.fill(50)
cv2.rectangle(old_frame_bgr, (100, 75), (150, 125), (200,200,200), -1)
old_gray = cv2.cvtColor(old_frame_bgr, cv2.COLOR_BGR2GRAY)

new_frame_bgr = np.zeros((200, 300, 3), dtype=np.uint8); new_frame_bgr.fill(50)
cv2.rectangle(new_frame_bgr, (110, 80), (160, 130), (200,200,200), -1) # Смещенный
new_gray = cv2.cvtColor(new_frame_bgr, cv2.COLOR_BGR2GRAY)

# --- Шаг 1: Найти характерные точки на первом кадре (например, углы Ши-Томаси) ---
# Параметры для детектора углов ShiTomasi
# maxCorners: максимальное количество углов для возврата.
# qualityLevel: минимально допустимое качество угла (0-1).
# minDistance: минимальное евклидово расстояние между возвращаемыми углами.
# blockSize: размер окна для вычисления производных.
feature_params = dict(maxCorners=100, qualityLevel=0.3, minDistance=7, blockSize=7)
p0 = cv2.goodFeaturesToTrack(old_gray, mask=None, **feature_params)

if p0 is None:
    print("Не найдено точек для отслеживания на первом кадре.")
    exit()

# --- Шаг 2: Вычислить оптический поток с помощью Лукаса-Канаде ---
# Параметры для оптического потока Лукаса-Канаде
# winSize: размер окна поиска на каждом уровне пирамиды.
# maxLevel: 0-based максимальный уровень пирамиды (0 - только исходное изображение, без пирамиды).
# criteria: критерии остановки итеративного поиска (точность и/или макс. число итераций).
lk_params = dict(winSize=(15,15), maxLevel=2, 
                 criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))

# p1: вычисленные новые положения точек p0 на втором кадре (new_gray).
# st: статусный вектор (1, если поток для соответствующей точки найден, 0 иначе).
# err: вектор ошибок (не всегда используется).
p1, status, error = cv2.calcOpticalFlowPyrLK(old_gray, new_gray, p0, None, **lk_params)

# --- Шаг 3: Отобрать "хорошие" точки (для которых поток найден) ---
# status.ravel()==1 создает булеву маску
good_new_points = p1[status.ravel() == 1] if p1 is not None else np.array([])
good_old_points = p0[status.ravel() == 1] if p0 is not None else np.array([])

# --- Шаг 4: Визуализация (рисование векторов потока) ---
# Создание маски для рисования траекторий
flow_visualization_mask = np.zeros_like(old_frame_bgr)
output_frame_with_flow = new_frame_bgr.copy() # Рисуем на втором кадре

for i, (new_pt, old_pt) in enumerate(zip(good_new_points, good_old_points)):
    a, b = new_pt.ravel().astype(int)
    c, d = old_pt.ravel().astype(int)
    # Рисуем линию от старой позиции к новой
    flow_visualization_mask = cv2.line(flow_visualization_mask, (a,b), (c,d), (0,255,0), 2) # Зеленая линия
    # Рисуем кружок в новой позиции точки
    output_frame_with_flow = cv2.circle(output_frame_with_flow, (a,b), 5, (0,0,255), -1) # Красный кружок

combined_display = cv2.add(output_frame_with_flow, flow_visualization_mask)

# plt.figure(figsize=(10, 7))
# plt.imshow(cv2.cvtColor(combined_display, cv2.COLOR_BGR2RGB))
# plt.title('Разреженный оптический поток (Лукас-Канаде)')
# plt.show()

# В цикле обработки видео:
# old_gray = new_gray.copy()
# p0 = good_new_points.reshape(-1, 1, 2) # Новые точки становятся старыми для следующего шага

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Используем те же два кадра, что и для Лукаса-Канаде
old_frame_bgr = np.zeros((200, 300, 3), dtype=np.uint8); old_frame_bgr.fill(50)
cv2.rectangle(old_frame_bgr, (100, 75), (150, 125), (200,200,200), -1)
prvs_gray = cv2.cvtColor(old_frame_bgr, cv2.COLOR_BGR2GRAY)

new_frame_bgr = np.zeros((200, 300, 3), dtype=np.uint8); new_frame_bgr.fill(50)
cv2.rectangle(new_frame_bgr, (110, 80), (160, 130), (200,200,200), -1) # Смещенный
next_gray = cv2.cvtColor(new_frame_bgr, cv2.COLOR_BGR2GRAY)

# Вычисление плотного оптического потока Фарнебека
# flow: Выходной массив потока (размер как у next_gray, 2 канала: dx, dy).
# pyr_scale: Масштаб пирамиды (<1, например, 0.5 для классической пирамиды).
# levels: Количество уровней пирамиды.
# winsize: Размер окна усреднения; большие значения дают более гладкий, но размытый поток.
# iterations: Количество итераций на каждом уровне пирамиды.
# poly_n: Размер окрестности пикселя для полиномиальной аппроксимации (5 или 7).
# poly_sigma: Стандартное отклонение Гауссианы для сглаживания производных (1.1 для poly_n=5, 1.5 для poly_n=7).
# flags: Флаги операции (0 по умолчанию, или cv2.OPTFLOW_USE_INITIAL_FLOW, cv2.OPTFLOW_FARNEBACK_GAUSSIAN).
flow_vectors = cv2.calcOpticalFlowFarneback(prvs_gray, next_gray, None, 
                                          pyr_scale=0.5, levels=3, winsize=15, 
                                          iterations=3, poly_n=5, poly_sigma=1.1, flags=0)

# Визуализация плотного оптического потока (преобразование векторов в цвета HSV)
# mag: величина (скорость) смещения.
# ang: угол (направление) смещения.
mag, ang_rad = cv2.cartToPolar(flow_vectors[...,0], flow_vectors[...,1])

# Создаем HSV изображение для визуализации
hsv_viz_mask = np.zeros_like(old_frame_bgr) # (высота, ширина, 3 канала)
# Устанавливаем насыщенность (Saturation) в максимум для ярких цветов
hsv_viz_mask[..., 1] = 255

# Угол определяет Тон (Hue) - цвет на цветовом круге
hsv_viz_mask[..., 0] = ang_rad * 180 / np.pi / 2 # Преобразование радиан в диапазон 0-179 для OpenCV Hue

# Величина определяет Яркость (Value) - чем быстрее движение, тем ярче
hsv_viz_mask[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)

# Преобразование из HSV в BGR для отображения
bgr_flow_visualization = cv2.cvtColor(hsv_viz_mask, cv2.COLOR_HSV2BGR)

# plt.figure(figsize=(10, 7))
# plt.imshow(cv2.cvtColor(bgr_flow_visualization, cv2.COLOR_BGR2RGB))
# plt.title('Плотный оптический поток (Фарнебек) - HSV визуализация')
# plt.show()

# В цикле обработки видео:
# prvs_gray = next_gray.copy()

Пример кода:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# 1. 3D-координаты точек объекта в его собственной системе координат (object_points)
# Например, для простого прямоугольного объекта (как маркер или лицевая сторона коробки)
# Предположим, начало координат объекта в его левом верхнем углу, ось X вправо, Y вниз.
object_points_3d = np.array([
                            (0.0, 0.0, 0.0),    # Левый верхний
                            (10.0, 0.0, 0.0),   # Правый верхний (ширина 10 ед.)
                            (10.0, 5.0, 0.0),   # Правый нижний (высота 5 ед.)
                            (0.0, 5.0, 0.0)     # Левый нижний
                           ], dtype=np.float64)

# 2. Соответствующие 2D-координаты этих точек на изображении (image_points)
# Эти точки нужно было бы найти на реальном изображении (например, детекцией углов маркера)
# Здесь приведем фиктивные данные, имитирующие перспективную проекцию
image_points_2d = np.array([
                            (100, 100), # Левый верхний на изображении
                            (300, 120), # Правый верхний
                            (280, 250), # Правый нижний
                            (80, 220)   # Левый нижний
                           ], dtype=np.float64)

# 3. Матрица камеры (K) и коэффициенты дисторсии (dist_coeffs)
# (Предположим, они получены из калибровки камеры - см. Билет 11)
# Для примера возьмем идеальную камеру (без дисторсии) и примерные параметры
image_height, image_width = 300, 400 # Примерные размеры изображения
focal_length_guess = image_width
camera_matrix = np.array([[focal_length_guess, 0, image_width/2],
                           [0, focal_length_guess, image_height/2],
                           [0, 0, 1]], dtype=np.float64)
dist_coeffs = np.zeros((4,1)) # Нулевые коэффициенты дисторсии

# Решение PnP задачи
# flags: метод решения, например, cv2.SOLVEPNP_ITERATIVE, cv2.SOLVEPNP_EPNP, cv2.SOLVEPNP_P3P, cv2.SOLVEPNP_SQPNP
success, rotation_vector, translation_vector = cv2.solvePnP(
    object_points_3d, image_points_2d, camera_matrix, dist_coeffs, flags=cv2.SOLVEPNP_ITERATIVE
)

if success:
    # print("Поза объекта успешно оценена (solvePnP).")
    # print("Вектор вращения (Rodrigues):\n", rotation_vector)
    # print("Вектор смещения (относительно камеры):\n", translation_vector)

    # Для визуализации можно спроецировать оси координат объекта на изображение
    axis_length = 3.0 # Длина осей для отрисовки
    object_axes_3d = np.float32([[0,0,0], [axis_length,0,0], [0,axis_length,0], [0,0,-axis_length]]).reshape(-1,3)
    image_axes_points_2d, _ = cv2.projectPoints(object_axes_3d, rotation_vector, translation_vector, 
                                                camera_matrix, dist_coeffs)
    
    # Создание изображения для демонстрации
    # display_image = np.zeros((image_height, image_width, 3), dtype=np.uint8); display_image.fill(200)
    # for pt in image_points_2d.astype(int):
    #     cv2.circle(display_image, tuple(pt), 5, (0,0,255), -1) # Красные - точки на изображении
    
    # pt_origin = tuple(image_axes_points_2d[0].ravel().astype(int))
    # pt_x_axis = tuple(image_axes_points_2d[1].ravel().astype(int))
    # pt_y_axis = tuple(image_axes_points_2d[2].ravel().astype(int))
    # pt_z_axis = tuple(image_axes_points_2d[3].ravel().astype(int))

    # cv2.line(display_image, pt_origin, pt_x_axis, (255,0,0), 2) # X-ось синяя
    # cv2.line(display_image, pt_origin, pt_y_axis, (0,255,0), 2) # Y-ось зеленая
    # cv2.line(display_image, pt_origin, pt_z_axis, (0,0,255), 2) # Z-ось красная

    # plt.imshow(cv2.cvtColor(display_image, cv2.COLOR_BGR2RGB))
    # plt.title('Оценка позы объекта (PnP) и проекция осей')
    # plt.show()

    # Пример с solvePnPRansac
    # success_r, rvec_r, tvec_r, inliers = cv2.solvePnPRansac(
    #     object_points_3d, image_points_2d, camera_matrix, dist_coeffs, iterationsCount=100, reprojectionError=8.0)
    # if success_r:
    #     print(f"solvePnPRansac: успех, {len(inliers) if inliers is not None else 0} инлайеров")
else:
    print("Оценка позы не удалась (solvePnP).")

Пример кода:

# Для использования MoveNet напрямую из TensorFlow Hub требуется TensorFlow.
# OpenCV DNN может запускать ONNX-версии MoveNet или других моделей оценки позы.
# Ниже приведен концептуальный код, иллюстрирующий идею работы с такой моделью через OpenCV DNN.
# Для этого потребуется скачать .onnx файл модели (например, MoveNet SinglePose Lightning/Thunder).

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Путь к ONNX модели MoveNet (ЗАМЕНИТЕ НА СВОЙ ПУТЬ)
# model_onnx_path = "path/to/your/movenet_model.onnx"
# image_path = "person_standing.jpg"

# # Параметры, специфичные для модели MoveNet (могут отличаться для разных версий)
# MOVENET_INPUT_SIZE = 192 # Lightning: 192, Thunder: 256
# KEYPOINT_NAMES = [
#     "nose", "left_eye", "right_eye", "left_ear", "right_ear",
#     "left_shoulder", "right_shoulder", "left_elbow", "right_elbow",
#     "left_wrist", "right_wrist", "left_hip", "right_hip",
#     "left_knee", "right_knee", "left_ankle", "right_ankle"
# ]
# # Соединения для отрисовки скелета (пары индексов KEYPOINT_NAMES)
# SKELETON_CONNECTIONS = [
#     (0,1), (0,2), (1,3), (2,4), # Голова
#     (5,6), (5,7), (7,9), (6,8), (8,10), # Руки
#     (5,11), (6,12), (11,12), # Торс
#     (11,13), (13,15), (12,14), (14,16) # Ноги
# ]
# KEYPOINT_CONFIDENCE_THRESHOLD = 0.3

# try:
#     net = cv2.dnn.readNetFromONNX(model_onnx_path)
# except cv2.error as e:
#     print(f"Ошибка загрузки ONNX модели: {e}")
#     exit()

# original_image = cv2.imread(image_path)
# if original_image is None: print(f"Ошибка загрузки изображения: {image_path}"); exit()
# h_orig, w_orig = original_image.shape[:2]

# # 1. Предобработка изображения
# input_image_resized = cv2.resize(original_image, (MOVENET_INPUT_SIZE, MOVENET_INPUT_SIZE))
# # Модели MoveNet обычно ожидают uint8 или float32 тензор, нормализация не всегда нужна,
# # или специфична. Для TF Lite моделей часто [0,255] uint8.
# # Для ONNX может быть float32 и нормализация -1 до 1 или 0 до 1.
# # В данном примере предполагаем, что модель ожидает uint8 [0,255] и сама делает нормализацию.
# # blob = cv2.dnn.blobFromImage(input_image_resized, size=(MOVENET_INPUT_SIZE, MOVENET_INPUT_SIZE), swapRB=False, ddepth=cv2.CV_8U)
# # Для моделей, ожидающих float и нормализацию:
# blob = cv2.dnn.blobFromImage(input_image_resized, scalefactor=1.0/255.0, 
#                                size=(MOVENET_INPUT_SIZE, MOVENET_INPUT_SIZE), 
#                                mean=(0,0,0), swapRB=True, crop=False) # Пример для float
# net.setInput(blob)

# # 2. Прямой проход
# # Выход MoveNet: (1, 1, 17, 3) -> (batch, num_instances, num_keypoints, [y, x, score])
# # Координаты y,x нормированы к [0,1] относительно входного размера (MOVENET_INPUT_SIZE)
# output_data = net.forward()

# # 3. Извлечение ключевых точек и их уверенностей
# keypoints_with_scores = output_data[0, 0, :, :]

# # 4. Визуализация
# image_with_pose = original_image.copy()
# for i in range(len(KEYPOINT_NAMES)):
#     y_norm, x_norm, score = keypoints_with_scores[i]
#     if score > KEYPOINT_CONFIDENCE_THRESHOLD:
#         # Перевод нормированных координат в координаты исходного изображения
#         x_coord = int(x_norm * w_orig)
#         y_coord = int(y_norm * h_orig)
#         cv2.circle(image_with_pose, (x_coord, y_coord), 5, (0, 255, 0), -1) # Зеленые точки
#         # cv2.putText(image_with_pose, f"{KEYPOINT_NAMES[i]} ({score:.2f})", (x_coord+7, y_coord-7), 
#         #             cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0,0,255), 1)

# for (idx1, idx2) in SKELETON_CONNECTIONS:
#     y1, x1, score1 = keypoints_with_scores[idx1]
#     y2, x2, score2 = keypoints_with_scores[idx2]
#     if score1 > KEYPOINT_CONFIDENCE_THRESHOLD and score2 > KEYPOINT_CONFIDENCE_THRESHOLD:
#         pt1 = (int(x1 * w_orig), int(y1 * h_orig))
#         pt2 = (int(x2 * w_orig), int(y2 * h_orig))
#         cv2.line(image_with_pose, pt1, pt2, (255, 0, 0), 2) # Синие линии скелета

# plt.figure(figsize=(8, 10))
# plt.imshow(cv2.cvtColor(image_with_pose, cv2.COLOR_BGR2RGB))
# plt.title('Оценка позы человека (MoveNet через OpenCV DNN)')
# plt.show()

print("Это концептуальный код для оценки позы человека. Требует обученной ONNX модели.")