Untitled

using System;
using System.Drawing;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using System.Threading;
using Emgu.CV;
using Emgu.CV.Structure;
using Emgu.CV.CvEnum;
using System.Windows.Forms;

public class ContinuousRegionMatcher : IDisposable
{
    // Global sonuç değişkenleri
    public static volatile bool Region1Result = false;
    public static volatile bool Region2Result = false;
    public static volatile bool Region3Result = false;
    public static volatile bool Region4Result = false;

    private class RegionInfo
    {
        public int RegionId { get; set; }
        public Rectangle Region { get; set; }
        public List<Mat> Templates { get; set; }
        public string TemplateFolder { get; set; }
        public double Threshold { get; set; }
    }

    private List<RegionInfo> regions;
    private volatile bool isRunning;
    private List<Task> processingTasks;
    private CancellationTokenSource cancellationTokenSource;

    public ContinuousRegionMatcher()
    {
        regions = new List<RegionInfo>();
        processingTasks = new List<Task>();
        cancellationTokenSource = new CancellationTokenSource();
    }

    public void AddRegion(int regionId, Rectangle region, string templateFolder, double threshold = 0.8)
    {
        var regionInfo = new RegionInfo
        {
            RegionId = regionId,
            Region = region,
            Templates = LoadTemplates(templateFolder),
            TemplateFolder = templateFolder,
            Threshold = threshold
        };
        regions.Add(regionInfo);
    }

    private List<Mat> LoadTemplates(string folder)
    {
        var templates = new List<Mat>();
        if (!Directory.Exists(folder))
            throw new DirectoryNotFoundException($"Template klasörü bulunamadı: {folder}");

        foreach (var file in Directory.GetFiles(folder, "*.png"))
        {
            var colorTemplate = CvInvoke.Imread(file, ImreadModes.Color);
            var grayTemplate = new Mat();
            CvInvoke.CvtColor(colorTemplate, grayTemplate, ColorConversion.Bgr2Gray);
            templates.Add(grayTemplate);
            colorTemplate.Dispose();
        }
        return templates;
    }

    private void SetResult(int regionId, bool result)
    {
        switch (regionId)
        {
            case 1: Region1Result = result; break;
            case 2: Region2Result = result; break;
            case 3: Region3Result = result; break;
            case 4: Region4Result = result; break;
        }
    }

    public void Start()
    {
        if (isRunning) return;
        isRunning = true;

        foreach (var region in regions)
        {
            var task = ProcessRegionContinuously(region, cancellationTokenSource.Token);
            processingTasks.Add(task);
        }
    }

    private async Task ProcessRegionContinuously(RegionInfo region, CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {
            try
            {
                using (var colorScreenCapture = CaptureRegion(region.Region))
                using (var screenCapture = new Mat())
                {
                    // Görüntüyü gri tonlamaya çevir
                    CvInvoke.CvtColor(colorScreenCapture, screenCapture, ColorConversion.Bgr2Gray);

                    var matchFound = false;

                    foreach (var template in region.Templates)
                    {
                        using (var result = new Mat())
                        {
                            CvInvoke.MatchTemplate(screenCapture, template, result, TemplateMatchingType.CcoeffNormed);
                            double minVal = 0, maxVal = 0;
                            Point minLoc = new Point(), maxLoc = new Point();
                            CvInvoke.MinMaxLoc(result, ref minVal, ref maxVal, ref minLoc, ref maxLoc);

                            if (maxVal >= region.Threshold)
                            {
                                matchFound = true;
                                break;
                            }
                        }
                    }

                    SetResult(region.RegionId, matchFound);
                }

                await Task.Delay(25, token);
            }
            catch (OperationCanceledException)
            {
                break;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Bölge {region.RegionId} işlenirken hata: {ex.Message}");
                await Task.Delay(1000, token);
            }
        }
    }

    //private Mat CaptureRegion(Rectangle region)
    //{
    //    using (var bitmap = new Bitmap(region.Width, region.Height))
    //    {
    //        using (var graphics = Graphics.FromImage(bitmap))
    //        {
    //            graphics.CopyFromScreen(region.X, region.Y, 0, 0, bitmap.Size);
    //        }
    //        return bitmap.ToMat();
    //    }
    //}


    private Mat CaptureRegion(Rectangle region)
    {
        using (var bitmap = new Bitmap(region.Width, region.Height))
        {
            using (var graphics = Graphics.FromImage(bitmap))
            {
                graphics.CopyFromScreen(region.X, region.Y, 0, 0, bitmap.Size);
            }
            // Bitmap'i Mat'e çevirme işlemi
            Mat mat = new Mat();
            mat = bitmap.ToImage<Bgr, byte>().Mat;
            return mat;
        }
    }
    public void Stop()
    {
        if (!isRunning) return;
        isRunning = false;
        cancellationTokenSource.Cancel();
        Task.WhenAll(processingTasks).Wait();
        cancellationTokenSource = new CancellationTokenSource();
        processingTasks.Clear();
    }

    public void Dispose()
    {
        Stop();
        foreach (var region in regions)
        {
            foreach (var template in region.Templates)
            {
                template?.Dispose();
            }
            region.Templates.Clear();
        }
        cancellationTokenSource.Dispose();
    }
}