MARKUS

                    <virtualDirectory path="/" physicalPath="D:\Source\Repos\MARKUS\ConvertService\ConverterService\ConvertionWebService" />

        [global::System.Configuration.ApplicationScopedSettingAttribute()]

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

        [global::System.Configuration.DefaultSettingValueAttribute("tcp://localhost:8091/remConverterPDF")]

        public string ConverterRemotingUrl {

            get {

                return ((string)(this["ConverterRemotingUrl"]));

            }

        }

    <Setting Name="ConverterRemotingUrl" Type="System.String" Scope="Application">

      <Value Profile="(Default)">tcp://localhost:8091/remConverterPDF</Value>

    </Setting>

        <value />

      <setting name="ConverterRemotingUrl" serializeAs="String">

        <value>tcp://localhost:8091/remConverterPDF</value>

      </setting>

        private Object stationObj;

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

    <startup> 

        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />

    </startup>

</configuration>

<Application x:Class="ComparerTestWPF.App"

             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

             xmlns:local="clr-namespace:ComparerTestWPF"

             StartupUri="MainWindow.xaml">

    <Application.Resources>

    </Application.Resources>

</Application>

using System;

using System.Collections.Generic;

using System.Configuration;

using System.Data;

using System.Linq;

using System.Threading.Tasks;

using System.Windows;

namespace ComparerTestWPF

{

    /// <summary>

    /// App.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class App : Application

    {

    }

}

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProjectGuid>{154D99CA-A021-4FFD-A590-5CEBF6C99BB3}</ProjectGuid>

    <OutputType>WinExe</OutputType>

    <RootNamespace>ComparerTestWPF</RootNamespace>

    <AssemblyName>ComparerTestWPF</AssemblyName>

    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>

    <FileAlignment>512</FileAlignment>

    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>

    <WarningLevel>4</WarningLevel>

    <Deterministic>true</Deterministic>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <PlatformTarget>AnyCPU</PlatformTarget>

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>bin\Debug\</OutputPath>

    <DefineConstants>DEBUG;TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

    <Prefer32Bit>false</Prefer32Bit>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <PlatformTarget>AnyCPU</PlatformTarget>

    <DebugType>pdbonly</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>bin\Release\</OutputPath>

    <DefineConstants>TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <ItemGroup>

    <Reference Include="System" />

    <Reference Include="System.Data" />

    <Reference Include="System.Drawing" />

    <Reference Include="System.Xml" />

    <Reference Include="Microsoft.CSharp" />

    <Reference Include="System.Core" />

    <Reference Include="System.Xml.Linq" />

    <Reference Include="System.Data.DataSetExtensions" />

    <Reference Include="System.Net.Http" />

    <Reference Include="System.Xaml">

      <RequiredTargetFramework>4.0</RequiredTargetFramework>

    </Reference>

    <Reference Include="Telerik.Windows.Controls, Version=2019.3.917.45, Culture=neutral, PublicKeyToken=5803cfa389c90ce7, processorArchitecture=MSIL" />

    <Reference Include="Telerik.Windows.Controls.ImageEditor, Version=2019.3.917.45, Culture=neutral, PublicKeyToken=5803cfa389c90ce7, processorArchitecture=MSIL" />

    <Reference Include="Telerik.Windows.Controls.Input, Version=2019.3.917.45, Culture=neutral, PublicKeyToken=5803cfa389c90ce7, processorArchitecture=MSIL" />

    <Reference Include="WindowsBase" />

    <Reference Include="PresentationCore" />

    <Reference Include="PresentationFramework" />

  </ItemGroup>

  <ItemGroup>

    <ApplicationDefinition Include="App.xaml">

      <Generator>MSBuild:Compile</Generator>

      <SubType>Designer</SubType>

    </ApplicationDefinition>

    <Page Include="MainWindow.xaml">

      <Generator>MSBuild:Compile</Generator>

      <SubType>Designer</SubType>

    </Page>

    <Compile Include="App.xaml.cs">

      <DependentUpon>App.xaml</DependentUpon>

      <SubType>Code</SubType>

    </Compile>

    <Compile Include="MainWindow.xaml.cs">

      <DependentUpon>MainWindow.xaml</DependentUpon>

      <SubType>Code</SubType>

    </Compile>

    <Page Include="ImageView.xaml">

      <SubType>Designer</SubType>

      <Generator>MSBuild:Compile</Generator>

    </Page>

  </ItemGroup>

  <ItemGroup>

    <Compile Include="Properties\AssemblyInfo.cs">

      <SubType>Code</SubType>

    </Compile>

    <Compile Include="ImageView.xaml.cs">

      <DependentUpon>ImageView.xaml</DependentUpon>

    </Compile>

    <Compile Include="Properties\Resources.Designer.cs">

      <AutoGen>True</AutoGen>

      <DesignTime>True</DesignTime>

      <DependentUpon>Resources.resx</DependentUpon>

    </Compile>

    <Compile Include="Properties\Settings.Designer.cs">

      <AutoGen>True</AutoGen>

      <DependentUpon>Settings.settings</DependentUpon>

      <DesignTimeSharedInput>True</DesignTimeSharedInput>

    </Compile>

    <EmbeddedResource Include="Properties\Resources.resx">

      <Generator>ResXFileCodeGenerator</Generator>

      <LastGenOutput>Resources.Designer.cs</LastGenOutput>

    </EmbeddedResource>

    <None Include="Properties\Settings.settings">

      <Generator>SettingsSingleFileGenerator</Generator>

      <LastGenOutput>Settings.Designer.cs</LastGenOutput>

    </None>

  </ItemGroup>

  <ItemGroup>

    <None Include="App.config" />

  </ItemGroup>

  <ItemGroup>

    <ProjectReference Include="..\Markus.ImageComparer\Markus.Image.csproj">

      <Project>{b3b05ced-f4eb-4f9d-b458-12fcbe48d546}</Project>

      <Name>Markus.Image</Name>

    </ProjectReference>

  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

</Project>

<Window x:Class="ComparerTestWPF.ImageView"

        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

        xmlns:local="clr-namespace:ComparerTestWPF.Properties"

        xmlns:telerik="http://schemas.telerik.com/2008/xaml/presentation"

        mc:Ignorable="d"

        Title="ImageView" Height="450" Width="800">

    <Grid>

        <telerik:RadImageEditor  x:Name="image"/>

    </Grid>

</Window>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Shapes;

namespace ComparerTestWPF

{

    /// <summary>

    /// ImageView.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class ImageView : Window

    {

        public ImageView(BitmapSource img)

        {

            InitializeComponent();

            this.image.Image = new Telerik.Windows.Media.Imaging.RadBitmap(img);

        }

    }

}

<Window x:Class="ComparerTestWPF.MainWindow"

        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

        xmlns:local="clr-namespace:ComparerTestWPF"

        mc:Ignorable="d"

        Title="MainWindow" Height="450" Width="800">

    <Grid>

        <Grid.RowDefinitions>

            <RowDefinition Height="Auto"/>

            <RowDefinition/>

            <RowDefinition/>

        </Grid.RowDefinitions>

        <StackPanel>

            <StackPanel.Resources>

                <Style TargetType="TextBlock">

                    <Setter Property="FontSize" Value="20"/>

                </Style>

                <Style TargetType="TextBox">

                    <Setter Property="FontSize" Value="20"/>

                    <Setter Property="MinWidth" Value="400"/>

                </Style>

            </StackPanel.Resources>

            <TextBlock Text="비교 대상 이미지 선택"/>

            <StackPanel Orientation="Horizontal">

                <TextBlock Text="원본       "/>

                <TextBox x:Name="TxtOriginalImage"/>

                <Button Content="찾기" Click="btFindOriginalFile_click"/>

            </StackPanel>

            <StackPanel Orientation="Horizontal">

                <TextBlock Text="비교대상  "/>

                <TextBox x:Name="TxtTargetImage"/>

                <Button Content="찾기" Click="btFindTargetFile_click"/>

            </StackPanel>

        </StackPanel>

        <Grid Height="100" Width="200" Grid.Row="1">

        <Grid.RowDefinitions>

            <RowDefinition/>

            <RowDefinition/>

            <RowDefinition/>

        </Grid.RowDefinitions>

            <Button Content="동기 이미지 비교" Click="btNoneTask_Click"/>

            <Button Content="비동기 이미지 비교" Grid.Row="1" Click="btTask_Click"/>

            <Button Content="비동기 URI 이미지 비교" Grid.Row="2" Click="btTaskUri_Click"/>

        </Grid>

        <Grid Grid.Row="2">

            <Grid.ColumnDefinitions>

                <ColumnDefinition/>

                <ColumnDefinition/>

            </Grid.ColumnDefinitions>

            <DataGrid x:Name="lstView"/>

            <DataGrid x:Name="lstView2" Grid.Column="1"/>

        </Grid>

    </Grid>

</Window>

using Microsoft.Win32;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

namespace ComparerTestWPF

{

    /// <summary>

    /// MainWindow.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class MainWindow : Window

    {

        public MainWindow()

        {

            InitializeComponent();

        }

        private void btFindOriginalFile_click(object sender, RoutedEventArgs e)

        {

            TxtOriginalImage.Text = FileOpen();

        }

        private void btFindTargetFile_click(object sender, RoutedEventArgs e)

        {

            TxtTargetImage.Text = FileOpen();

        }

        private string FileOpen()

        {

            string result = null;

            OpenFileDialog openFileDialog = new OpenFileDialog();

            openFileDialog.Filter = "Image Files|*.png;*.jpg;*.bmp";

                if (openFileDialog.ShowDialog() == true)

                    result = openFileDialog.FileName;

                else

                    result = null;

            return result;

        }

        private void btNoneTask_Click(object sender, RoutedEventArgs e)

        {

            BitmapSource bitmapSource = null;

            BitmapSource TargetSource = null;

            using (Markus.Image.ImageComparer imageComparer = new Markus.Image.ImageComparer())

            {

                var original = new System.Drawing.Bitmap(TxtOriginalImage.Text);

                var target = new System.Drawing.Bitmap(TxtTargetImage.Text);

                var result = imageComparer.CompareDrawRects(original, target, new System.Drawing.Size(20, 20));

                bitmapSource = imageComparer.CreateWriteableBitmapFromBitmap(result);

                //var result2 = imageComparer.CompareDrawRects(target, original, new System.Drawing.Size(20, 20));

                //TargetSource = imageComparer.CreateBitmapSourceFromBitmap(result2);

                //result2.Dispose();

                //result2 = null;

                original.Dispose();

                target.Dispose();

            }

            ImageView imageView = new ImageView(bitmapSource);

            imageView.Show();

            //ImageView imageView2 = new ImageView(TargetSource);

            //imageView2.Show();

        }

        private async void btTask_Click(object sender, RoutedEventArgs e)

        {

            BitmapSource bitmapSource = null;

            BitmapSource TargetSource = null;

            using (Markus.Image.ImageComparer imageComparer = new Markus.Image.ImageComparer())

            {

                var original = new System.Drawing.Bitmap(TxtOriginalImage.Text);

                var target = new System.Drawing.Bitmap(TxtTargetImage.Text);

                var result = await imageComparer.CompareReturnRectsAsync(original, target, new System.Drawing.Size(20, 20));

                // bitmapSource = imageComparer.CreateWriteableBitmapFromBitmap(result);

                lstView.ItemsSource = result;

                var original2 = new System.Drawing.Bitmap(TxtOriginalImage.Text);

                var target2 = new System.Drawing.Bitmap(TxtTargetImage.Text);

                var result2 = await imageComparer.CompareReturnRectsAsync(target2, original2, new System.Drawing.Size(20, 20));

                lstView2.ItemsSource = result2;

                //TargetSource = imageComparer.CreateWriteableBitmapFromBitmap(result2);

                original.Dispose();

                target.Dispose();

            }

            //ImageView imageView = new ImageView(bitmapSource);

            //imageView.Show();

            //ImageView imageView2 = new ImageView(TargetSource);

            //imageView2.Show();

        }

        private async void btTaskUri_Click(object sender, RoutedEventArgs e)

        {

            using (Markus.Image.ImageComparer imageComparer = new Markus.Image.ImageComparer())

            {

                var result = await imageComparer.CompareReturnRectsAsync("http://192.168.0.67:5977/TileSource/000000_Tile/110001/11000102/1.png"

                    , "http://192.168.0.67:5977/TileSource/000000_Tile/110001/11000101/1.png", new System.Drawing.Size(20, 20));

                // bitmapSource = imageComparer.CreateWriteableBitmapFromBitmap(result);

                lstView.ItemsSource = result;

                var result2 = await imageComparer.CompareReturnRectsAsync("http://192.168.0.67:5977/TileSource/000000_Tile/110001/11000101/1.png"

                    , "http://192.168.0.67:5977/TileSource/000000_Tile/110001/11000102/1.png", new System.Drawing.Size(20, 20));

                lstView2.ItemsSource = result2;

                //TargetSource = imageComparer.CreateWriteableBitmapFromBitmap(result2);

            }

        }

    }

}

using System.Reflection;

using System.Resources;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

using System.Windows;

// 어셈블리에 대한 일반 정보는 다음 특성 집합을 통해 

// 제어됩니다. 어셈블리와 관련된 정보를 수정하려면

// 이러한 특성 값을 변경하세요.

[assembly: AssemblyTitle("ComparerTestWPF")]

[assembly: AssemblyDescription("")]

[assembly: AssemblyConfiguration("")]

[assembly: AssemblyCompany("")]

[assembly: AssemblyProduct("ComparerTestWPF")]

[assembly: AssemblyCopyright("Copyright ©  2020")]

[assembly: AssemblyTrademark("")]

[assembly: AssemblyCulture("")]

// ComVisible을 false로 설정하면 이 어셈블리의 형식이 COM 구성 요소에 

// 표시되지 않습니다. COM에서 이 어셈블리의 형식에 액세스하려면

// 해당 형식에 대해 ComVisible 특성을 true로 설정하세요.

[assembly: ComVisible(false)]

//지역화 가능 응용 프로그램 빌드를 시작하려면 다음을 설정하세요.

//.csproj 파일에서 <PropertyGroup> 내에 <UICulture>CultureYouAreCodingWith</UICulture>를

//설정하십시오. 예를 들어 소스 파일에서 영어(미국)를

//사용하는 경우 <UICulture>를 en-US로 설정합니다. 그런 다음 아래

//NeutralResourceLanguage 특성의 주석 처리를 제거합니다. 아래 줄의 "en-US"를 업데이트하여

//프로젝트 파일의 UICulture 설정과 일치시킵니다.

//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]

[assembly: ThemeInfo(

    ResourceDictionaryLocation.None, //테마별 리소스 사전의 위치

                                     //(페이지 또는 응용 프로그램 리소스 사진에

                                     // 리소스가 없는 경우에 사용됨)

    ResourceDictionaryLocation.SourceAssembly //제네릭 리소스 사전의 위치

                                              //(페이지 또는 응용 프로그램 리소스 사진에

                                              // 리소스가 없는 경우에 사용됨)

)]

// 어셈블리의 버전 정보는 다음 네 가지 값으로 구성됩니다.

//

//      주 버전

//      부 버전 

//      빌드 번호

//      수정 버전

//

// 모든 값을 지정하거나 아래와 같이 '*'를 사용하여 빌드 번호 및 수정 번호가 자동으로

// 지정되도록 할 수 있습니다.

// [assembly: AssemblyVersion("1.0.*")]

[assembly: AssemblyVersion("1.0.0.0")]

[assembly: AssemblyFileVersion("1.0.0.0")]

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 도구를 사용하여 생성되었습니다.

//     런타임 버전:4.0.30319.42000

//

//     파일 내용을 변경하면 잘못된 동작이 발생할 수 있으며, 코드를 다시 생성하면

//     이러한 변경 내용이 손실됩니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace ComparerTestWPF.Properties

{

    /// <summary>

    ///   지역화된 문자열 등을 찾기 위한 강력한 형식의 리소스 클래스입니다.

    /// </summary>

    // 이 클래스는 ResGen 또는 Visual Studio와 같은 도구를 통해 StronglyTypedResourceBuilder

    // 클래스에서 자동으로 생성되었습니다.

    // 멤버를 추가하거나 제거하려면 .ResX 파일을 편집한 다음 /str 옵션을 사용하여

    // ResGen을 다시 실행하거나 VS 프로젝트를 다시 빌드하십시오.

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]

    internal class Resources

    {

        private static global::System.Resources.ResourceManager resourceMan;

        private static global::System.Globalization.CultureInfo resourceCulture;

        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]

        internal Resources()

        {

        }

        /// <summary>

        ///   이 클래스에서 사용하는 캐시된 ResourceManager 인스턴스를 반환합니다.

        /// </summary>

        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]

        internal static global::System.Resources.ResourceManager ResourceManager

        {

            get

            {

                if ((resourceMan == null))

                {

                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ComparerTestWPF.Properties.Resources", typeof(Resources).Assembly);

                    resourceMan = temp;

                }

                return resourceMan;

            }

        }

        /// <summary>

        ///   이 강력한 형식의 리소스 클래스를 사용하여 모든 리소스 조회에 대해 현재 스레드의 CurrentUICulture 속성을

        ///   재정의합니다.

        /// </summary>

        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]

        internal static global::System.Globalization.CultureInfo Culture

        {

            get

            {

                return resourceCulture;

            }

            set

            {

                resourceCulture = value;

            }

        }

    }

}

<?xml version="1.0" encoding="utf-8"?>

<root>

  <!-- 

    Microsoft ResX Schema 

    Version 2.0

    The primary goals of this format is to allow a simple XML format 

    that is mostly human readable. The generation and parsing of the 

    various data types are done through the TypeConverter classes 

    associated with the data types.

    Example:

    ... ado.net/XML headers & schema ...

    <resheader name="resmimetype">text/microsoft-resx</resheader>

    <resheader name="version">2.0</resheader>

    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>

    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>

    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>

    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>

    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">

        <value>[base64 mime encoded serialized .NET Framework object]</value>

    </data>

    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">

        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>

        <comment>This is a comment</comment>

    </data>

    There are any number of "resheader" rows that contain simple 

    name/value pairs.

    Each data row contains a name, and value. The row also contains a 

    type or mimetype. Type corresponds to a .NET class that support 

    text/value conversion through the TypeConverter architecture. 

    Classes that don't support this are serialized and stored with the 

    mimetype set.

    The mimetype is used for serialized objects, and tells the 

    ResXResourceReader how to depersist the object. This is currently not 

    extensible. For a given mimetype the value must be set accordingly:

    Note - application/x-microsoft.net.object.binary.base64 is the format 

    that the ResXResourceWriter will generate, however the reader can 

    read any of the formats listed below.

    mimetype: application/x-microsoft.net.object.binary.base64

    value   : The object must be serialized with 

            : System.Serialization.Formatters.Binary.BinaryFormatter

            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.soap.base64

    value   : The object must be serialized with 

            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter

            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64

    value   : The object must be serialized into a byte array 

            : using a System.ComponentModel.TypeConverter

            : and then encoded with base64 encoding.

    -->

  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">

    <xsd:element name="root" msdata:IsDataSet="true">

      <xsd:complexType>

        <xsd:choice maxOccurs="unbounded">

          <xsd:element name="metadata">

            <xsd:complexType>

              <xsd:sequence>

                <xsd:element name="value" type="xsd:string" minOccurs="0" />

              </xsd:sequence>

              <xsd:attribute name="name" type="xsd:string" />

              <xsd:attribute name="type" type="xsd:string" />

              <xsd:attribute name="mimetype" type="xsd:string" />

            </xsd:complexType>

          </xsd:element>

          <xsd:element name="assembly">

            <xsd:complexType>

              <xsd:attribute name="alias" type="xsd:string" />

              <xsd:attribute name="name" type="xsd:string" />

            </xsd:complexType>

          </xsd:element>

          <xsd:element name="data">

            <xsd:complexType>

              <xsd:sequence>

                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />

                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />

              </xsd:sequence>

              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />

              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />

              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />

            </xsd:complexType>

          </xsd:element>

          <xsd:element name="resheader">

            <xsd:complexType>

              <xsd:sequence>

                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />

              </xsd:sequence>

              <xsd:attribute name="name" type="xsd:string" use="required" />

            </xsd:complexType>

          </xsd:element>

        </xsd:choice>

      </xsd:complexType>

    </xsd:element>

  </xsd:schema>

  <resheader name="resmimetype">

    <value>text/microsoft-resx</value>

  </resheader>

  <resheader name="version">

    <value>2.0</value>

  </resheader>

  <resheader name="reader">

    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>

  </resheader>

  <resheader name="writer">

    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>

  </resheader>

</root>

//------------------------------------------------------------------------------

// <auto-generated>

//     This code was generated by a tool.

//     Runtime Version:4.0.30319.42000

//

//     Changes to this file may cause incorrect behavior and will be lost if

//     the code is regenerated.

// </auto-generated>

//------------------------------------------------------------------------------

namespace ComparerTestWPF.Properties

{

    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]

    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase

    {

        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));

        public static Settings Default

        {

            get

            {

                return defaultInstance;

            }

        }

    }

}

<?xml version='1.0' encoding='utf-8'?>

<SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">

  <Profiles>

    <Profile Name="(Default)" />

  </Profiles>

  <Settings />

</SettingsFile>



Microsoft Visual Studio Solution File, Format Version 12.00

# Visual Studio 15

VisualStudioVersion = 15.0.28307.902

MinimumVisualStudioVersion = 10.0.40219.1

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Markus.Image", "Markus.ImageComparer\Markus.Image.csproj", "{B3B05CED-F4EB-4F9D-B458-12FCBE48D546}"

EndProject

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ComparerTestWPF", "ComparerTestWPF\ComparerTestWPF.csproj", "{154D99CA-A021-4FFD-A590-5CEBF6C99BB3}"

EndProject

Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Nuget", "Nuget", "{101826B1-FAA0-42AE-B81E-BF0B4CAD526F}"

	ProjectSection(SolutionItems) = preProject

		Nuget\Markus.Image.nupkg = Nuget\Markus.Image.nupkg

	EndProjectSection

EndProject

Global

	GlobalSection(SolutionConfigurationPlatforms) = preSolution

		Debug|Any CPU = Debug|Any CPU

		Release|Any CPU = Release|Any CPU

	EndGlobalSection

	GlobalSection(ProjectConfigurationPlatforms) = postSolution

		{B3B05CED-F4EB-4F9D-B458-12FCBE48D546}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{B3B05CED-F4EB-4F9D-B458-12FCBE48D546}.Debug|Any CPU.Build.0 = Debug|Any CPU

		{B3B05CED-F4EB-4F9D-B458-12FCBE48D546}.Release|Any CPU.ActiveCfg = Release|Any CPU

		{B3B05CED-F4EB-4F9D-B458-12FCBE48D546}.Release|Any CPU.Build.0 = Release|Any CPU

		{154D99CA-A021-4FFD-A590-5CEBF6C99BB3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{154D99CA-A021-4FFD-A590-5CEBF6C99BB3}.Debug|Any CPU.Build.0 = Debug|Any CPU

		{154D99CA-A021-4FFD-A590-5CEBF6C99BB3}.Release|Any CPU.ActiveCfg = Release|Any CPU

		{154D99CA-A021-4FFD-A590-5CEBF6C99BB3}.Release|Any CPU.Build.0 = Release|Any CPU

	EndGlobalSection

	GlobalSection(SolutionProperties) = preSolution

		HideSolutionNode = FALSE

	EndGlobalSection

	GlobalSection(ExtensibilityGlobals) = postSolution

		SolutionGuid = {845D8227-7407-4233-A0F3-E2E6CCDCA8B0}

	EndGlobalSection

EndGlobal

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

            {

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

        }

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

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