物理学家的解决办法: 定义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).

有趣的问题。我想尝试的解决方案如下。

应用一个低通滤波器，比如用二维高斯掩码卷积。这将给你一堆(可能，但不一定是浮点数)值。 使用每个爪垫(或脚趾)的已知近似半径执行2D非最大抑制。

这将为你提供最大的职位，而不是有多个候选人。澄清一下，第1步中蒙版的半径也应该与第2步中使用的半径相似。这个半径是可以选择的，或者兽医可以事先明确测量它(它会随着年龄/品种等而变化)。

建议的一些解决方案(均值漂移、神经网络等)可能在某种程度上是可行的，但它们过于复杂，可能并不理想。

这是一个图像配准问题。总的策略是:

有一个已知的例子，或者有一些先验的数据。 将数据与示例相匹配，或将示例与数据相匹配。 如果您的数据在一开始就大致对齐，这是有帮助的。

这里有一个粗略而现成的方法，“可能起作用的最愚蠢的方法”:

从五个脚趾坐标开始，大致在你期望的位置。 使用每一个，迭代地爬到山顶。即给定当前位置，移动到最大邻近像素，如果它的值大于当前像素。当你的脚趾坐标停止移动时停止。

为了解决方向问题，你可以为基本方向设置8个左右的初始设置(北，东北等)。单独运行每一个，并丢弃任何两个或多个脚趾最终位于同一像素的结果。我会再思考一下这个问题，但这种事情在图像处理中还在研究中——没有正确的答案!

稍微复杂一点的想法:(加权)k -均值聚类。没那么糟。

从五个脚趾坐标开始，但现在这些是“集群中心”。

然后迭代直到收敛:

将每个像素分配到最近的集群(只需为每个集群制作一个列表)。 计算每个簇的质心。对于每个聚类，这是:Sum(坐标*强度值)/Sum(坐标) 移动每个星团到新的质心。

这种方法几乎肯定会得到更好的结果，你可以得到每个簇的质量，这可能有助于识别脚趾。

(同样，您已经预先指定了集群的数量。对于聚类，您必须以一种或另一种方式指定密度:要么选择集群的数量，在这种情况下合适，要么选择集群半径，看看最终有多少。后者的一个例子是mean-shift。)

很抱歉缺少实现细节或其他细节。我可以把它写出来，但我有最后期限了。如果到下周还没有效果，请告诉我，我会试试的。

如果你能够创建一些训练数据，那么使用神经网络可能是值得尝试的……但这需要手工标注许多样本。

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

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.

我用局部最大滤波器检测了峰值。下面是你的第一个4个爪子数据集的结果:

我还在9个爪子的第二个数据集上运行了它，效果也很好。

你可以这样做:

import numpy as np
from scipy.ndimage.filters import maximum_filter
from scipy.ndimage.morphology import generate_binary_structure, binary_erosion
import matplotlib.pyplot as pp

#for some reason I had to reshape. Numpy ignored the shape header.
paws_data = np.loadtxt("paws.txt").reshape(4,11,14)

#getting a list of images
paws = [p.squeeze() for p in np.vsplit(paws_data,4)]


def detect_peaks(image):
    """
    Takes an image and detect the peaks usingthe local maximum filter.
    Returns a boolean mask of the peaks (i.e. 1 when
    the pixel's value is the neighborhood maximum, 0 otherwise)
    """

    # define an 8-connected neighborhood
    neighborhood = generate_binary_structure(2,2)

    #apply the local maximum filter; all pixel of maximal value 
    #in their neighborhood are set to 1
    local_max = maximum_filter(image, footprint=neighborhood)==image
    #local_max is a mask that contains the peaks we are 
    #looking for, but also the background.
    #In order to isolate the peaks we must remove the background from the mask.

    #we create the mask of the background
    background = (image==0)

    #a little technicality: we must erode the background in order to 
    #successfully subtract it form local_max, otherwise a line will 
    #appear along the background border (artifact of the local maximum filter)
    eroded_background = binary_erosion(background, structure=neighborhood, border_value=1)

    #we obtain the final mask, containing only peaks, 
    #by removing the background from the local_max mask (xor operation)
    detected_peaks = local_max ^ eroded_background

    return detected_peaks


#applying the detection and plotting results
for i, paw in enumerate(paws):
    detected_peaks = detect_peaks(paw)
    pp.subplot(4,2,(2*i+1))
    pp.imshow(paw)
    pp.subplot(4,2,(2*i+2) )
    pp.imshow(detected_peaks)

pp.show()

之后你所需要做的就是在蒙版上使用scipy. nmage .measurements.label来标记所有不同的对象。然后你就可以单独和他们玩了。

注意，该方法工作得很好，因为背景没有噪声。如果是的话，你会在背景中检测到一堆其他不想要的峰。另一个重要因素是社区的大小。如果峰值大小发生变化，您将需要调整它(应该保持大致成比例)。