MARKUS

using OpenCvSharp;

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Drawing;

using System.Drawing.Imaging;

using System.IO;

using System.Linq;

using System.Net;

using System.Runtime.InteropServices;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Media.Imaging;

using Point = System.Drawing.Point;

using Size = System.Drawing.Size;

namespace Markus.Image

{

    public class ImageCompareBase : IDisposable

    {

        double contoursLongCount = 0;

        int ComparisonCount = 0;

        public CompareProgress Progress = new CompareProgress();

        private void SetStatus(string message,double percentage,CompareStatus status)

        {

            //System.Diagnostics.Debug.WriteLine(percentage);

            Progress.Message = message;

            Progress.Percentage = percentage;

            Progress.Status = status;

        }

        /// <summary>

        /// Originalbitmap에서 TargatBitmap과 비교하여 틀린 부분의 데이터를 Emgu.CV.TDepth형식으로 반환한다.

        /// </summary>

        /// <param name="Originalbitmap">원본 이미지</param>

        /// <param name="TargatBitmap">비교대상 이미지</param>

        /// <returns>Emgu.CV.TDepth형식의 byte[,,]</returns>

        protected Mat MathchesImageData(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap,Size resultSize)

        {

            Mat result = new Mat();

            try

            {

                SetStatus("Image Load", 0, CompareStatus.Loading);

                Originalbitmap = ChangeBitmapFormatAndSize(Originalbitmap, resultSize, PixelFormat.Format24bppRgb);

                TargatBitmap = ChangeBitmapFormatAndSize(TargatBitmap, resultSize, PixelFormat.Format24bppRgb);

                // 원본이미지의 크키와 Format24bppRgb로 타켓 이미지를 변경

                // 크기가 틀린 경우 비교시 바이트배열 오류 발생

                using (Mat OriginalImageData = OpenCvSharp.Extensions.BitmapConverter.ToMat(Originalbitmap))

                {

                    using (Mat TargatImageData = OpenCvSharp.Extensions.BitmapConverter.ToMat(TargatBitmap))

                    {

                        if (OriginalImageData.Size() != TargatImageData.Size())

                        {

                            Cv2.Resize(TargatImageData, TargatImageData, OriginalImageData.Size());

                        }

                        Cv2.CvtColor(OriginalImageData, OriginalImageData, ColorConversionCodes.BGR2GRAY);

                        Cv2.CvtColor(TargatImageData, TargatImageData, ColorConversionCodes.BGR2GRAY);

                        using (Mat outputData = new Mat(new OpenCvSharp.Size(resultSize.Width, resultSize.Height), MatType.CV_8UC1))

                        {

                            Cv2.Absdiff(OriginalImageData, TargatImageData, outputData);

                            // 틀린부분을 반환

                            Cv2.BitwiseNot(outputData, result);

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                throw ex;

            }

            finally

            {

            }

            return result;

        }

        /// <summary>

        /// Image<TColor, TDepth>의 틀린 부분을 Rect로 반환

        /// </summary>

        /// <param name="data"></param>

        /// <param name="block"></param>

        /// <returns></returns>

        protected List<System.Windows.Rect> GetMatchPixels(Mat data, Size block)

        {

            SetStatus("Detection", 0, CompareStatus.Detection);

            int width = data.Cols;

            int height = data.Rows;

            List<System.Windows.Rect> results = new List<System.Windows.Rect>();

            System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();

            stopwatch.Start();

            //Mat outputMat = new Mat(data.Size(), MatType.CV_8UC1);

            HierarchyIndex[] hierarchy;

            OpenCvSharp.Point[][] contours;

            OpenCvSharp.Point testpoint = new OpenCvSharp.Point();

            Cv2.Threshold(data, data, 50, 255,ThresholdTypes.BinaryInv);

            Cv2.FindContours(data, out contours, out hierarchy,RetrievalModes.List,ContourApproximationModes.ApproxSimple, testpoint);

            SetStatus("Comparison", 0, CompareStatus.Comparison);

            contoursLongCount = contours.Sum(x => x.Count());

            //var rects = contours.AsParallel()

            //                    .Select(points => GetRectList(points, block))

            //                    .SelectMany(x => x);

            var rects = contours.SelectMany(points => GetRectList(points, block));

            results.AddRange(rects);

            return results;

        }

        protected System.Drawing.Bitmap GetContoursImage(Mat data, Size resultSize, Color RectColor)

        {

            System.Drawing.Bitmap result = null;

            try

            {

                Mat transparentImage = new Mat(new OpenCvSharp.Size(resultSize.Width, resultSize.Height), MatType.CV_8UC4, new Scalar(0, 0, 0, 0));

                // 컨투어를 찾기 위한 변수 선언

                HierarchyIndex[] hierarchy;

                OpenCvSharp.Point[][] contours;

                OpenCvSharp.Point testpoint = new OpenCvSharp.Point();

                Cv2.Threshold(data, data, 100, 255, ThresholdTypes.BinaryInv);

                // 이진화된 이미지에서 컨투어 찾기

                Cv2.FindContours(data, out contours, out hierarchy, RetrievalModes.List, ContourApproximationModes.ApproxNone, testpoint);

                // Scalar(B,G,R,A)

                // 컨투어 그리기

                Cv2.DrawContours(transparentImage, contours, -1, new Scalar(RectColor.B, RectColor.G, RectColor.R, RectColor.A), 10);

                // Mat을 Bitmap으로 변환

                result = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(transparentImage);

            }

            catch (Exception ex)

            {

                throw new Exception("GetContoursImage Error.", ex);

            }

            finally

            {

            }

            return result;

        }

        private List<System.Windows.Rect> GetRectListAsParallel(OpenCvSharp.Point[] points, Size block)

        {

            List<System.Windows.Rect> result = new List<System.Windows.Rect>();

            ConcurrentBag<System.Windows.Rect> rectBag = new ConcurrentBag<System.Windows.Rect>();

            Parallel.For(0, points.Length, i =>

            {

                if (i >= points.Length) return; // 배열 길이 확인

                var rect = new System.Windows.Rect

                {

                    X = points[i].X - block.Width / 2,

                    Y = points[i].Y - block.Height / 2,

                    Width = block.Width,

                    Height = block.Height

                };

                if (!rectBag.Any(r => r.IntersectsWith(rect)))

                {

                    rectBag.Add(rect);

                    result.Add(rect);

                }

                Interlocked.Increment(ref ComparisonCount);

                SetStatus("Comparison", (double)ComparisonCount / (double)contoursLongCount * 100, CompareStatus.Comparison);

            });

            return result;

        }

        protected System.Drawing.Bitmap ChangeBitmapFormatAndSize(System.Drawing.Bitmap bitmap, Size newSize, PixelFormat pixelFormat)

        {

            Bitmap result = bitmap;

            if (pixelFormat != bitmap.PixelFormat)

            {

                Point originPoint = new Point(0, 0);

                Rectangle rect = new Rectangle(originPoint, bitmap.Size);

                result = bitmap.Clone(rect, pixelFormat);

            }

            if (bitmap.Size != newSize)

            {

                result = new Bitmap(newSize.Width, newSize.Height);

                using (Graphics g = Graphics.FromImage(result))

                {

                    g.DrawImage(bitmap, 0, 0, newSize.Width, newSize.Height);

                    g.Dispose();

                }

            }

            return result;

        }

        private List<System.Windows.Rect> GetRectList(OpenCvSharp.Point[] points,Size block)

        {

            List<System.Windows.Rect> result = new List<System.Windows.Rect>();

            for (int i = 0; i < points.Count(); i++)

            {

                var rect = new System.Windows.Rect

                {

                    X = points[i].X - block.Width / 2,

                    Y = points[i].Y - block.Height / 2,

                    Width = block.Width,

                    Height = block.Height

                };

                if (result.Count(r => r.IntersectsWith(rect)) == 0)

                {

                    result.Add(rect);

                }

                ComparisonCount++;

                SetStatus("Comparison", ComparisonCount/contoursLongCount*100, CompareStatus.Comparison);

            }

            return result;

        }

        /// <summary>

        /// Image<TColor, TDepth>의 틀린 부분을 Rect로 반환

        /// </summary>

        /// <param name="data"></param>

        /// <param name="block"></param>

        /// <returns></returns>

        protected async Task<List<System.Windows.Rect>> GetMatchPixelsAsnc(Mat data, Size block)

        {

            return await Task.Factory.StartNew<List<System.Windows.Rect>>(() =>

            {

                return GetMatchPixels(data, block);

            });

        }

        protected Bitmap LoadPicture(string url)

        {

            HttpWebRequest wreq;

            HttpWebResponse wresp;

            Stream mystream;

            Bitmap bmp;

            bmp = null;

            mystream = null;

            wresp = null;

            try

            {

                wreq = (HttpWebRequest)WebRequest.Create(url);

                wreq.AllowWriteStreamBuffering = true;

                wresp = (HttpWebResponse)wreq.GetResponse();

                if ((mystream = wresp.GetResponseStream()) != null)

                    bmp = new Bitmap(mystream);

            }

            finally

            {

                if (mystream != null)

                {

                    mystream.Close();

                    mystream.Dispose();

                }

                if (wresp != null)

                {

                    wresp.Close();

                    wresp.Dispose();

                }

            }

            return (bmp);

        }

        #region  IDisposable Support 

        private bool disposedValue = false;

        // 중복 호출을 검색하려면 

        protected virtual void Dispose(bool disposing)

        {

            if (!disposedValue)

            {

                if (disposing)

                {

                    // TODO: 관리되는 상태(관리되는 개체)를 삭제합니다. 

                }

                // TODO: 관리되지 않는 리소스(관리되지 않는 개체)를 해제하고 아래의 종료자를 재정의합니다. 

                // TODO: 큰 필드를 null로 설정합니다. 

                disposedValue = true;

            }

        }

        // TODO: 위의 Dispose(bool disposing)에 관리되지 않는 리소스를 해제하는 코드가 포함되어 있는 경우에만 종료자를 재정의합니다.

        // 

        //~DisposeClass()

       // {

            // // 이 코드를 변경하지 마세요. 위의 Dispose(bool disposing)에 정리 코드를 입력하세요. 

            // Dispose(false); // 

       // } 

        // 삭제 가능한 패턴을 올바르게 구현하기 위해 추가된 코드입니다. 

        public void Dispose()

        {

            // 이 코드를 변경하지 마세요. 위의 Dispose(bool disposing)에 정리 코드를 입력하세요. 

            Dispose(true);

            // TODO: 위의 종료자가 재정의된 경우 다음 코드 줄의 주석 처리를 제거합니다. 

            //  GC.SuppressFinalize(this);

            GC.Collect();

            GC.SuppressFinalize(this);

            GC.Collect();

        } 

        #endregion

    }

}