Обработка изображений в реальном времени на C# с OpenCV

C:\opencv\
  ├── build\
  │   ├── bin\
  │   ├── etc\
  │   ├── include\
  │   └── ...
  ├── sources\
  └── ...

Install-Package OpenCvSharp4
Install-Package OpenCvSharp4.runtime.win

using OpenCvSharp;
 
// Создаём пустое чёрное изображение 800x600
using var img = new Mat(600, 800, MatType.CV_8UC3, Scalar.Black);
 
// Рисуем белый текст
Cv2.PutText(img, "OpenCV работает!", new Point(50, 300), 
            HersheyFonts.HersheyComplex, 2, Scalar.White, 2);
 
// Показываем изображение в окне
using var window = new Window("Тест OpenCV", WindowFlags.AutoSize);
window.ShowImage(img);
Cv2.WaitKey();

// Инициализация детектора лиц
using var faceCascade = new CascadeClassifier("haarcascade_frontalface_default.xml");
 
// Захват изображения с камеры
using var capture = new VideoCapture(0);
var frame = new Mat();
 
while (true)
{
    capture.Read(frame);
    if (frame.Empty()) break;
    
    // Преобразование в оттенки серого для ускорения обработки
    var grayFrame = new Mat();
    Cv2.CvtColor(frame, grayFrame, ColorConversionCodes.BGR2GRAY);
    
    // Обнаружение лиц
    var faces = faceCascade.DetectMultiScale(
        grayFrame, 
        1.1,     // Фактор масштабирования
        5,       // Минимальное количество соседей
        0,       // Флаги (не используются)
        new Size(30, 30) // Минимальный размер лица
    );
    
    // Отрисовка прямоугольников вокруг лиц
    foreach (var face in faces)
    {
        Cv2.Rectangle(frame, face, Scalar.Red, 2);
    }
    
    Cv2.ImShow("Faces", frame);
    if (Cv2.WaitKey(1) == 27) break; // ESC для выхода
}

using var faceNet = CvDnn.ReadNetFromCaffe("deploy.prototxt", "res10_300x300_ssd_iter_140000.caffemodel");
 
// В цикле обработки кадров
using var blob = CvDnn.BlobFromImage(frame, 1.0, new Size(300, 300), 
                                     new Scalar(104, 177, 123), false, false);
faceNet.SetInput(blob);
using var detection = faceNet.Forward();
 
var detections = new Mat(detection.Size(2), detection.Size(3), MatType.CV_32F, 
                         detection.Ptr(0));
 
for (int i = 0; i < detections.Rows; i++)
{
    float confidence = detections.At<float>(i, 2);
    if (confidence > 0.5)
    {
        // Извлечение координат
        int x1 = (int)(detections.At<float>(i, 3) * frame.Width);
        int y1 = (int)(detections.At<float>(i, 4) * frame.Height);
        int x2 = (int)(detections.At<float>(i, 5) * frame.Width);
        int y2 = (int)(detections.At<float>(i, 6) * frame.Height);
        
        Cv2.Rectangle(frame, new Point(x1, y1), new Point(x2, y2), Scalar.Green, 2);
    }
}

var recognizer = LBPHFaceRecognizer.Create();
 
// Обучение на заранее подготовленном наборе лиц
var faceImages = new List<Mat>(); // Загруженные изображения лиц
var faceLabels = new List<int>(); // Соответствующие метки (ID людей)
 
// Заполнение этих списков опущено для краткости
recognizer.Train(faceImages.ToArray(), faceLabels.ToArray());
 
// В цикле обработки при обнаружении лица:
using var faceROI = new Mat(grayFrame, face);
var result = recognizer.Predict(faceROI);
int personId = result.Label;
double confidence = result.Confidence;

// Инициализация трекера
var tracker = TrackerKCF.Create();
 
// Определение начальной области для отслеживания (ROI)
var frame = new Mat();
capture.Read(frame);
var roi = Cv2.SelectROI("Tracking", frame);
tracker.Init(frame, roi);
 
while (true)
{
    capture.Read(frame);
    if (frame.Empty()) break;
    
    // Обновление позиции объекта
    bool success = tracker.Update(frame, out var newBox);
    
    if (success)
    {
        // Отрисовка новой позиции объекта
        Cv2.Rectangle(frame, newBox, Scalar.Blue, 2);
    }
    
    Cv2.ImShow("Tracking", frame);
    if (Cv2.WaitKey(30) == 27) break;
}

// Предварительная обработка для сегментации водоразделом
var markers = new Mat(frame.Size(), MatType.CV_32S, Scalar.All(0));
 
// Здесь обычно идёт код для маркировки известных областей
// Для простоты опустим его
 
// Применение алгоритма водораздела
Cv2.Watershed(frame, markers);
 
// Визуализация результатов
var segmentation = new Mat(frame.Size(), MatType.CV_8UC3, Scalar.Black);
for (int i = 0; i < markers.Rows; i++)
{
    for (int j = 0; j < markers.Cols; j++)
    {
        int idx = markers.At<int>(i, j);
        if (idx > 0 && idx <= 255)
        {
            segmentation.Set(i, j, new Scalar(idx, idx, idx));
        }
    }
}

// Загрузка предобученной модели Mask R-CNN
using var net = CvDnn.ReadNetFromTensorflow("frozen_inference_graph.pb", "mask_rcnn_inception_v2_coco_2018_01_28.pbtxt");
 
// В цикле обработки кадров
using var blob = CvDnn.BlobFromImage(frame, 1.0, new Size(frame.Width, frame.Height));
net.SetInput(blob);
 
// Получение результатов детекции и сегментации
using var boxes = net.Forward("detection_out_final");
using var masks = net.Forward("detection_masks");
 
// Дальнейшая обработка для наложения масок на изображение
// Код опущен из-за сложности

// Предварительная обработка изображения для OCR
var grayImage = new Mat();
Cv2.CvtColor(frame, grayImage, ColorConversionCodes.BGR2GRAY);
Cv2.Threshold(grayImage, grayImage, 0, 255, ThresholdTypes.Binary | ThresholdTypes.Otsu);
 
// Использование Tesseract через API
using var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default);
using var pix = Pix.LoadFromFile("processed_image.png");
using var page = engine.Process(pix);
string text = page.GetText();

using var textNet = CvDnn.ReadNet("frozen_east_text_detection.pb");
var blob = CvDnn.BlobFromImage(frame, 1.0, new Size(320, 320), 
                             new Scalar(123.68, 116.78, 103.94), true, false);
textNet.SetInput(blob);
 
// Получение выходных слоёв
string[] outNames = { "feature_fusion/Conv_7/Sigmoid", "feature_fusion/concat_3" };
var outputs = outNames.Select(n => new Mat()).ToArray();
textNet.Forward(outputs, outNames);
 
// Обработка выходных данных для определения областей текста
var scores = outputs[0];
var geometry = outputs[1];
 
// Дальнейшая обработка для извлечения прямоугольников с текстом

// Простое применение гауссова размытия
Cv2.GaussianBlur(frame, blurred, new Size(5, 5), 0);
 
// Более продвинутое размытие с сохранением краёв (билатеральный фильтр)
Cv2.BilateralFilter(frame, filtered, 9, 75, 75);

// Создание структурного элемента
var kernel = Cv2.GetStructuringElement(MorphShapes.Rect, new Size(5, 5));
 
// Применение операций "эрозия" и "наращивание"
Cv2.Erode(binaryFrame, eroded, kernel);
Cv2.Dilate(binaryFrame, dilated, kernel);
 
// Для удаления мелких объектов зачастую достаточно операции открытия
Cv2.MorphologyEx(binaryFrame, opened, MorphTypes.Open, kernel);

// Эквализация гистограммы (работает только для одноканальных изображений)
Cv2.EqualizeHist(grayFrame, equalized);
 
// Для цветных изображений можно использовать CLAHE
using var clahe = Cv2.CreateCLAHE(2.0, new Size(8, 8));
clahe.Apply(grayFrame, enhanced);

// Загрузка модели для суперразрешения
using var srNet = CvDnn.ReadNetFromCaffe("FSRCNN_x4.prototxt", "FSRCNN_x4.caffemodel");
 
// Преобразование входного изображения в блоб
var blob = CvDnn.BlobFromImage(lowResImage, 1.0 / 255);
srNet.SetInput(blob);
 
// Получение изображения в 4 раза большего разрешения
using var outputBlob = srNet.Forward();
 
// Преобразование выходного блоба обратно в изображение
var highResImage = new Mat(lowResImage.Rows * 4, lowResImage.Cols * 4, MatType.CV_8UC3);
// ... (Код преобразования формата опущен)

// Загрузка предобученной модели для классификации
using var classifierNet = CvDnn.ReadNetFromONNX("resnet50.onnx");
 
// В цикле обработки кадров
// Преобразование изображения в формат, ожидаемый сетью
var blob = CvDnn.BlobFromImage(frame, 1.0/255, new Size(224, 224), 
                             new Scalar(0.485, 0.456, 0.406), true, false);
classifierNet.SetInput(blob);
 
// Получение вектора вероятностей классов
using var probs = classifierNet.Forward();
 
// Нахождение класса с максимальной вероятностью
Point maxLoc = new Point();
double maxVal = 0;
Cv2.MinMaxLoc(probs.Reshape(1, 1), out _, out maxVal, out _, out maxLoc);
int classId = maxLoc.X;
 
// Загрузка меток классов и отображение результата
string[] classNames = File.ReadAllLines("imagenet_classes.txt");
Cv2.PutText(frame, classNames[classId], new Point(10, 30), 
          HersheyFonts.HersheyComplex, 1, Scalar.Red);

// Пример определения пола с использованием предобученной модели
using var genderNet = CvDnn.ReadNetFromCaffe("gender_deploy.prototxt", 
                                         "gender_net.caffemodel");
 
// Для каждого обнаруженного лица
foreach (var face in faces)
{
    using var faceROI = new Mat(frame, face);
    var blob = CvDnn.BlobFromImage(faceROI, 1.0, new Size(227, 227),
                                 new Scalar(78.4263377603, 87.7689143744, 114.895847746),
                                 false, false);
    genderNet.SetInput(blob);
    using var genderPreds = genderNet.Forward();
    float maleProb = genderPreds.At<float>(0, 0);
    float femaleProb = genderPreds.At<float>(0, 1);
    string gender = maleProb > femaleProb ? "Мужчина" : "Женщина";
    
    Cv2.PutText(frame, gender, new Point(face.X, face.Y - 10),
              HersheyFonts.HersheyTriplex, 1, Scalar.Yellow, 2);
}

using System.Collections.Concurrent;
using System.Threading.Tasks;
 
// Коллекция для передачи кадров между потоками
BlockingCollection<Mat> frameQueue = new BlockingCollection<Mat>(capacity: 5);
 
// Задача для захвата кадров
Task captureTask = Task.Run(() =>
{
    using var capture = new VideoCapture(0);
    while (!tokenSource.IsCancellationRequested)
    {
        var frame = new Mat();
        if (capture.Read(frame))
        {
            // Добавляем кадр в очередь (блокируется при достижении capacity)
            frameQueue.Add(frame.Clone());
        }
        else
        {
            Thread.Sleep(10);
        }
    }
    frameQueue.CompleteAdding();
});
 
// Задача для обработки кадров
Task processingTask = Task.Run(() =>
{
    foreach (var frame in frameQueue.GetConsumingEnumerable())
    {
        using (frame) // Важно освобождать ресурсы!
        {
            // Тут происходит вся магия обработки...
            Cv2.CvtColor(frame, frame, ColorConversionCodes.BGR2GRAY);
            
            // Отправляем в UI поток через диспетчер
            Application.Current.Dispatcher.Invoke(() =>
            {
                ImageControl.Source = frame.ToBitmapSource();
            });
        }
    }
});

// Перенос вычислений на GPU
using var srcGpu = new GpuMat();
using var dstGpu = new GpuMat();
 
// Загрузка изображения на GPU
srcGpu.Upload(srcMat);
 
// Создание GPU-версии фильтра Гаусса
using var gaussFilter = new CudaGaussianFilter(srcGpu.Type(), 
                                            dstGpu.Type(), 
                                            new Size(5, 5), 3.5);
// Применение фильтра
gaussFilter.Apply(srcGpu, dstGpu);
 
// Выгрузка результата обратно в CPU-память
dstGpu.Download(dstMat);

// Инициализация несколько CUDA-алгоритмов для конвейерной обработки
using var bgSegmenter = CudaBackgroundSubtractorMOG2.Create();
using var cudaEnhancer = CudaCLAHE.Create(4.0);
using var cudaDetector = CudaHOG.Create(new Size(64, 128));
 
// Оптимизация: создаём и переиспользуем GpuMat
using var frameGpu = new GpuMat();
using var fgMaskGpu = new GpuMat();
using var enhancedGpu = new GpuMat();
 
while (ProcessFrames)
{
    // Захват и загрузка
    capture.Read(frame);
    frameGpu.Upload(frame);
    
    // CUDA-оптимизированный конвейер: 
    // 1. Выделение переднего плана
    bgSegmenter.Apply(frameGpu, fgMaskGpu);
    
    // 2. Улучшение контраста в областях интереса
    cudaEnhancer.Apply(frameGpu, enhancedGpu);
    
    // 3. Нахождение людей через HOG-детектор
    var foundLocations = new Point[0];
    cudaDetector.Detect(enhancedGpu, ref foundLocations);
    
    // Выгрузка результатов обратно в память CPU
    enhancedGpu.Download(enhancedFrame);
}

// Правильное управление ресурсами
using (var tempMat = new Mat())
{
    Cv2.CvtColor(frame, tempMat, ColorConversionCodes.BGR2HSV);
    // ...работаем с tempMat
} // tempMat автоматически освобождается здесь

class MatPool : IDisposable
{
    private readonly ConcurrentBag<Mat> _pool = new ConcurrentBag<Mat>();
    
    public Mat Get(Size size, MatType type)
    {
        if (_pool.TryTake(out var mat))
        {
            if (mat.Size() == size && mat.Type() == type)
                return mat;
            
            mat.Dispose(); // Размер или тип не подходят, освобождаем
        }
        
        return new Mat(size, type);
    }
    
    public void Return(Mat mat)
    {
        if (mat != null && !mat.IsDisposed)
            _pool.Add(mat);
    }
    
    public void Dispose()
    {
        foreach (var mat in _pool)
            mat?.Dispose();
        
        _pool.Clear();
    }
}

// Упрощённая реализация каскадного подхода
var movement = motionDetector.Detect(frame);
if (movement.Any())
{
    var rectangles = rectangleDetector.FindCandidates(frame, movement);
    foreach (var rect in rectangles)
    {
        using var roi = new Mat(frame, rect);
        if (roi.Width < 30 || roi.Height < 10) continue; // Фильтрация по размеру
        
        // Только теперь применяем тяжёлую нейросеть к маленькой области
        var isLicensePlate = neuralNetwork.Predict(roi) > 0.9;
        if (isLicensePlate)
        {
            // Дальнейшая обработка...
        }
    }
}

// Быстрое вычисление средней яркости с использованием SIMD
public unsafe float CalculateAverageBrightness(Mat grayImage)
{
    var sum = 0f;
    var data = grayImage.DataPointer;
    var length = grayImage.Width * grayImage.Height;
    
    // Обрабатываем данные блоками по 8 элементов
    fixed (byte* ptr = &data[0])
    {
        int vectorSize = Vector<byte>.Count;
        int vectorCount = length / vectorSize;
        
        for (int i = 0; i < vectorCount; i++)
        {
            var byteVector = new Vector<byte>(ptr + i * vectorSize);
            var floatVector = Vector.ConvertToSingle(byteVector);
            sum += Vector.Sum(floatVector);
        }
        
        // Обработка оставшихся элементов
        for (int i = vectorCount * vectorSize; i < length; i++)
        {
            sum += ptr[i];
        }
    }
    
    return sum / length;
}

private Rect? _lastFaceLocation;
 
private Rect[] DetectFacesWithCache(Mat frame)
{
    // Если у нас есть информация о предыдущем местоположении
    if (_lastFaceLocation.HasValue)
    {
        // Создаём расширенную область поиска
        var searchRect = ExpandRect(_lastFaceLocation.Value, 1.5);
        
        // Проверяем, что область в пределах кадра
        searchRect = EnsureRectInFrame(searchRect, frame.Size());
        
        // Извлекаем ROI и ищем в нём
        using var roi = new Mat(frame, searchRect);
        var faces = _faceDetector.DetectMultiScale(roi);
        
        // Если нашли лицо, корректируем координаты и обновляем кеш
        if (faces.Length > 0)
        {
            // Преобразуем координаты обратно в полное изображение
            var adjustedFaces = faces.Select(f => new Rect(
                f.X + searchRect.X,
                f.Y + searchRect.Y,
                f.Width,
                f.Height
            )).ToArray();
            
            _lastFaceLocation = adjustedFaces[0];
            return adjustedFaces;
        }
    }
    
    // Если не удалось найти с помощью кеша, сканируем всё изображение
    var detectedFaces = _faceDetector.DetectMultiScale(frame);
    
    if (detectedFaces.Length > 0)
        _lastFaceLocation = detectedFaces[0];
    else
        _lastFaceLocation = null;
    
    return detectedFaces;
}

private double _targetProcessingTime = 33.0; // ~30 FPS
private double _currentScale = 1.0;
private const double ScaleAdjustStep = 0.05;
 
private Mat ProcessFrameAdaptively(Mat frame)
{
    var stopwatch = Stopwatch.StartNew();
    
    // Масштабируем входное изображение
    var scaledFrame = new Mat();
    if (_currentScale < 0.99)
    {
        Cv2.Resize(frame, scaledFrame, 
            new Size(frame.Width * _currentScale, frame.Height * _currentScale));
    }
    else
    {
        scaledFrame = frame.Clone();
    }
    
    // Выполняем обработку
    var result = HeavyImageProcessing(scaledFrame);
    
    // Если нужно, увеличиваем обратно до исходного размера
    if (_currentScale < 0.99)
    {
        var finalResult = new Mat();
        Cv2.Resize(result, finalResult, frame.Size());
        result.Dispose();
        result = finalResult;
    }
    
    // Адаптируем масштаб на основе измеренного времени
    stopwatch.Stop();
    double processingTime = stopwatch.Elapsed.TotalMilliseconds;
    
    // Если обработка занимает слишком много времени, уменьшаем масштаб
    if (processingTime > _targetProcessingTime * 1.1)
    {
        _currentScale = Math.Max(0.3, _currentScale - ScaleAdjustStep);
    }
    // Если есть запас по времени, постепенно увеличиваем масштаб
    else if (processingTime < _targetProcessingTime * 0.7 && _currentScale < 1.0)
    {
        _currentScale = Math.Min(1.0, _currentScale + ScaleAdjustStep / 2);
    }
    
    return result;
}

private DefectAnalysisResult AnalyzeSolderJoint(Mat source)
{
    using var hsv = new Mat();
    Cv2.CvtColor(source, hsv, ColorConversionCodes.BGR2HSV);
    
    // Выделение областей припоя по цвету
    using var mask = new Mat();
    Cv2.InRange(hsv, new Scalar(20, 40, 80), new Scalar(45, 180, 255), mask);
    
    // Морфологические операции для удаления шумов
    var kernel = Cv2.GetStructuringElement(MorphShapes.Ellipse, new Size(3, 3));
    Cv2.MorphologyEx(mask, mask, MorphTypes.Open, kernel);
    
    // Поиск контуров
    Point[][] contours;
    HierarchyIndex[] hierarchy;
    Cv2.FindContours(mask, out contours, out hierarchy, 
                    RetrievalModes.External, ContourApproximationModes.ApproxSimple);
    
    // Анализ формы и площади каждого контура
    var defects = new List<Defect>();
    foreach (var contour in contours)
    {
        double area = Cv2.ContourArea(contour);
        if (area < 50) continue; // Игнорируем мелкие шумы
        
        // Анализ выпуклости контура
        var hull = Cv2.ConvexHull(contour);
        double hullArea = Cv2.ContourArea(hull);
        double solidity = area / hullArea;
        
        // Дефектом считаем припой с низкой "плотностью"
        if (solidity < 0.8)
        {
            defects.Add(new Defect { 
                Type = DefectType.PoorSoldering,
                Location = BoundingBox(contour),
                Confidence = 1.0 - solidity
            });
        }
    }
    
    return new DefectAnalysisResult { Defects = defects };
}

// Простая реализация гибридного подхода
private async Task<AnalysisResult> ProcessFrameHybrid(Mat frame)
{
    // Шаг 1: Быстрая локальная обработка через OpenCV
    var grayFrame = new Mat();
    Cv2.CvtColor(frame, grayFrame, ColorConversionCodes.BGR2GRAY);
    
    // Обнаружение движения и людей
    var persons = _localDetector.DetectPersons(frame);
    if (persons.Count == 0)
    {
        return new AnalysisResult { ActivityDetected = false };
    }
    
    // Шаг 2: Если обнаружена активность, анализируем подробнее через облако
    if (ShouldProcessInCloud(persons))
    {
        // Преобразуем Mat в формат, пригодный для отправки в API
        byte[] imageBytes;
        Cv2.ImEncode(".jpg", frame, out imageBytes);
        
        // Отправляем в облачный сервис
        var cloudResult = await _visionService.AnalyzeImageAsync(
            imageBytes, 
            new List<VisualFeatureTypes> 
            { 
                VisualFeatureTypes.Objects,
                VisualFeatureTypes.Tags
            }
        );
        
        // Объединяем результаты локального и облачного анализа
        return CombineResults(persons, cloudResult);
    }
    
    return new AnalysisResult 
    { 
        ActivityDetected = true,
        PersonCount = persons.Count
    };
}

public class CloudVisionCache : IDisposable
{
    private readonly Dictionary<string, Tuple<DateTime, AnalysisResult>> _cache 
        = new Dictionary<string, Tuple<DateTime, AnalysisResult>>();
    private readonly TimeSpan _cacheLifetime;
 
    public CloudVisionCache(TimeSpan cacheLifetime)
    {
        _cacheLifetime = cacheLifetime;
    }
 
    public bool TryGetResult(Mat image, out AnalysisResult result)
    {
        // Создаём простой хеш изображения для использования в качестве ключа
        string imageHash = ComputeSimpleHash(image);
        
        if (_cache.TryGetValue(imageHash, out var cachedItem))
        {
            if (DateTime.Now - cachedItem.Item1 < _cacheLifetime)
            {
                result = cachedItem.Item2;
                return true;
            }
            // Удаляем устаревшие записи
            _cache.Remove(imageHash);
        }
        
        result = null;
        return false;
    }
 
    public void AddResult(Mat image, AnalysisResult result)
    {
        string imageHash = ComputeSimpleHash(image);
        _cache[imageHash] = Tuple.Create(DateTime.Now, result);
        
        // Для упрощения пропустим очистку кеша от старых записей
    }
 
    private string ComputeSimpleHash(Mat image)
    {
        // Упрощённая версия - масштабируем до крошечного размера и хешируем
        using var smallImage = new Mat();
        Cv2.Resize(image, smallImage, new Size(16, 16));
        
        using var grayImage = new Mat();
        Cv2.CvtColor(smallImage, grayImage, ColorConversionCodes.BGR2GRAY);
        
        // Создаём простой хеш на основе яркости пикселей
        var hashBuilder = new StringBuilder();
        for (int y = 0; y < grayImage.Rows; y++)
        {
            for (int x = 0; x < grayImage.Cols; x++)
            {
                hashBuilder.Append(grayImage.At<byte>(y, x) > 128 ? "1" : "0");
            }
        }
        
        return hashBuilder.ToString();
    }
 
    public void Dispose()
    {
        _cache.Clear();
    }
}

public static class ContourExtensions
{
    // Расширение для вычисления соотношения сторон контура
    public static double AspectRatio(this Point[] contour)
    {
        var boundingRect = Cv2.BoundingRect(contour);
        return (double)boundingRect.Width / boundingRect.Height;
    }
    
    // Расширение для проверки, является ли контур прямоугольным
    public static bool IsRectangular(this Point[] contour, double threshold = 0.8)
    {
        var hull = Cv2.ConvexHull(contour);
        var boundingRect = Cv2.BoundingRect(contour);
        
        // Площадь выпуклой оболочки должна быть близка к площади прямоугольника
        double hullArea = Cv2.ContourArea(hull);
        double rectArea = boundingRect.Width * boundingRect.Height;
        
        return (hullArea / rectArea) >= threshold;
    }
    
    // Расширение для фильтрации контуров по размеру
    public static Point[][] FilterBySize(this Point[][] contours, int minArea, int maxArea = int.MaxValue)
    {
        return contours.Where(contour => {
            double area = Cv2.ContourArea(contour);
            return area >= minArea && area <= maxArea;
        }).ToArray();
    }
    
    // Расширение для вычисления несколько характерстик контура одним проходом
    public static ContourMetrics GetMetrics(this Point[] contour)
    {
        var boundingRect = Cv2.BoundingRect(contour);
        var area = Cv2.ContourArea(contour);
        var hull = Cv2.ConvexHull(contour);
        var hullArea = Cv2.ContourArea(hull);
        var perimeter = Cv2.ArcLength(contour, true);
        
        return new ContourMetrics
        {
            Area = area,
            BoundingRect = boundingRect,
            Perimeter = perimeter,
            Solidity = area / hullArea,
            Circularity = (4 * Math.PI * area) / (perimeter * perimeter)
        };
    }
}
 
// Вспомогательный класс для хранения метрик контура
public class ContourMetrics
{
    public double Area { get; set; }
    public Rect BoundingRect { get; set; }
    public double Perimeter { get; set; }
    public double Solidity { get; set; }  // Отношение площади к площади выпуклой оболочки
    public double Circularity { get; set; }  // Насколько форма близка к кругу
}

var boundingRect = Cv2.BoundingRect(contour);
var aspectRatio = (double)boundingRect.Width / boundingRect.Height;

var aspectRatio = contour.AspectRatio();

public class EnhancedMotionDetector
{
    private BackgroundSubtractorMOG2 _backgroundSubtractor;
    private Mat _fgMask;
    private Mat _kernel;
    private double _lastUpdateTime;
    private readonly double _learningRate;
    private readonly int _history;
    
    public EnhancedMotionDetector(double learningRate = 0.005, int history = 500)
    {
        _learningRate = learningRate;
        _history = history;
        _backgroundSubtractor = BackgroundSubtractorMOG2.Create(
            history: history,
            varThreshold: 16,
            detectShadows: true
        );
        _fgMask = new Mat();
        _kernel = Cv2.GetStructuringElement(
            MorphShapes.Ellipse, 
            new Size(3, 3)
        );
        _lastUpdateTime = Cv2.GetTickCount() / Cv2.GetTickFrequency();
    }
    
    public Mat DetectMotion(Mat frame)
    {
        // Применяем размытие для уменьшения шума
        var blurredFrame = new Mat();
        Cv2.GaussianBlur(frame, blurredFrame, new Size(5, 5), 0);
        
        // Вычисляем адаптивный learning rate
        double currentTime = Cv2.GetTickCount() / Cv2.GetTickFrequency();
        double timeDelta = currentTime - _lastUpdateTime;
        _lastUpdateTime = currentTime;
        
        // Адаптируем learning rate на основе временного интервала
        double adaptiveLearningRate = Math.Min(
            _learningRate * (timeDelta * 30), // Нормализация для 30 FPS
            1.0
        );
        
        // Обновляем модель фона
        _backgroundSubtractor.Apply(blurredFrame, _fgMask, adaptiveLearningRate);
        
        // Пост-обработка для уменьшения шума и заполнения дырок
        Cv2.MorphologyEx(_fgMask, _fgMask, MorphTypes.Open, _kernel);
        Cv2.MorphologyEx(_fgMask, _fgMask, MorphTypes.Close, _kernel);
        
        // Применяем пороговую фильтрацию для выделения областей движения
        var thresholdMask = new Mat();
        Cv2.Threshold(_fgMask, thresholdMask, 128, 255, ThresholdTypes.Binary);
        
        return thresholdMask;
    }
    
    public Point[][] GetMotionContours(Mat frame, out Mat processedMask)
    {
        processedMask = DetectMotion(frame);
        
        // Находим контуры движущихся объектов
        Point[][] contours;
        HierarchyIndex[] hierarchy;
        Cv2.FindContours(
            processedMask, 
            out contours, 
            out hierarchy, 
            RetrievalModes.External, 
            ContourApproximationModes.ApproxSimple
        );
        
        // Отфильтровываем маленькие контуры (шум)
        return contours.FilterBySize(100);
    }
    
    public void Reset()
    {
        // Сбрасываем модель фона
        _backgroundSubtractor = BackgroundSubtractorMOG2.Create(
            history: _history,
            varThreshold: 16,
            detectShadows: true
        );
    }
    
    public void Dispose()
    {
        _fgMask?.Dispose();
        _kernel?.Dispose();
    }
}

using var motionDetector = new EnhancedMotionDetector();
using var capture = new VideoCapture(0);
var frame = new Mat();
 
while (true)
{
    capture.Read(frame);
    if (frame.Empty()) break;
    
    Mat processedMask;
    var motionContours = motionDetector.GetMotionContours(frame, out processedMask);
    
    // Визуализация результатов
    foreach (var contour in motionContours)
    {
        Cv2.DrawContours(frame, new[] { contour }, 0, Scalar.Red, 2);
    }
    
    Cv2.ImShow("Motion Detection", frame);
    if (Cv2.WaitKey(30) == 27) break;
}

SmartCam/
|-- Program.cs                  # Точка входа
|-- Detectors/
|   |-- PersonDetector.cs       # Детектор людей
|   |-- ActionRecognizer.cs     # Распознаватель действий
|   |-- MotionDetector.cs       # Детектор движения
|-- Tracking/
|   |-- ObjectTracker.cs        # Трекер объектов
|   |-- TrackingObject.cs       # Класс для хранения данных отслеживаемого объекта
|-- Utils/
|   |-- CameraCapture.cs        # Обёртка для работы с камерой
|   |-- MatExtensions.cs        # Расширения для класса Mat
|   |-- CudaHelper.cs           # Вспомогательные методы для работы с CUDA
|-- Visualization/
|   |-- OverlayRenderer.cs      # Отрисовка аналитики поверх изображения

using OpenCvSharp;
using SmartCam.Detectors;
using SmartCam.Tracking;
using SmartCam.Utils;
using SmartCam.Visualization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
namespace SmartCam
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("SmartCam: начало работы...");
            
            // Создаём токен отмены для корректного завершения
            using var tokenSource = new CancellationTokenSource();
            var cancellationToken = tokenSource.Token;
            
            // Регистрируем обработчик Ctrl+C
            Console.CancelKeyPress += (s, e) => {
                e.Cancel = true;
                tokenSource.Cancel();
                Console.WriteLine("Завершение работы...");
            };
            
            try
            {
                // Инициализация компонентов
                using var cameraCapture = new CameraCapture(0);
                using var personDetector = new PersonDetector();
                using var motionDetector = new MotionDetector();
                using var actionRecognizer = new ActionRecognizer();
                using var objectTracker = new ObjectTracker();
                using var overlayRenderer = new OverlayRenderer();
                
                // Главный цикл обработки
                await ProcessingLoop(
                    cameraCapture,
                    personDetector,
                    motionDetector,
                    actionRecognizer,
                    objectTracker,
                    overlayRenderer,
                    cancellationToken
                );
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("Операция была отменена пользователем.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Произошла ошибка: {ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
            
            Console.WriteLine("SmartCam: работа завершена.");
        }
        
        static async Task ProcessingLoop(
            CameraCapture cameraCapture,
            PersonDetector personDetector,
            MotionDetector motionDetector,
            ActionRecognizer actionRecognizer,
            ObjectTracker objectTracker,
            OverlayRenderer overlayRenderer,
            CancellationToken cancellationToken)
        {
            // Создаём окно для отображения результатов
            using var window = new Window("SmartCam");
            
            // Инициализируем многопоточную обработку
            var frameProcessingTasks = new List<Task>();
            
            // Главный цикл обработки видео
            while (!cancellationToken.IsCancellationRequested)
            {
                // Захват кадра
                using var frame = await cameraCapture.CaptureFrameAsync(cancellationToken);
                if (frame == null) continue;
                
                // Создаём рабочую копию кадра для визуализации
                using var displayFrame = frame.Clone();
                
                // Обнаружение движения для оптимизации
                var motionMask = motionDetector.DetectMotion(frame);
                if (Cv2.CountNonZero(motionMask) < 100)
                {
                    // Если движения нет, просто показываем кадр
                    window.ShowImage(displayFrame);
                    await Task.Delay(10, cancellationToken);
                    continue;
                }
                
                // Запускаем обнаружение людей в отдельной задаче
                var detectionTask = Task.Run(() => {
                    return personDetector.Detect(frame);
                }, cancellationToken);
                
                // Параллельно обновляем трекер
                await objectTracker.UpdateAsync(frame, cancellationToken);
                
                // Ожидаем завершения обнаружения
                var persons = await detectionTask;
                
                // Обновляем отслеживаемые объекты
                objectTracker.AssignDetections(persons);
                
                // Распознаём действия для каждого отслеживаемого человека
                foreach (var trackingObject in objectTracker.GetActiveObjects())
                {
                    if (trackingObject.Type != ObjectType.Person) continue;
                    
                    // Получаем область с изображением человека
                    using var personROI = new Mat(frame, trackingObject.BoundingBox);
                    
                    // Распознаём действие
                    var action = actionRecognizer.RecognizeAction(personROI);
                    trackingObject.LastAction = action;
                }
                
                // Отрисовываем аналитику
                overlayRenderer.RenderAnalytics(
                    displayFrame, 
                    objectTracker.GetActiveObjects()
                );
                
                // Отображаем результат
                window.ShowImage(displayFrame);
                
                // Короткая задержка для обработки нажатий клавиш
                int key = Cv2.WaitKey(1);
                if (key == 27) // Esc
                {
                    tokenSource.Cancel();
                    break;
                }
            }
        }
    }
}

using OpenCvSharp;
using OpenCvSharp.Dnn;
using System;
using System.Collections.Generic;
using System.Linq;
 
namespace SmartCam.Detectors
{
    public class PersonDetector : IDisposable
    {
        private Net _net;
        private readonly float _confidenceThreshold;
        private readonly Size _modelInputSize;
        
        public PersonDetector(float confidenceThreshold = 0.5)
        {
            _confidenceThreshold = confidenceThreshold;
            _modelInputSize = new Size(416, 416);
            
            // Загружаем предобученную модель YOLO для обнаружения объектов
            _net = CvDnn.ReadNetFromDarknet(
                "Models/yolov4.cfg", 
                "Models/yolov4.weights"
            );
            
            // Проверяем доступность CUDA
            if (CudaHelper.IsCudaAvailable())
            {
                Console.WriteLine("Используем CUDA для инференса");
                _net.SetPreferableBackend(Backend.CUDA);
                _net.SetPreferableTarget(Target.CUDA);
            }
            else
            {
                Console.WriteLine("CUDA недоступна, используем CPU");
                _net.SetPreferableBackend(Backend.DEFAULT);
                _net.SetPreferableTarget(Target.CPU);
            }
        }
        
        public List<DetectedPerson> Detect(Mat frame)
        {
            using var blob = CvDnn.BlobFromImage(
                frame, 
                1/255.0, 
                _modelInputSize, 
                new Scalar(0, 0, 0), 
                swapRB: true, 
                crop: false
            );
            
            _net.SetInput(blob);
            
            // Получаем имена выходных слоёв
            var outLayerNames = _net.GetUnconnectedOutLayersNames();
            
            // Выполняем проход по сети
            using var outs = new VectorOfMat();
            _net.Forward(outs, outLayerNames);
            
            var result = new List<DetectedPerson>();
            
            // Обрабатываем результаты
            for (int i = 0; i < outs.Size; i++)
            {
                var mat = outs[i];
                
                for (int j = 0; j < mat.Rows; j++)
                {
                    var row = mat.Row(j);
                    var scores = row.ColRange(5, mat.Cols);
                    Point classIdPoint = new Point();
                    double confidence = 0;
                    
                    // Получаем максимальную вероятность и соответствующий класс
                    Cv2.MinMaxLoc(scores, out _, out confidence, out _, out classIdPoint);
                    
                    // Если это человек (класс 0 в COCO) и вероятность выше порога
                    if (classIdPoint.X == 0 && confidence > _confidenceThreshold)
                    {
                        int centerX = (int)(row.At<float>(0) * frame.Width);
                        int centerY = (int)(row.At<float>(1) * frame.Height);
                        int width = (int)(row.At<float>(2) * frame.Width);
                        int height = (int)(row.At<float>(3) * frame.Height);
                        
                        // Вычисляем координаты верхнего левого угла
                        int x = centerX - width / 2;
                        int y = centerY - height / 2;
                        
                        result.Add(new DetectedPerson
                        {
                            BoundingBox = new Rect(x, y, width, height),
                            Confidence = confidence
                        });
                    }
                }
            }
            
            // Применяем NMS для устранения дублирующих обнаружений
            var filteredIds = CvDnn.NMSBoxes(
                result.Select(p => p.BoundingBox).ToArray(),
                result.Select(p => (float)p.Confidence).ToArray(),
                _confidenceThreshold,
                0.4f
            );
            
            return filteredIds.Select(id => result[id]).ToList();
        }
        
        public void Dispose()
        {
            _net?.Dispose();
        }
    }
    
    public class DetectedPerson
    {
        public Rect BoundingBox { get; set; }
        public double Confidence { get; set; }
    }
}

using OpenCvSharp;
using SmartCam.Detectors;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
namespace SmartCam.Tracking
{
    public enum ObjectType
    {
        Unknown,
        Person
    }
    
    public enum ActionType
    {
        Standing,
        Walking,
        Running,
        Sitting
    }
    
    public class ObjectTracker : IDisposable
    {
        private Dictionary<int, TrackingObject> _trackingObjects = new Dictionary<int, TrackingObject>();
        private int _nextId = 1;
        private Mat _previousFrame;
        private DateTime _lastCleanupTime = DateTime.Now;
        
        public async Task UpdateAsync(Mat frame, CancellationToken cancellationToken)
        {
            // Если это первый кадр, просто сохраняем его
            if (_previousFrame == null)
            {
                _previousFrame = frame.Clone();
                return;
            }
            
            // Обновляем параметры всех отслеживаемых объектов
            List<int> idsToRemove = new List<int>();
            
            foreach (var trackObj in _trackingObjects.Values)
            {
                // Проверяем, не устарело ли отслеживание
                if (DateTime.Now - trackObj.LastUpdated > TimeSpan.FromSeconds(2))
                {
                    idsToRemove.Add(trackObj.Id);
                    continue;
                }
                
                // Если есть активный трекер, обновляем его
                if (trackObj.Tracker != null)
                {
                    var success = trackObj.Tracker.Update(frame, out var newBox);
                    
                    if (success)
                    {
                        trackObj.BoundingBox = newBox;
                        trackObj.LastTrackingSuccess = DateTime.Now;
                        
                        // Обновляем историю положений
                        trackObj.PositionHistory.Add(new Point(
                            newBox.X + newBox.Width / 2,
                            newBox.Y + newBox.Height / 2
                        ));
                        
                        // Ограничиваем размер истории
                        if (trackObj.PositionHistory.Count > 30)
                        {
                            trackObj.PositionHistory.RemoveAt(0);
                        }
                        
                        // Вычисляем скорость
                        if (trackObj.PositionHistory.Count >= 2)
                        {
                            var lastPos = trackObj.PositionHistory.Last();
                            var prevPos = trackObj.PositionHistory[trackObj.PositionHistory.Count - 2];
                            trackObj.Speed = Math.Sqrt(
                                Math.Pow(lastPos.X - prevPos.X, 2) + 
                                Math.Pow(lastPos.Y - prevPos.Y, 2)
                            );
                        }
                    }
                    else
                    {
                        // Если трекер потерял объект, сбрасываем его
                        trackObj.Tracker.Dispose();
                        trackObj.Tracker = null;
                    }
                }
            }
            
            // Удаляем устаревшие объекты
            foreach (var id in idsToRemove)
            {
                _trackingObjects[id].Dispose();
                _trackingObjects.Remove(id);
            }
            
            // Периодическая очистка неактивных объектов
            if (DateTime.Now - _lastCleanupTime > TimeSpan.FromSeconds(10))
            {
                CleanupInactiveObjects();
                _lastCleanupTime = DateTime.Now;
            }
            
            // Обновляем предыдущий кадр
            frame.CopyTo(_previousFrame);
        }
        
        public void AssignDetections(List<DetectedPerson> detections)
        {
            if (detections.Count == 0) return;
            
            foreach (var detection in detections)
            {
                // Ищем ближайший существующий объект
                var closestObject = FindClosestObject(detection.BoundingBox);
                
                if (closestObject != null)
                {
                    // Обновляем существующий объект
                    closestObject.BoundingBox = detection.BoundingBox;
                    closestObject.LastUpdated = DateTime.Now;
                    
                    // Создаём новый трекер, если нужно
                    if (closestObject.Tracker == null)
                    {
                        closestObject.Tracker = TrackerCSRT.Create();
                        closestObject.Tracker.Init(_previousFrame, closestObject.BoundingBox);
                    }
                }
                else
                {
                    // Создаём новый отслеживаемый объект
                    var newObject = new TrackingObject
                    {
                        Id = _nextId++,
                        Type = ObjectType.Person,
                        BoundingBox = detection.BoundingBox,
                        LastUpdated = DateTime.Now,
                        LastTrackingSuccess = DateTime.Now,
                        PositionHistory = new List<Point>
                        {
                            new Point(
                                detection.BoundingBox.X + detection.BoundingBox.Width / 2,
                                detection.BoundingBox.Y + detection.BoundingBox.Height / 2
                            )
                        }
                    };
                    
                    // Инициализируем трекер
                    newObject.Tracker = TrackerCSRT.Create();
                    newObject.Tracker.Init(_previousFrame, newObject.BoundingBox);
                    
                    _trackingObjects.Add(newObject.Id, newObject);
                }
            }
        }
        
        public List<TrackingObject> GetActiveObjects()
        {
            return _trackingObjects.Values
                .Where(obj => DateTime.Now - obj.LastUpdated < TimeSpan.FromSeconds(1))
                .ToList();
        }
        
        private TrackingObject FindClosestObject(Rect detectionBox)
        {
            TrackingObject closest = null;
            double minDistance = 100; // Максимальное расстояние для считания объектов одинаковыми
            
            foreach (var obj in _trackingObjects.Values)
            {
                if (DateTime.Now - obj.LastUpdated > TimeSpan.FromSeconds(1))
                    continue;
                
                double iou = CalculateIoU(obj.BoundingBox, detectionBox);
                
                if (iou > 0.3 && iou > minDistance)
                {
                    minDistance = iou;
                    closest = obj;
                }
            }
            
            return closest;
        }
        
        private double CalculateIoU(Rect box1, Rect box2)
        {
            // Вычисляем пересечение
            int x1 = Math.Max(box1.X, box2.X);
            int y1 = Math.Max(box1.Y, box2.Y);
            int x2 = Math.Min(box1.X + box1.Width, box2.X + box2.Width);
            int y2 = Math.Min(box1.Y + box1.Height, box2.Y + box2.Height);
            
            if (x2 < x1 || y2 < y1) return 0;
            
            int intersectionArea = (x2 - x1) * (y2 - y1);
            
            // Вычисляем объединение
            int box1Area = box1.Width * box1.Height;
            int box2Area = box2.Width * box2.Height;
            int unionArea = box1Area + box2Area - intersectionArea;
            
            return (double)intersectionArea / unionArea;
        }
        
        private void CleanupInactiveObjects()
        {
            var idsToRemove = _trackingObjects
                .Where(kv => DateTime.Now - kv.Value.LastUpdated > TimeSpan.FromSeconds(5))
                .Select(kv => kv.Key)
                .ToList();
            
            foreach (var id in idsToRemove)
            {
                _trackingObjects[id].Dispose();
                _trackingObjects.Remove(id);
            }
        }
        
        public void Dispose()
        {
            foreach (var obj in _trackingObjects.Values)
            {
                obj.Dispose();
            }
            
            _trackingObjects.Clear();
            _previousFrame?.Dispose();
        }
    }
}

using OpenCvSharp;
using System;
using System.Collections.Generic;
 
namespace SmartCam.Tracking
{
    public class TrackingObject : IDisposable
    {
        public int Id { get; set; }
        public ObjectType Type { get; set; }
        public Rect BoundingBox { get; set; }
        public DateTime LastUpdated { get; set; }
        public DateTime LastTrackingSuccess { get; set; }
        public Tracker Tracker { get; set; }
        public List<Point> PositionHistory { get; set; } = new List<Point>();
        public double Speed { get; set; }
        public ActionType LastAction { get; set; } = ActionType.Standing;
        
        public void Dispose()
        {
            Tracker?.Dispose();
        }
    }
}

using OpenCvSharp;
using SmartCam.Tracking;
using System.Collections.Generic;
using System.Linq;
 
namespace SmartCam.Visualization
{
    public class OverlayRenderer
    {
        private readonly Scalar _personColor = new Scalar(0, 255, 0);
        private readonly Dictionary<ActionType, Scalar> _actionColors = new Dictionary<ActionType, Scalar>
        {
            { ActionType.Standing, new Scalar(0, 255, 0) },
            { ActionType.Walking, new Scalar(255, 255, 0) },
            { ActionType.Running, new Scalar(0, 0, 255) },
            { ActionType.Sitting, new Scalar(255, 0, 0) }
        };
        
        public void RenderAnalytics(Mat frame, List<TrackingObject> objects)
        {
            if (objects == null || objects.Count == 0) return;
            
            foreach (var obj in objects)
            {
                if (obj.Type == ObjectType.Person)
                {
                    // Рисуем рамку вокруг человека
                    Cv2.Rectangle(
                        frame, 
                        obj.BoundingBox, 
                        _personColor, 
                        2
                    );
                    
                    // Рисуем ID объекта
                    Cv2.PutText(
                        frame,
                        $"ID: {obj.Id}",
                        new Point(obj.BoundingBox.X, obj.BoundingBox.Y - 10),
                        HersheyFonts.HersheyDuplex,
                        0.5,
                        _personColor,
                        1
                    );
                    
                    // Отображаем тип действия
                    var actionColor = _actionColors.ContainsKey(obj.LastAction) 
                        ? _actionColors[obj.LastAction] 
                        : new Scalar(255, 255, 255);
                    
                    Cv2.PutText(
                        frame,
                        obj.LastAction.ToString(),
                        new Point(obj.BoundingBox.X, obj.BoundingBox.Y - 30),
                        HersheyFonts.HersheyDuplex,
                        0.5,
                        actionColor,
                        1
                    );
                    
                    // Рисуем траекторию движения
                    if (obj.PositionHistory.Count > 1)
                    {
                        for (int i = 1; i < obj.PositionHistory.Count; i++)
                        {
                            Cv2.Line(
                                frame,
                                obj.PositionHistory[i - 1],
                                obj.PositionHistory[i],
                                new Scalar(0, 165, 255),
                                2
                            );
                        }
                    }
                }
            }
            
            // Добавляем счётчик обнаруженных людей
            int personCount = objects.Count(o => o.Type == ObjectType.Person);
            Cv2.PutText(
                frame,
                $"Людей в кадре: {personCount}",
                new Point(10, 30),
                HersheyFonts.HersheyDuplex,
                1.0,
                new Scalar(255, 255, 255),
                2
            );
        }
    }
}