Python 快速比较图像\矩阵的算法

有一个图像（imA）大小为10x10px，有60 000多个图像（imN）大小为10x10

所有图像都是黑白的

寻找区分第一幅图像（imA）和所有其他图像（imN）的最小点数的任务-对不起，我的英语不好，我添加了img和注释

我做的第一件事，就是用numpy将所有图像转换成矩阵

q=0
for file in inputImages:
    eachImage = os.path.join(generatorFolder, file)
    a[q]=numpy.asarray(Image.open(eachImage))
    q+=1

b=numpy.asarray(Image.open(templateimage))

b[y，x，color]为其列表着色[255255]

a[1-60000，y，x，颜色]

接下来，我使用嵌套比较，深度为3点的非递归搜索如下所示：

for y1 in range(b.shape[0]):
    for x1 in range(b.shape[1]):
        for y2 in range(b.shape[0]):
            for x2 in range(b.shape[1]):
                for y3 in range(b.shape[0]):
                    for x3 in range(b.shape[1]):
                        if y1==y2==y3 and x1==x2==x3:continue

                        check=0
                        for a_el in range(a.shape[0]):
                            if numpy.array_equal(b[y1,x1],a[a_el,y1,x1]) and \
                               numpy.array_equal(b[y2,x2],a[a_el,y2,x2]) and \
                               numpy.array_equal(b[y3,x3],a[a_el,y3,x3]):
                                check=1
                                break

                        if not check:return 'its unic dots'

这段代码的问题是速度非常慢。例如，我们第一个图像与所有其他图像至少有五点不同：

得到100分！/95! * 60000次比较-54207014000000次

没错，我使用了一种稍有不同的算法，它允许您将其转化为： 40!/35!*60000=4.737.657.600.000这不是太少

有没有办法解决我的问题更漂亮，而不是暴力

更新添加img

0行：3个其他图像（imN）4x4

1行：0模板图像（imA）和1-3图像，其中红色标记差异（imA XOR imN）

2行：0图像，其中蓝色标记两个点两个点进行比较

    1 image green its difference, red its compare - difference yes - NEXT

    2 image red its compare - difference NO - Break (these two points is not enough to say that imA differs from imN(2))

3行：与第2行类似，其他点

---

4行：我们选择两个点就足以说明imA不同于imN（1-3）

10x10=100。两幅图像之间的100次比较。你有60000张图片。我认为算法必须是O（100*60000）=O（6000000）。我不知道python，但伪算法应该是这样的：

int minDistinguishPoints = 100; 
int currentPointsDiff;
Image imA;

foreach (Image myImg in ImageItems)
{
    currentPointsDiff = 0;
    for (int i=0; i<10; i++)
       for (int j=0; j<10; j++)
       {
           if (!imA.GetPixel(i,j).Equals(myImg.GetPixel(i,j)))
           {
               currentPointsDiff++;
           }                
       }
    if (minDistinguishPoints > currentPointsDiff)
    {
        minDistinguishPoints = currentPointsDiff;
    }
}

int minDistinguishPoints=100；
int currentPointsDiff；
图像imA；
foreach（ImageItems中的图像myImg）
{
currentPointsDiff=0；
对于（int i=0；i如果我正确理解了您的问题，您需要计算第一张图片上的点数，这与所有其他图片不同，而不管其他图片之间的差异如何

如果是这样的话，除非我遗漏了什么，否则你不能简单地做如下事情：

boolean[10][10] DIFFS // all values set to TRUE
int[10][10] ORIGINAL  // store first pictures color values

foreach IMAGE in [IMAGES - FIRST IMAGE] {
    int[10][10] CURRENT <- IMAGE // store the current image's color values
    for (i : 0 -> 9) {
        for (j : 0 -> 9) {
            if (DIFFS[i][j]) {
                DIFFS[i][j] = ORIGINAL[i][j] != CURRENT[i][j]
            }
        }
    }
}

boolean[10][10]diff//所有值均设置为TRUE
int[10][10]原始//存储第一张图片的颜色值
[图像-第一个图像]中的foreach图像{
int[10][10]CURRENT如果我理解正确，我们可以完全重新定义您的问题。我认为您想要实现的是：快速确定某个给定图像是否等于预定义的60000个图像中的一个或所有图像中的一个。每个图像都是10x10黑/白

因此，每个图像都可以解释为10x10=100位的数组，并且您有60000个预定的给定值，要与之进行比较

你为什么不把你的60000张图片转换成100位整数，然后对它们进行排序，这样你就可以非常有效地比较任何100位整数，找到一个命中或未命中的结果

编辑：如果我正确理解了注释，则图像会大得多。只要已知的图像仍然是可管理的数量（60k是，600k可能也是），您就可以为这些图像生成哈希，并对其进行排序和比较。您有一些前期计算成本，但您只有一次。
我的方法是：

将图像读入60000 x 100数组，设置为1和0
以每像素为基础求和，以获得每个像素“设置”为1英寸的图像数
在参考图像中选择和最小的像素。（如果和为0，则仅需要该像素来区分参考图像和所有其他像素）
现在只查看设置了该位的图像，重新计算总和并再次选择最低值
重复迭代，直到选择了参考图像中的所有设置位（这意味着无法区分它或需要所有位），或者直到总和等于1，这意味着只有一个图像设置了该位
在代码中，对于1000个4x4图像：

import numpy

def least_freq_set_pixel(array, must_have):
    # If it is specified that a certain pixels must be set, remove rows that don't have those pixels set
    if must_have != []:
        for i in must_have:
            array = numpy.delete(array, numpy.where(array[:,i] == 0), axis = 0)

    # Calculate the sum for each pixel
    set_in_n = numpy.sum(array, axis = 0)
    my_index = numpy.argmin(set_in_n)

    # Return the pixel number which is set in the fewest images
    return my_index, set_in_n[my_index]


# Create some test data 4x4 images
numpy.random.seed(11)
a = numpy.array([0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0])
b = numpy.random.randint(0,2,(1000,16))


must_have = []
stop = 0
while stop == 0:
    i,j = least_freq_set_pixel(b, must_have)
    print i,j
    # If the pixel is set in more than one image and not all pixels have been selected yet... find the next pixel
    if j > 1 and len(must_have) <= 16:
        must_have.append(i)
    else:
        stop = 1
        print must_have

导入numpy
定义最小频率设置像素（阵列，必须有）：
#如果指定必须设置特定像素，请删除未设置这些像素的行
如果必须有！=[]：
因为我必须：
array=numpy.delete（array，numpy.where（array[：，i]==0），axis=0）
#计算每个像素的和
在n=numpy.sum（数组，轴=0）中设置
my_index=numpy.argmin（在\u n中设置）
#返回在最少图像中设置的像素数
返回我的索引，在[我的索引]中设置
#创建一些测试数据4x4图像
随机种子（11）
a=numpy.数组（[0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0]）
b=numpy.random.randint（0,2，（1000,16））
必须有=[]
停止=0
当stop==0时：
i、 j=最小频率设置像素（b，必须有）
打印i，j
#如果在多个图像中设置了像素，但尚未选择所有像素…请查找下一个像素
如果j>1和len（必须有）我添加了一张图片和注释来解释。@stukselbax:
O（6000000）
是愚蠢的，因为它等于
O（1）
。你需要参数化输入，比如用
n
（图像的宽度）、
w
（图像的宽度）和
h
（图像的高度）。复杂性是
O（n*w*h）
。这样我们可以比较算法。如果我理解语法，那么你的方法会给出第一张图像唯一的点矩阵。但在我的例子中没有。我添加了一张图片和注释。事实上比我描述的复杂得多。imA不是几百个中的一个。图像序列是imN 100k*100k imN。我发现加速以下操作项目的最小点数。根据我的计算，它将给我大约20倍的加速度。IMA不需要几百倍，这是任何可能的。但是像100kx100k这样大的图像与你描述的完全不同。对其使用哈希算法。im的第二行年龄：一些在imA中但不在imB中的像素被标记，但其他的没有标记。为什么？这两个像素