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

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

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

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

解决方案

数据文件:paw.txt。源代码:

from scipy import *
from operator import itemgetter

n = 5  # how many fingers are we looking for

d = loadtxt("paw.txt")
width, height = d.shape

# Create an array where every element is a sum of 2x2 squares.

fourSums = d[:-1,:-1] + d[1:,:-1] + d[1:,1:] + d[:-1,1:]

# Find positions of the fingers.

# Pair each sum with its position number (from 0 to width*height-1),

pairs = zip(arange(width*height), fourSums.flatten())

# Sort by descending sum value, filter overlapping squares

def drop_overlapping(pairs):
    no_overlaps = []
    def does_not_overlap(p1, p2):
        i1, i2 = p1[0], p2[0]
        r1, col1 = i1 / (width-1), i1 % (width-1)
        r2, col2 = i2 / (width-1), i2 % (width-1)
        return (max(abs(r1-r2),abs(col1-col2)) >= 2)
    for p in pairs:
        if all(map(lambda prev: does_not_overlap(p,prev), no_overlaps)):
            no_overlaps.append(p)
    return no_overlaps

pairs2 = drop_overlapping(sorted(pairs, key=itemgetter(1), reverse=True))

# Take the first n with the heighest values

positions = pairs2[:n]

# Print results

print d, "\n"

for i, val in positions:
    row = i / (width-1)
    column = i % (width-1)
    print "sum = %f @ %d,%d (%d)" % (val, row, column, i)
    print d[row:row+2,column:column+2], "\n"

输出不重叠方块。似乎选择的区域与您的示例中相同。

一些评论

棘手的部分是计算所有2x2平方的和。我猜你们都需要，所以可能会有重叠。我使用切片从原始2D数组中切割第一个/最后一个列和行，然后将它们全部重叠在一起并计算总和。

为了更好地理解它，对一个3x3数组进行成像:

>>> a = arange(9).reshape(3,3) ; a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

然后你可以把它切片:

>>> a[:-1,:-1]
array([[0, 1],
       [3, 4]])
>>> a[1:,:-1]
array([[3, 4],
       [6, 7]])
>>> a[:-1,1:]
array([[1, 2],
       [4, 5]])
>>> a[1:,1:]
array([[4, 5],
       [7, 8]])

现在想象一下，你把它们一个叠在另一个上面，然后在相同的位置上求和。这些和将与左上角位置相同的2x2平方的和完全相同:

>>> sums = a[:-1,:-1] + a[1:,:-1] + a[:-1,1:] + a[1:,1:]; sums
array([[ 8, 12],
       [20, 24]])

当你有2x2平方的和时，你可以用max来求最大值，或者排序，或者排序来求峰值。

为了记住峰值的位置，我将每个值(总和)与其在扁平数组中的序数位置(参见zip)耦合起来。然后在打印结果时再次计算行/列位置。

笔记

我允许2x2平方重叠。编辑后的版本过滤掉其中的一些，这样只有不重叠的正方形出现在结果中。

选择手指(一个想法)

另一个问题是如何从所有的峰中选择可能是手指的峰。我有个主意，可能有用也可能没用。我现在没有时间实现它，所以只是伪代码。

我注意到，如果前面的手指几乎保持在一个完美的圆圈上，后面的手指应该在这个圆圈里。此外，食指的间距也差不多相等。我们可以尝试使用这些启发式属性来检测手指。

伪代码:

select the top N finger candidates (not too many, 10 or 12)
consider all possible combinations of 5 out of N (use itertools.combinations)
for each combination of 5 fingers:
    for each finger out of 5:
        fit the best circle to the remaining 4
        => position of the center, radius
        check if the selected finger is inside of the circle
        check if the remaining four are evenly spread
        (for example, consider angles from the center of the circle)
        assign some cost (penalty) to this selection of 4 peaks + a rear finger
        (consider, probably weighted:
             circle fitting error,
             if the rear finger is inside,
             variance in the spreading of the front fingers,
             total intensity of 5 peaks)
choose a combination of 4 peaks + a rear peak with the lowest penalty

这是一种蛮力方法。如果N相对较小，那么我认为它是可行的。对于N=12，有C_12^5 = 792种组合，乘以5种选择后指的方法，所以每个爪子要评估3960种情况。

我不确定这是否回答了问题，但似乎你可以只寻找n个没有邻居的最高的山峰。

这是要点。注意，它是用Ruby编写的，但其思想应该很清楚。

require 'pp'

NUM_PEAKS = 5
NEIGHBOR_DISTANCE = 1

data = [[1,2,3,4,5],
        [2,6,4,4,6],
        [3,6,7,4,3],
       ]

def tuples(matrix)
  tuples = []
  matrix.each_with_index { |row, ri|
    row.each_with_index { |value, ci|
      tuples << [value, ri, ci]
    }
  }
  tuples
end

def neighbor?(t1, t2, distance = 1)
  [1,2].each { |axis|
    return false if (t1[axis] - t2[axis]).abs > distance
  }
  true
end

# convert the matrix into a sorted list of tuples (value, row, col), highest peaks first
sorted = tuples(data).sort_by { |tuple| tuple.first }.reverse

# the list of peaks that don't have neighbors
non_neighboring_peaks = []

sorted.each { |candidate|
  # always take the highest peak
  if non_neighboring_peaks.empty?
    non_neighboring_peaks << candidate
    puts "took the first peak: #{candidate}"
  else
    # check that this candidate doesn't have any accepted neighbors
    is_ok = true
    non_neighboring_peaks.each { |accepted|
      if neighbor?(candidate, accepted, NEIGHBOR_DISTANCE)
        is_ok = false
        break
      end
    }
    if is_ok
      non_neighboring_peaks << candidate
      puts "took #{candidate}"
    else
      puts "denied #{candidate}"
    end
  end
}

pp non_neighboring_peaks

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

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

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

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

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

物理学家对这个问题进行了深入的研究。在ROOT中有一个很好的实现。查看TSpectrum类(特别是TSpectrum2)和它们的文档。

引用:

M.Morhac et al.: Background elimination methods for multidimensional coincidence gamma-ray spectra. Nuclear Instruments and Methods in Physics Research A 401 (1997) 113-132. M.Morhac et al.: Efficient one- and two-dimensional Gold deconvolution and its application to gamma-ray spectra decomposition. Nuclear Instruments and Methods in Physics Research A 401 (1997) 385-408. M.Morhac et al.: Identification of peaks in multidimensional coincidence gamma-ray spectra. Nuclear Instruments and Methods in Research Physics A 443(2000), 108-125.

.．.对于那些没有订阅NIM的人:

Spectrum.doc SpectrumDec.ps.gz SpectrumSrc.ps.gz SpectrumBck.ps.gz