这是我在大型望远镜上做类似事情时使用的另一种方法:

1)搜索最高像素。 一旦你有了这个，在周围搜索2x2的最佳拟合(可能是最大化2x2的和)，或者在4x4的子区域内做一个2d高斯拟合，以最高像素为中心。

然后在峰值中心周围将那些2x2像素设置为0(或者3x3)

回到1)，重复直到峰值低于噪声阈值，或者你有所有你需要的脚趾

物理学家的解决办法: 定义5个爪标记，用它们的位置X_i来标识，并用随机的位置初始化它们。 定义一个能量函数，结合标记物在爪子位置的定位奖励和标记物重叠惩罚;比方说:

E(X_i;S)=-Sum_i(S(X_i))+alfa*Sum_ij (|X_i-Xj|<=2*sqrt(2)?1:0)

(S(X_i)是围绕X_i的2x2平方的平均力，阿尔法是一个实验峰值参数)

Now time to do some Metropolis-Hastings magic: 1. Select random marker and move it by one pixel in random direction. 2. Calculate dE, the difference of energy this move caused. 3. Get an uniform random number from 0-1 and call it r. 4. If dE<0 or exp(-beta*dE)>r, accept the move and go to 1; if not, undo the move and go to 1. This should be repeated until the markers will converge to paws. Beta controls the scanning to optimizing tradeoff, so it should be also optimized experimentally; it can be also constantly increased with the time of simulation (simulated annealing).

也许一个简单的方法在这里就足够了:建立一个平面上所有2x2正方形的列表，按它们的和排序(降序)。

首先，在你的“爪子列表”中选择价值最高的方块。然后，迭代地选择4个次优正方形，这些正方形不与之前找到的任何正方形相交。

我相信你现在已经有足够的信息了，但我忍不住建议使用k-均值聚类方法。k-means是一种无监督聚类算法，它将你的数据(在任何维度上-我碰巧在3D中这样做)，并将其排列成k个具有明显边界的聚类。这里很好，因为你确切地知道这些犬齿应该有多少脚趾。

此外，它是在Scipy中实现的，非常好(http://docs.scipy.org/doc/scipy/reference/cluster.vq.html)。

下面是它在空间上解析3D集群的一个例子:

你想要做的有点不同(2D，包括压力值)，但我仍然认为你可以尝试一下。

如果你一步一步地进行:你首先找到全局最大值，如果需要处理周围的点，然后将找到的区域设置为零，然后对下一个重复。

好吧，这里有一些简单而不是非常有效的代码，但对于这样大的数据集来说，这是很好的。

import numpy as np
grid = np.array([[0,0,0,0,0,0,0,0,0,0,0,0,0,0],
              [0,0,0,0,0,0,0,0,0.4,0.4,0.4,0,0,0],
              [0,0,0,0,0.4,1.4,1.4,1.8,0.7,0,0,0,0,0],
              [0,0,0,0,0.4,1.4,4,5.4,2.2,0.4,0,0,0,0],
              [0,0,0.7,1.1,0.4,1.1,3.2,3.6,1.1,0,0,0,0,0],
              [0,0.4,2.9,3.6,1.1,0.4,0.7,0.7,0.4,0.4,0,0,0,0],
              [0,0.4,2.5,3.2,1.8,0.7,0.4,0.4,0.4,1.4,0.7,0,0,0],
              [0,0,0.7,3.6,5.8,2.9,1.4,2.2,1.4,1.8,1.1,0,0,0],
              [0,0,1.1,5,6.8,3.2,4,6.1,1.8,0.4,0.4,0,0,0],
              [0,0,0.4,1.1,1.8,1.8,4.3,3.2,0.7,0,0,0,0,0],
              [0,0,0,0,0,0.4,0.7,0.4,0,0,0,0,0,0]])

arr = []
for i in xrange(grid.shape[0] - 1):
    for j in xrange(grid.shape[1] - 1):
        tot = grid[i][j] + grid[i+1][j] + grid[i][j+1] + grid[i+1][j+1]
        arr.append([(i,j),tot])

best = []

arr.sort(key = lambda x: x[1])

for i in xrange(5):
    best.append(arr.pop())
    badpos = set([(best[-1][0][0]+x,best[-1][0][1]+y)
                  for x in [-1,0,1] for y in [-1,0,1] if x != 0 or y != 0])
    for j in xrange(len(arr)-1,-1,-1):
        if arr[j][0] in badpos:
            arr.pop(j)


for item in best:
    print grid[item[0][0]:item[0][0]+2,item[0][1]:item[0][1]+2]

我基本上只是用左上角的位置和每个2x2平方的和来做一个数组，然后根据和来排序。然后我把和最高的2x2平方从竞争中取出，把它放在最好的数组中，然后删除所有其他使用了这个2x2平方的部分的2x2平方。

It seems to work fine except with the last paw (the one with the smallest sum on the far right in your first picture), it turns out that there are two other eligible 2x2 squares with a larger sum (and they have an equal sum to each other). One of them is still selects one square from your 2x2 square, but the other is off to the left. Fortunately, by luck we see to be choosing more of the one that you would want, but this may require some other ideas to be used to get what you actually want all of the time.