MARKUS

using OpenCvSharp;

using OpenCvSharp.CPlusPlus;

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 ImageComparerBase : IDisposable

    {

        Mat OriginalImageData = null;

        Mat TargatImageData = null;

        /// <summary>

        /// 이미지 비교에 사용되는 점수

        /// </summary>

        double gMatchScore = 0.9;

        /// <summary>

        /// 이미지의 크기와 포멧을 변경한다.

        /// </summary>

        /// <param name="bitmap"></param>

        /// <param name="newSize"></param>

        /// <param name="pixelFormat"></param>

        /// <returns></returns>

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

        {

            Bitmap result = bitmap;

            //if (pixelFormat != result.PixelFormat)

            //{

            //    Point originPoint = new Point(0, 0);

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

            //    result = bitmap.Clone(rect, pixelFormat);

            //}

            if (result.Size != newSize || pixelFormat != result.PixelFormat)

            {

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

                {

                    ColorMatrix cm = new ColorMatrix(new float[][]{ new

                                    float[]{0.3f,0.3f,0.3f,0,0},

                                    new float[]{0.59f,0.59f,0.59f,0,0},

                                    new float[]{0.11f,0.11f,0.11f,0,0},

                                    new float[]{0,0,0,1,0,0},

                                    new float[]{0,0,0,0,1,0},

                                    new float[]{0,0,0,0,0,1}});

                    ImageAttributes ia = new ImageAttributes();

                    ia.SetColorMatrix(cm);

                    g.DrawImage(result, new Rectangle(0, 0, newSize.Width, newSize.Height),

                                            0, 0, newSize.Width, newSize.Height, GraphicsUnit.Pixel, ia);

                    g.Dispose();

                }

            }

            return result;

        }

        /// <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

            {

                Mat mask = new Mat();

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

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

                // 이미지 포멧은 24bit이하로 emgu CV가 작동

                //Originalbitmap = ChangeBitmapFormatAndSize(Originalbitmap, Originalbitmap.Size, PixelFormat.Format24bppRgb);

                //TargatBitmap = ChangeBitmapFormatAndSize(TargatBitmap, Originalbitmap.Size, PixelFormat.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.ImWrite("d:\\testsave\\original.png", OriginalImageData);

                //Cv2.ImWrite("d:\\testsave\\Targat.png", TargatImageData);

                Cv2.CvtColor(OriginalImageData, OriginalImageData, ColorConversion.BgrToGray);

                Cv2.CvtColor(TargatImageData, TargatImageData, ColorConversion.BgrToGray);

                //Cv2.CvtColor(TargatImageData, TargatImageData, ColorConversion.RgbToGray);

                //Cv2.ImWrite("d:\\testsave\\original_Mask.png", OriginalImageData);

                //Cv2.Threshold(OriginalImageData, OriginalImageData, 127, 255,ThresholdType.Binary);

                //Cv2.Threshold(TargatImageData, TargatImageData, 127, 255, ThresholdType.Otsu);

                Mat outputData = new Mat(TargatImageData.Size(), MatType.CV_8UC1);

                Cv2.Absdiff(OriginalImageData, TargatImageData, outputData);

                //Cv2.ImWrite("d:\\testsave\\outputData.png", outputData);

                //Computes absolute different between this image and the other image

                // 원본이미지와 타겟이미지를 처리

                // 틀린부분을 반환

                Cv2.BitwiseNot(outputData, result);

               // Cv2.ImWrite("d:\\testsave\\result.png", outputData);

            }

            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_test(OpenCvSharp.CPlusPlus.Mat data, Size block)

        {

            int width = data.Cols;

            int height = data.Rows;

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

            var heightRange = from h in Enumerable.Range(1, height)

                              where h % block.Height == 0

                              select h;

            var widthRange = from w in Enumerable.Range(1, width)

                             where w % block.Width == 0

                             select w;

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

            stopwatch.Start();

            Mat outputMat = new Mat();

            HierarchyIndex[] hierarchy;

            //OpenCvSharp.CPlusPlus.Point[][] contours;

            OpenCvSharp.CPlusPlus.Point[][] contours;

            Cv2.ImWrite("d:\\testsave\\CvtColor_before.png", data);

            Cv2.CvtColor(data, outputMat, ColorConversion.BgrToGray);

            Cv2.ImWrite("d:\\testsave\\CvtColor_after.png", outputMat);

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

            Cv2.Threshold(outputMat, outputMat, 127, 255, ThresholdType.Binary);

            Cv2.FindContours(outputMat, out contours, out hierarchy, ContourRetrieval.Tree, ContourChain.ApproxSimple, testpoint);

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

            {

                Cv2.DrawContours(data, contours, i, Scalar.Red, 1, LineType.AntiAlias);

            }

            Cv2.ImWrite("d:\\testsave\\draw.png", data);

            //foreach (var y in heightRange)

            //{

            //    foreach (var x in widthRange)

            //    {

            //        var rect = DataMatchScore(data, x, y, width, height, block);

            //        if (rect != null)

            //        {

            //            results.Add(rect.Value);

            //        }

            //    }

            //}

            //var items = data.ToDataFloat();

            //var handle = GCHandle.Alloc(data);

            //foreach (var y in heightRange)

            //{

            //    foreach (var x in widthRange)

            //    {

            //           var rect = DataMatchScore(data, x, y, width, height, block);

            //        if (rect != null)

            //        {

            //            results.Add(rect.Value);

            //        }

            //    }

            //}

            //handle.Free();

            //Parallel.ForEach(heightRange, (y) =>

            //{

            //    Parallel.ForEach(widthRange, (x) =>

            //    {

            //        var rect = DataMatchScore(data, x, y, width, height, block);

            //        if (rect != null)

            //        {

            //            results.Add(rect.Value);

            //        }

            //    });

            //});

            //Parallel.ForEach(heightRange, (y) =>

            //{

            //    Parallel.ForEach(widthRange, (x) =>

            //    {

            //        var rect = DataMatchScore(data, x, y, width, height, block);

            //        if (rect != null)

            //        {

            //            results.Add(rect.Value);

            //        }

            //    });

            //});

            System.Diagnostics.Debug.WriteLine("1 - " + new TimeSpan(stopwatch.ElapsedTicks));

            return results;

        }

        /// <summary>

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

        /// </summary>

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

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

        /// <returns></returns>

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

        {

            int width = data.Cols;

            int height = data.Rows;

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

            //var heightRange = from h in Enumerable.Range(1, height)

            //                  where h % block.Height == 0

            //                  select h;

            //var widthRange = from w in Enumerable.Range(1, width)

            //                 where w % block.Width == 0

            //                 select w;

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

            stopwatch.Start();

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

            HierarchyIndex[] hierarchy;

            //OpenCvSharp.CPlusPlus.Point[][] contours;

            OpenCvSharp.CPlusPlus.Point[][] contours;

            //Cv2.CvtColor(data, outputMat,ColorConversion.RgbToGray);

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

            Cv2.Threshold(data, data, 200, 255,ThresholdType.Otsu);

            Cv2.FindContours(data, out contours, out hierarchy, ContourRetrieval.List, ContourChain.ApproxNone, testpoint);

            int blockWidthMargin = block.Width / 2;

            int blockHeightMargin = block.Height / 2;

            var rects = contours.SelectMany(p => p).OrderBy(p=>p.X + p.Y)

                            .Select(p=> 

                                new System.Windows.Rect {

                                    X = p.X - blockWidthMargin,

                                    Y = p.Y - blockHeightMargin,

                                    Width = block.Width,

                                    Height = block.Height

                                })

                                .ToArray();

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

            {

                if (results.Count(r => r.IntersectsWith(rects[i])) == 0)

                {

                    results.Add(rects[i]);

                }

            }

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

            //{

            //    for (int j = 0; j < contours[i].Count(); j++)

            //    {

            //        if (results.Count(x => x.Contains()))

            //        {

            //            results.Add(contours)

            //        }

            //    }

            //    Cv2.DrawContours(data, contours, i, Scalar.Red, 1, LineType.AntiAlias);

            //}

            //Cv2.ImWrite("d:\\testsave\\draw.png", data);

            System.Diagnostics.Debug.WriteLine("1 - " + new TimeSpan(stopwatch.ElapsedTicks));

            return results;

        }

        /// <summary>

        /// MathchesImageData의 틀린 부분을 Rect로 반환

        /// </summary>

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

        /// <param name="currentX"></param>

        /// <param name="currentY"></param>

        /// <param name="ImageWidth"></param>

        /// <param name="ImageHeight"></param>

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

        /// <returns></returns>

        protected System.Windows.Rect? DataMatchScore(OpenCvSharp.CPlusPlus.Mat mat, int currentX, int currentY, int ImageWidth, int ImageHeight, Size block)

        {

            System.Windows.Rect? result = null;

            int x = currentX;

            int y = currentY;

            int width = ImageWidth;

            int height = ImageHeight;

            for (int i = 0; i < block.Width; i++)

            {

                int wi = x + i;

                if (wi >= width) break;

                for (int j = 0; j < block.Height; j++)

                {

                    int hj = y + j;

                    if (hj >= height) break;

                    try

                    {

                        //System.Diagnostics.Debug.WriteLine($"point :{wi},{hj}");

                        if (mat.GetValue<float>(wi,hj) < gMatchScore)

                        {

                            result = new System.Windows.Rect(y, x, block.Width, block.Height);

                            return result;

                        }

                    }

                    catch (Exception e)

                    {

                        System.Diagnostics.Debug.WriteLine(e);

                    }

                }

            }

            return result;

        }

        /// <summary>

        /// MathchesImageData의 틀린 부분을 Rect로 반환

        /// </summary>

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

        /// <param name="currentX"></param>

        /// <param name="currentY"></param>

        /// <param name="ImageWidth"></param>

        /// <param name="ImageHeight"></param>

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

        /// <returns></returns>

        protected System.Windows.Rect? DataMatchScore(IEnumerable<ImageData<float>> data, int currentX, int currentY, int ImageWidth, int ImageHeight, Size block)

        {

            System.Windows.Rect? result = null;

            int x = currentX;

            int y = currentY;

            int width = ImageWidth;

            int height = ImageHeight;

            for (int i = 0; i < block.Width; i++)

            {

                int wi = x + i;

                if (wi >= width) break;

                for (int j = 0; j < block.Height; j++)

                {

                    int hj = y + j;

                    if (hj >= height) break;

                    try

                    {

                        //System.Diagnostics.Debug.WriteLine($"point :{wi},{hj}");

                        if (data.FirstOrDefault(d=> d.Row == wi && d.Col == hj)?.Value < gMatchScore)

                        {

                            result = new System.Windows.Rect(y, x, block.Width, block.Height);

                            return result;

                        }

                    }

                    catch (Exception e)

                    {

                        System.Diagnostics.Debug.WriteLine(e);

                    }

                }

            }

            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(OpenCvSharp.CPlusPlus.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

    }

}