MARKUS

using Emgu.CV;

using Emgu.CV.Structure;

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Drawing.Imaging;

using System.IO;

using System.Linq;

using System.Net;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Image

{

    public class ImageComparerBase : IDisposable

    {

        Image<Bgr, Byte> OriginalImageData = null;

        Image<Bgr, Byte> 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 != 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;

        }

        /// <summary>

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

        /// </summary>

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

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

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

        protected byte[,,] MathchesImageData(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap)

        {

            byte[,,] result = null;

            try

            {

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

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

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

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

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

                OriginalImageData = new Image<Bgr, Byte>(Originalbitmap);

                TargatImageData = new Image<Bgr, Byte>(TargatBitmap);

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

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

                var tmp = OriginalImageData.AbsDiff(TargatImageData);

                // 틀린부분을 반환

                var matches = tmp.Not();

                result = matches.Data;

                matches.Dispose();

                tmp.Dispose();

            }

            catch (Exception ex)

            {

                throw ex;

            }

            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(byte[,,] 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;

                    double matchScore = data[wi, hj, 0];

                    if (matchScore < gMatchScore)

                    {

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

                        return result;

                    }

                }

            }

            return result;

        }

        /// <summary>

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

        /// </summary>

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

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

        /// <returns></returns>

        protected List<System.Windows.Rect> GetMatchPixels(byte[,,] data, Size block)

        {

            int width = data.GetLength(0);

            int height = data.GetLength(1);

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

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

                    }

                }

            }

            //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 async Task<List<System.Windows.Rect>> GetMatchPixelsAsnc(byte[,,] 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

    }

}