C# iPhone上的位图比较方法（unity3d）

在iPhone上比较Unity3d中的2个位图并获得2（0完全不同，1完全相同）之间的相关性的最佳方法是什么？我使用C#，因为文档中说使用Boo或UnityScript会增加应用程序的大小

我需要的是类似于指纹识别方法的东西，但不是那么准确。因为这是为了在iPhone上运行，所以性能在这里是一个大问题

示例图像：

对于那些我希望有一个大约0.5的相关系数，因为它们相似但颜色不同。比较有许多不同的维度，但基本的维度是颜色和形状

任何帮助都将不胜感激。

为了回答我自己的问题，在谷歌搜索了几天之后，我发现。基本思想是测试具有偏移/旋转的图像，搜索主色等。到目前为止，这是我能找到的最好的信息，所以我将尝试一下

此处建议的代码如下所示：

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace BitmapSimilarity
{
    public interface IBitmapCompare
    {
        double GetSimilarity(Bitmap a, Bitmap b);
    }

    class BitmapCompare: IBitmapCompare
    {
        public struct RGBdata
        {
            public int r;
            public int g;
            public int b;

            public int GetLargest()
            {
                if(r>b)
                {
                    if(r>g)
                    {
                        return 1;
                    }
                    else
                    {
                        return 2;
                    }
                }
                else
                {
                    return 3;
                }
            }
        }

        private RGBdata ProcessBitmap(Bitmap a)
        {
            BitmapData bmpData = a.LockBits(new Rectangle(0,0,a.Width,a.Height),ImageLockMode.ReadOnly,PixelFormat.Format24bppRgb);
            IntPtr ptr = bmpData.Scan0;
            RGBdata data = new RGBdata();

            unsafe
            {
                byte* p = (byte*)(void*)ptr;
                int offset = bmpData.Stride - a.Width * 3;
                int width = a.Width * 3;

                for (int y = 0; y < a.Height; ++y)
                {
                    for (int x = 0; x < width; ++x)
                    {
                        data.r += p[0];             //gets red values
                        data.g += p[1];             //gets green values
                        data.b += p[2];             //gets blue values
                        ++p;
                    }
                    p += offset;
                }
            }
            a.UnlockBits(bmpData);
            return data;
        }

        public double GetSimilarity(Bitmap a, Bitmap b)
        {
            RGBdata dataA = ProcessBitmap(a);
            RGBdata dataB = ProcessBitmap(b);
            double result = 0;
            int averageA = 0;
            int averageB = 0;
            int maxA = 0;
            int maxB = 0;

            maxA = ((a.Width * 3) * a.Height);
            maxB = ((b.Width * 3) * b.Height);

            switch (dataA.GetLargest())            //Find dominant color to compare
            {
                case 1:
                    {
                        averageA = Math.Abs(dataA.r / maxA);
                        averageB = Math.Abs(dataB.r / maxB);
                        result = (averageA - averageB) / 2;
                        break;
                    }
                case 2:
                    {
                        averageA = Math.Abs(dataA.g / maxA);
                        averageB = Math.Abs(dataB.g / maxB);
                        result = (averageA - averageB) / 2;
                        break;
                    }
                case 3:
                    {
                        averageA = Math.Abs(dataA.b / maxA);
                        averageB = Math.Abs(dataB.b / maxB);
                        result = (averageA - averageB) / 2;
                        break;
                    }
            }

            result = Math.Abs((result + 100) / 100);

            if (result > 1.0)
            {
                result -= 1.0;
            }

            return result;
        }
    }

    class Program
    {
        static BitmapCompare SimpleCompare;
        static Bitmap searchImage;

        static private void Line()
        {
            for (int x = 0; x < Console.BufferWidth; x++)
            {
                Console.Write("*");
            }
        }

        static void CheckDirectory(string directory,double percentage,Bitmap sImage)
        {
            DirectoryInfo dir = new DirectoryInfo(directory);
            FileInfo[] files = null;
            try
            {
                files = dir.GetFiles("*.jpg");
            }
            catch (DirectoryNotFoundException)
            {
                Console.WriteLine("Bad directory specified");
                return;
            }

            double sim = 0;

            foreach (FileInfo f in files)
            {
                sim = Math.Round(SimpleCompare.GetSimilarity(sImage, new Bitmap(f.FullName)),3);
                if (sim >= percentage)
                {
                    Console.WriteLine(f.Name);
                    Console.WriteLine("Match of: {0}", sim);
                    Line(); 
                }
            }
        }

        static void Main(string[] args)
        {
            SimpleCompare = new BitmapCompare();
            Console.Write("Enter path to search image: ");
            try
            {
                searchImage = new Bitmap(Console.ReadLine());
            }
            catch (ArgumentException)
            {
                Console.WriteLine("Bad file");
                return;
            }

            Console.Write("Enter directory to scan: ");
            string dir = Console.ReadLine();
            Line();
            CheckDirectory(dir, 0.95 , searchImage);        //Display only images that match by 95%
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用系统文本；
使用系统图；
使用系统、绘图、成像；
使用System.IO；
命名空间位图相似性
{
公共接口IBitMacCompare
{
双重相似性（位图a、位图b）；
}
类BitmapCompare:IBitmapCompare
{
公共结构RGBdata
{
公共INTR；
公共INTG；
公共int b；
公共int getmax（）
{
如果（r>b）
{
如果（r>g）
{
返回1；
}
其他的
{
返回2；
}
}
其他的
{
返回3；
}
}
}
专用RGB数据处理位图（位图a）
{
BitmapData bmpData=a.LockBits（新矩形（0,0，a.Width，a.Height），ImageLockMode.ReadOnly，PixelFormat.Format24bppRgb）；
IntPtr ptr=bmpData.Scan0；
RGBdata data=新的RGBdata（）；
不安全的
{
字节*p=（字节*）（空*）ptr；
int offset=bmpData.Stride-a.Width*3；
内部宽度=a.宽度*3；
对于（int y=0；y1.0）
{
结果-=1.0；
}
返回结果；
}
}
班级计划
{
静态位图比较SimpleCompare；
静态位图图像；
静态私有空位线（）
{
对于（int x=0；x=百分比）
{
Console.WriteLine（f.Name）；
WriteLine（“匹配：{0}”，sim）；
第（）行；
}
}
}
静态void Main（字符串[]参数）
{
SimpleCompare=新的位图比较（）；
编写（“输入搜索图像的路径：”）；
尝试
{
searchImage=新位图（Console.ReadLine（））；
}
捕获（异常）
{
控制台写入线(