MARKUS

using OpenCvSharp;

using System;

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.Tasks;

using Point = System.Drawing.Point;

using Size = System.Drawing.Size;

namespace Markus.Image

{

    public class ImageCompareBase : IDisposable

    {

        Mat OriginalImageData = null;

        Mat TargatImageData = null;

        double contoursLongCount = 0;

        double 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)

        {

            Mat result = new Mat();

            try

            {

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

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

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

                OriginalImageData = OpenCvSharp.Extensions.BitmapConverter.ToMat(Originalbitmap);

                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);

                Mat outputData = new Mat(TargatImageData.Size(), 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, 90, 255,ThresholdTypes.BinaryInv);

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

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

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

            var rects = contours.AsParallel()

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

                                .SelectMany(x => x);

            results.AddRange(rects);

            return results;

        }

        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);

            if (OriginalImageData != null)

            {

                OriginalImageData.Dispose();

            }

            if (TargatImageData != null)

            {

                TargatImageData.Dispose();

            }

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

            //  GC.SuppressFinalize(this);

            GC.Collect();

            GC.SuppressFinalize(this);

            GC.Collect();

        } 

        #endregion

    }

}