MARKUS

  <startup> 

    <PlatformTarget>x64</PlatformTarget>

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Markus.Image.EMGU", "Markus.ImageComparer.EMGU\Markus.Image.EMGU.csproj", "{96437AC2-24F9-48A7-AC24-221086017BB3}"

EndProject

		{96437AC2-24F9-48A7-AC24-221086017BB3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{96437AC2-24F9-48A7-AC24-221086017BB3}.Debug|Any CPU.Build.0 = Debug|Any CPU

		{96437AC2-24F9-48A7-AC24-221086017BB3}.Release|Any CPU.ActiveCfg = Release|Any CPU

		{96437AC2-24F9-48A7-AC24-221086017BB3}.Release|Any CPU.Build.0 = Release|Any CPU

using Emgu.CV;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Image

{

    public class EmguCVImage

    {

        public static void test()

        {

        }

    }

}

using Emgu.CV;

using Emgu.CV.Structure;

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Drawing.Imaging;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Image

{

    public class ImageComparer : ImageComparerBase

    {

        /// <summary>

        /// 이미지를 비교 후 원본 이미지에 Rect를 그린다.

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public Bitmap CompareDrawRects(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap, Size ResultRectSize)

        {

            var rects =  CompareReturnRects(Originalbitmap, TargatBitmap, ResultRectSize);

            if (rects.Count != 0)

            {

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

                {

                    var rect = rects.Select(x => new System.Drawing.Rectangle((int)x.X, (int)x.Y, (int)x.Width, (int)x.Height));

                    g.DrawRectangles(new Pen(Brushes.Blue, 3f), rect.ToArray());

                    g.Save();

                    g.Dispose();

                }

            }

            return Originalbitmap;

        }

        public System.Windows.Media.Imaging.BitmapSource CompareDrawRects(System.Windows.Media.Imaging.BitmapSource Originalbitmap, System.Windows.Media.Imaging.BitmapSource TargatBitmap, Size ResultRectSize)

        {

            var _Originalbitmap = CreateBitmapFromSource(Originalbitmap);

            var _TargatBitmap = CreateBitmapFromSource(TargatBitmap);

            var rects = CompareReturnRects(_Originalbitmap, _TargatBitmap, ResultRectSize);

            if (rects.Count != 0)

            {

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

                {

                    var rect = rects.Select(x => new System.Drawing.Rectangle((int)x.X, (int)x.Y, (int)x.Width, (int)x.Height));

                    g.DrawRectangles(new Pen(Brushes.Blue, 3f), rect.ToArray());

                    g.Save();

                    g.Dispose();

                }

            }

            return CreateBitmapSourceFromBitmap(_Originalbitmap);

        }

        public List<System.Windows.Rect> CompareReturnRects(string OriginalbitmapUri, string TargatBitmapUri, Size ResultRectSize)

        {

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

            Bitmap Originalbitmap = null;

            Bitmap TargatBitmap = null;

            try

            {

                Originalbitmap = LoadPicture(OriginalbitmapUri);

                TargatBitmap = LoadPicture(TargatBitmapUri);

                result = CompareReturnRects(Originalbitmap, TargatBitmap, ResultRectSize);

            }

            catch (Exception)

            {

                throw;

            }

            finally

            {

                Originalbitmap.Dispose();

                TargatBitmap.Dispose();

            }

            return result;

        }

        /// <summary>

        /// 이미지를 비교 후 해당 영역을 Rect로 반환한다.

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public List<System.Windows.Rect> CompareReturnRects(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap, Size ResultRectSize)

        {

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

            try

            {

                Point[][] data = MathchesImageData(Originalbitmap, TargatBitmap);

                result =  GetMatchPixels(data, ResultRectSize);

            }

            catch (Exception ex)

            {

                throw ex;

            }

            finally

            {

            }

            return result;

        }

        /// <summary>

        /// 이미지를 비교 후 원본 이미지에 Rect를 그린다.

        /// 메모리 문제 발생

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public async Task<Bitmap> CompareDrawRectsAsync(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap, Size ResultRectSize)

        {

            System.Drawing.Bitmap cloneOriginal = Originalbitmap;

            var rects = await CompareReturnRectsAsync(cloneOriginal, TargatBitmap, ResultRectSize);

            if (rects.Count != 0)

            {

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

                {

                    var rect = rects.Select(x => new System.Drawing.Rectangle((int)x.X, (int)x.Y, (int)x.Width, (int)x.Height));

                    g.DrawRectangles(new Pen(Brushes.Blue, 3f), rect.ToArray());

                    g.Save();

                    g.Dispose();

                }

            }

            return cloneOriginal;

        }

        public async Task<Bitmap> CompareDrawRectsAsync(string OriginalbitmapUri, string TargatBitmapUri, Size ResultRectSize)

        {

            Bitmap Originalbitmap = null;

            Bitmap TargatBitmap = null;

            Originalbitmap = LoadPicture(OriginalbitmapUri);

            TargatBitmap = LoadPicture(TargatBitmapUri);

            System.Drawing.Bitmap cloneOriginal = Originalbitmap;

            var rects = await CompareReturnRectsAsync(cloneOriginal, TargatBitmap, ResultRectSize);

            if (rects.Count != 0)

            {

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

                {

                    var rect = rects.Select(x => new System.Drawing.Rectangle((int)x.X, (int)x.Y, (int)x.Width, (int)x.Height));

                    g.DrawRectangles(new Pen(Brushes.Blue, 3f), rect.ToArray());

                    g.Save();

                    g.Dispose();

                }

            }

            return cloneOriginal;

        }

        /// <summary>

        /// 이미지를 비교 후 원본 이미지에 Rect를 그린다.

        /// 메모리 문제 발생

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public async Task<System.Windows.Media.Imaging.BitmapSource> CompareDrawRectsAsync(System.Windows.Media.Imaging.BitmapSource Originalbitmap, System.Windows.Media.Imaging.BitmapSource TargatBitmap, Size ResultRectSize)

        {

            var _Originalbitmap = CreateBitmapFromSource(Originalbitmap);

            var _TargatBitmap = CreateBitmapFromSource(TargatBitmap);

            var rects = await CompareReturnRectsAsync(_Originalbitmap, _TargatBitmap, ResultRectSize);

            if (rects.Count != 0)

            {

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

                {

                    var rect = rects.Select(x => new System.Drawing.Rectangle((int)x.X, (int)x.Y, (int)x.Width, (int)x.Height));

                    g.DrawRectangles(new Pen(Brushes.Blue, 3f), rect.ToArray());

                    g.Save();

                    g.Dispose();

                }

            }

            return CreateBitmapSourceFromBitmap(_Originalbitmap);

        }

        public Bitmap CreateBitmapFromSource(System.Windows.Media.Imaging.BitmapSource bitmapsource)

        {

            //convert image format

            var src = new System.Windows.Media.Imaging.FormatConvertedBitmap();

            src.BeginInit();

            src.Source = bitmapsource;

            src.DestinationFormat = System.Windows.Media.PixelFormats.Bgr24;

            src.EndInit();

            //copy to bitmap

            Bitmap bitmap = new Bitmap(src.PixelWidth, src.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb);

            var data = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);

            src.CopyPixels(System.Windows.Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride);

            bitmap.UnlockBits(data);

            return bitmap;

        }

        /// <summary>

        /// 메모리 문제 발생

        /// </summary>

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

        /// <returns></returns>

        public System.Windows.Media.Imaging.WriteableBitmap CreateWriteableBitmapFromBitmap(Bitmap bitmap)

        {

            System.Windows.Media.Imaging.WriteableBitmap result = null;

            if (bitmap == null)

                throw new ArgumentNullException("bitmap");

            try

            {

                int bytesPerPixel = 4;

                result = new System.Windows.Media.Imaging.WriteableBitmap(bitmap.Width, bitmap.Height,

                                                                   bitmap.HorizontalResolution ,bitmap.VerticalResolution,

                                                                   bitmap.PixelFormat.Convert(), null);

                Rectangle colorBitmapRectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);

                System.Windows.Int32Rect colorBitmapInt32Rect = new System.Windows.Int32Rect(0, 0, bitmap.Width, bitmap.Height);

                BitmapData data = bitmap.LockBits(colorBitmapRectangle, ImageLockMode.WriteOnly, bitmap.PixelFormat);

                result.WritePixels(colorBitmapInt32Rect, data.Scan0, data.Width * data.Height * bytesPerPixel, data.Stride);

                bitmap.UnlockBits(data);

            }

            catch (Exception ex)

            {

                //throw ex;

            }

            finally

            {

                bitmap.Dispose();

                bitmap = null;

                //GC.Collect(2);

            }

            return result;

        }

        /// <summary>

        /// 메모리 문제 발생

        /// </summary>

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

        /// <returns></returns>

        public System.Windows.Media.Imaging.BitmapSource CreateBitmapSourceFromBitmap(Bitmap bitmap)

        {

            System.Windows.Media.Imaging.BitmapSource result = null;

            if (bitmap == null)

                throw new ArgumentNullException("bitmap");

            try

            {

                using (var hbitmap = new SafeHBitmapHandle(bitmap.GetHbitmap(), true))

                {

                    result = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(

                        hbitmap.DangerousGetHandle(),

                        IntPtr.Zero,

                        System.Windows.Int32Rect.Empty,

                        System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());

                }

            }

            catch (Exception ex)

            {

                //throw ex;

            }

            finally

            {

                bitmap.Dispose();

                bitmap = null;

                //GC.Collect(2);

            }

            return result;

        }

        public async Task<List<System.Windows.Rect>> CompareReturnRectsAsync(string OriginalbitmapUri, string TargatBitmapUri, Size ResultRectSize)

        {

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

            Bitmap Originalbitmap = null;

            Bitmap TargatBitmap = null;

            try

            {

                Originalbitmap = LoadPicture(OriginalbitmapUri);

                TargatBitmap = LoadPicture(TargatBitmapUri);

                result = await CompareReturnRectsAsync(Originalbitmap, TargatBitmap, ResultRectSize);

            }

            catch (Exception)

            {

                throw;

            }

            finally

            {

                Originalbitmap.Dispose();

                TargatBitmap.Dispose();

            }

            return result;

        }

        /// <summary>

        /// 이미지를 비교 후 해당 영역을 Rect로 반환한다.

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public async Task<List<System.Windows.Rect>> CompareReturnRectsAsync(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap, Size ResultRectSize)

        {

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

            try

            {

                byte[,,] data = MathchesImageData(Originalbitmap, TargatBitmap);

                result = await GetMatchPixelsAsnc(data, ResultRectSize);

                data = null;

            }

            catch (Exception ex)

            {

                throw ex;

            }

            finally

            {

            }

            return result;

        }

        protected override void Dispose(bool disposing)

        {

            base.Dispose(disposing);

        }

    }

}

using Emgu.CV;

using Emgu.CV.Structure;

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Drawing.Imaging;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Markus.Image

{

    public class ImageComparer : ImageComparerBase

    {

        /// <summary>

        /// 이미지를 비교 후 원본 이미지에 Rect를 그린다.

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public Bitmap CompareDrawRects(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap, Size ResultRectSize)

        {

            var rects =  CompareReturnRects(Originalbitmap, TargatBitmap, ResultRectSize);

            if (rects.Count != 0)

            {

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

                {

                    var rect = rects.Select(x => new System.Drawing.Rectangle((int)x.X, (int)x.Y, (int)x.Width, (int)x.Height)).ToList();

                    g.DrawRectangles(new Pen(Brushes.Blue, 3f), rect.ToArray());

                    g.Save();

                    g.Dispose();

                }

            }

            return Originalbitmap;

        }

        // JoinRects: will return a rectangle composed of r1 and r2.

        private System.Windows.Rect JoinRects(System.Windows.Rect r1, System.Windows.Rect r2)

        {

            return new System.Windows.Rect(Math.Min(r1.X, r2.X),

                            Math.Min(r1.Y, r2.Y),

                            Math.Max(r1.Y + r1.Width, r2.Y + r2.Width),

                            Math.Max(r1.X + r1.Height, r2.X + r2.Height));

        }

        private System.Windows.Rect RectSizeUp(System.Windows.Rect rect,int UpSize)

        {

            return new System.Windows.Rect(rect.X - UpSize, rect.Y - UpSize, rect.Width + UpSize, rect.Height + UpSize);

        }

        public System.Windows.Media.Imaging.BitmapSource CompareDrawRects(System.Windows.Media.Imaging.BitmapSource Originalbitmap, System.Windows.Media.Imaging.BitmapSource TargatBitmap, Size ResultRectSize)

        {

            var _Originalbitmap = CreateBitmapFromSource(Originalbitmap);

            var _TargatBitmap = CreateBitmapFromSource(TargatBitmap);

            var rects = CompareReturnRects(_Originalbitmap, _TargatBitmap, ResultRectSize);

            if (rects.Count != 0)

            {

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

                {

                    var rect = rects.Select(x => new System.Drawing.Rectangle((int)x.X, (int)x.Y, (int)x.Width, (int)x.Height));

                    g.DrawRectangles(new Pen(Brushes.Blue, 3f), rect.ToArray());

                    g.Save();

                    g.Dispose();

                }

            }

            return CreateBitmapSourceFromBitmap(_Originalbitmap);

        }

        public List<System.Windows.Rect> CompareReturnRects(string OriginalbitmapUri, string TargatBitmapUri, Size ResultRectSize)

        {

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

            Bitmap Originalbitmap = null;

            Bitmap TargatBitmap = null;

            try

            {

                Originalbitmap = LoadPicture(OriginalbitmapUri);

                TargatBitmap = LoadPicture(TargatBitmapUri);

                result = CompareReturnRects(Originalbitmap, TargatBitmap, ResultRectSize);

            }

            catch (Exception)

            {

                throw;

            }

            finally

            {

                Originalbitmap.Dispose();

                TargatBitmap.Dispose();

            }

            return result;

        }

        /// <summary>

        /// 이미지를 비교 후 해당 영역을 Rect로 반환한다.

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public List<System.Windows.Rect> CompareReturnRects(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap, Size ResultRectSize)

        {

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

            try

            {

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

                byte[,,] data = MathchesImageData(Originalbitmap, TargatBitmap);

                result =  GetMatchPixels(data, ResultRectSize);

                //if (rects.Count() > 0)

                //{

                //    result = Merge(rects, ResultRectSize.Height);

                //}

                //result = JoinRectList(rects);

            }

            catch (Exception ex)

            {

                throw ex;

            }

            finally

            {

            }

            return result;

        }

        private List<System.Windows.Rect> JoinRectList(List<System.Windows.Rect> rects)

        {

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

            if (rects.Count() > 0)

            {

                System.Windows.Rect rect = rects[0];

                System.Windows.Rect joinRect = rects[0];

                while (rects.Count() > 0)

                {

                    var joinItems = rects.Where(x => RectSizeUp(joinRect, 1).Contains(x)).ToList();

                    if (joinItems.Count() == 0)

                    {

                        result.Add(joinRect);

                    }

                    else

                    {

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

                        {

                            rect = JoinRects(rect, joinItems[i]);

                            rects.Remove(joinItems[i]);

                        }

                        if (rects.Count() > 0)

                        {

                            rects.RemoveAt(0);

                        }

                        result.Add(joinRect);

                    }

                }

            }

            return result;

        }

        private List<System.Windows.Rect> Merge(List<System.Windows.Rect> r,int rectHeight)

        {

            // Computing the bound

            System.Windows.Rect bound = new System.Windows.Rect(r[0].X, r[0].Y, r[0].Width, r[0].Height);

            for (int i = 1; i < r.Count(); ++i)

            {

                bound.X = Math.Min(bound.X, r[i].X);

                bound.Y = Math.Min(bound.Y, r[i].Y);

                bound.Width = Math.Max(bound.Right, r[i].Right) - bound.X;

                bound.Height = Math.Max(bound.Bottom, r[i].Bottom) - bound.Y;

            }

            // Create number of rectangle will be created by vertical strip expansion

            System.Windows.Rect[] m = new System.Windows.Rect[(int)bound.Height / (int)rectHeight];

            for (int i = 0; i < m.Length; ++i)

            {

                m[i] = new System.Windows.Rect(bound.X, bound.Y + i * rectHeight, bound.Y, rectHeight);

            }

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

            {

                int index = ((int)r[i].Y - (int)bound.Y) / rectHeight;

                if (m[index].Width <= 0)

                {

                    m[index].Width = r[i].Width;

                    m[index].X = r[i].X;

                }

                else

                {

                    int right = (int)m[index].Right;

                    m[index].X = Math.Min(m[index].X, r[i].X);

                    m[index].Width = Math.Max(right, r[i].Right) - m[index].X;

                }

            }

            // Merge horozontally

            for (int i = m.Length - 1; i > 0; --i)

            {

                // can only merge when two rect has the same X and Width

                if ((m[i].X == m[i - 1].X) && (m[i].Width == m[i - 1].Width))

                {

                    m[i - 1].Height += m[i].Height; // expanse the rectangle

                    m[i].Width = 0;                // remove one rectangle

                }

            }

            // Remove all the empty rectangle

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

            for (int i = m.Length - 1; i >= 0; --i)

            {

                if (m[i].Width > 0)

                    result.Add(m[i]);

            }

            return result;

        }

        /// <summary>

        /// 이미지를 비교 후 원본 이미지에 Rect를 그린다.

        /// 메모리 문제 발생

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public async Task<Bitmap> CompareDrawRectsAsync(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap, Size ResultRectSize)

        {

            System.Drawing.Bitmap cloneOriginal = Originalbitmap;

            var rects = await CompareReturnRectsAsync(cloneOriginal, TargatBitmap, ResultRectSize);

            if (rects.Count != 0)

            {

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

                {

                    var rect = rects.Select(x => new System.Drawing.Rectangle((int)x.X, (int)x.Y, (int)x.Width, (int)x.Height));

                    g.DrawRectangles(new Pen(Brushes.Blue, 3f), rect.ToArray());

                    g.Save();

                    g.Dispose();

                }

            }

            return cloneOriginal;

        }

        /// <summary>

        /// 이미지를 비교 후 원본 이미지에 Rect를 그린다.

        /// 메모리 문제 발생

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public async Task<System.Windows.Media.Imaging.BitmapSource> CompareDrawRectsAsync(System.Windows.Media.Imaging.BitmapSource Originalbitmap, System.Windows.Media.Imaging.BitmapSource TargatBitmap, Size ResultRectSize)

        {

            var _Originalbitmap = CreateBitmapFromSource(Originalbitmap);

            var _TargatBitmap = CreateBitmapFromSource(TargatBitmap);

            var rects = await CompareReturnRectsAsync(_Originalbitmap, _TargatBitmap, ResultRectSize);

            if (rects.Count != 0)

            {

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

                {

                    var rect = rects.Select(x => new System.Drawing.Rectangle((int)x.X, (int)x.Y, (int)x.Width, (int)x.Height));

                    g.DrawRectangles(new Pen(Brushes.Blue, 3f), rect.ToArray());

                    g.Save();

                    g.Dispose();

                }

            }

            return CreateBitmapSourceFromBitmap(_Originalbitmap);

        }

        public Bitmap CreateBitmapFromSource(System.Windows.Media.Imaging.BitmapSource bitmapsource)

        {

            //convert image format

            var src = new System.Windows.Media.Imaging.FormatConvertedBitmap();

            src.BeginInit();

            src.Source = bitmapsource;

            src.DestinationFormat = System.Windows.Media.PixelFormats.Bgr24;

            src.EndInit();

            //copy to bitmap

            Bitmap bitmap = new Bitmap(src.PixelWidth, src.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb);

            var data = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);

            src.CopyPixels(System.Windows.Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride);

            bitmap.UnlockBits(data);

            return bitmap;

        }

        /// <summary>

        /// 메모리 문제 발생

        /// </summary>

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

        /// <returns></returns>

        public System.Windows.Media.Imaging.WriteableBitmap CreateWriteableBitmapFromBitmap(Bitmap bitmap)

        {

            System.Windows.Media.Imaging.WriteableBitmap result = null;

            if (bitmap == null)

                throw new ArgumentNullException("bitmap");

            try

            {

                int bytesPerPixel = 4;

                result = new System.Windows.Media.Imaging.WriteableBitmap(bitmap.Width, bitmap.Height,

                                                                   bitmap.HorizontalResolution ,bitmap.VerticalResolution,

                                                                   bitmap.PixelFormat.Convert(), null);

                Rectangle colorBitmapRectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);

                System.Windows.Int32Rect colorBitmapInt32Rect = new System.Windows.Int32Rect(0, 0, bitmap.Width, bitmap.Height);

                BitmapData data = bitmap.LockBits(colorBitmapRectangle, ImageLockMode.WriteOnly, bitmap.PixelFormat);

                result.WritePixels(colorBitmapInt32Rect, data.Scan0, data.Width * data.Height * bytesPerPixel, data.Stride);

                bitmap.UnlockBits(data);

            }

            catch (Exception ex)

            {

                //throw ex;

            }

            finally

            {

                bitmap.Dispose();

                bitmap = null;

                //GC.Collect(2);

            }

            return result;

        }

        /// <summary>

        /// 메모리 문제 발생

        /// </summary>

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

        /// <returns></returns>

        public System.Windows.Media.Imaging.BitmapSource CreateBitmapSourceFromBitmap(Bitmap bitmap)

        {

            System.Windows.Media.Imaging.BitmapSource result = null;

            if (bitmap == null)

                throw new ArgumentNullException("bitmap");

            try

            {

                using (var hbitmap = new SafeHBitmapHandle(bitmap.GetHbitmap(), true))

                {

                    result = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(

                        hbitmap.DangerousGetHandle(),

                        IntPtr.Zero,

                        System.Windows.Int32Rect.Empty,

                        System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());

                }

            }

            catch (Exception ex)

            {

                //throw ex;

            }

            finally

            {

                bitmap.Dispose();

                bitmap = null;

                //GC.Collect(2);

            }

            return result;

        }

        public async Task<List<System.Windows.Rect>> CompareReturnRectsAsync(string OriginalbitmapUri, string TargatBitmapUri, Size ResultRectSize)

        {

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

            Bitmap Originalbitmap = null;

            Bitmap TargatBitmap = null;

            try

            {

                Originalbitmap = LoadPicture(OriginalbitmapUri);

                TargatBitmap = LoadPicture(TargatBitmapUri);

                result = await CompareReturnRectsAsync(Originalbitmap, TargatBitmap, ResultRectSize);

            }

            catch (Exception)

            {

                throw;

            }

            finally

            {

                Originalbitmap.Dispose();

                TargatBitmap.Dispose();

            }

            return result;

        }

        /// <summary>

        /// 이미지를 비교 후 해당 영역을 Rect로 반환한다.

        /// </summary>

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

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

        /// <param name="ResultRectSize">반환되는 Rect의 사이즈</param>

        /// <returns></returns>

        public async Task<List<System.Windows.Rect>> CompareReturnRectsAsync(System.Drawing.Bitmap Originalbitmap, System.Drawing.Bitmap TargatBitmap, Size ResultRectSize)

        {

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

            try

            {

                byte[,,] data = MathchesImageData(Originalbitmap, TargatBitmap);

                result = await GetMatchPixelsAsnc(data, ResultRectSize);

                //result = JoinRectList(result);

                //if (result.Count() > 0)

                //{

                //    result = Merge(result, ResultRectSize.Height);

                //}

                data = null;

            }

            catch (Exception ex)

            {

                throw ex;

            }

            finally

            {

            }

            return result;

        }

        protected override void Dispose(bool disposing)

        {

            base.Dispose(disposing);

        }

    }

}

using Emgu.CV;

using Emgu.CV.CvEnum;

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<Gray, Byte> OriginalImageData = null;

        Image<Gray, Byte> TargatImageData = null;

        int Threshold = 60; //stores threshold for thread access

        /// <summary>

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

        /// </summary>

        double gMatchScore = 0.09;

        /// <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_old(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<Gray, Byte>(Originalbitmap);

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

                //OriginalImageData = OriginalImageData.SmoothBilateral(10,50,50);

                //TargatImageData = TargatImageData.SmoothBilateral(10, 50, 50);

                #region Apply dilation and erosion to remove some noise 효과없음

                //OriginalImageData = OriginalImageData.Dilate(1);

                //TargatImageData = TargatImageData.Dilate(1);

                //OriginalImageData = OriginalImageData.Erode(1);

                //TargatImageData = TargatImageData.Erode(1);

                //threshold(OriginalImageData);

                //threshold(TargatImageData);

                #endregion

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

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

                var tmp = OriginalImageData.AbsDiff(TargatImageData).ThresholdBinary(new Gray(50), new Gray(255));

                var matches = tmp.Not();

                // 틀린부분을 반환

                result = matches.Data;

                matches.Dispose();

                tmp.Dispose();

            }

            catch (Exception ex)

            {

                throw ex;

            }

            return result;

        }

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

        {

            Point[][] result = null;

            try

            {

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

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

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

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

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

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

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

                //OriginalImageData = OriginalImageData.SmoothBilateral(10,50,50);

                //TargatImageData = TargatImageData.SmoothBilateral(10, 50, 50);

                #region Apply dilation and erosion to remove some noise 효과없음

                //OriginalImageData = OriginalImageData.Dilate(1);

                //TargatImageData = TargatImageData.Dilate(1);

                //OriginalImageData = OriginalImageData.Erode(1);

                //TargatImageData = TargatImageData.Erode(1);

                //threshold(OriginalImageData);

                //threshold(TargatImageData);

                #endregion

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

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

                var tmp = OriginalImageData.AbsDiff(TargatImageData).ThresholdBinary(new Gray(50), new Gray(255));

                Emgu.CV.Util.VectorOfVectorOfPoint contours = new Emgu.CV.Util.VectorOfVectorOfPoint();

                Mat m = new Mat();

                CvInvoke.FindContours(tmp, contours, m, Emgu.CV.CvEnum.RetrType.External, Emgu.CV.CvEnum.ChainApproxMethod.ChainApproxSimple);

                result = contours.ToArrayOfArray();

                tmp.Dispose();

            }

            catch (Exception ex)

            {

                throw ex;

            }

            return result;

        }

        private void threshold(Emgu.CV.Image<Gray, byte> image)

        {

            Emgu.CV.Image<Gray, byte> outImg = new Image<Gray, byte>(image.Size);

            //CvInvoke.Threshold(image.SmoothGaussian(5), outImg,0, 255, ThresholdType.Mask);

            CvInvoke.AdaptiveThreshold(image.SmoothMedian(1), outImg, 255,AdaptiveThresholdType.GaussianC,ThresholdType.Binary,31,2);

            //CvInvoke.Threshold(image.SmoothGaussian(9), outImg, 100, 255, ThresholdType.Binary | ThresholdType.Otsu);

            image = outImg;

        }

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

            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;

        }

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

            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

    }

}

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)

        {