python एक 2 डी सरणी में पीक पहचान




image-processing (17)

यदि आप कुछ प्रशिक्षण डेटा तैयार करने में सक्षम हैं तो संभवतः तंत्रिका नेटवर्क के साथ प्रयास करना उचित है ... लेकिन इसे हाथ से एनोटेट किए गए कई नमूने की आवश्यकता है।

मैं कुत्तों के पंजे के नीचे एक पशु चिकित्सा क्लिनिक मापने के दबाव में मदद कर रहा हूं। मैं अपने डेटा विश्लेषण के लिए पायथन का उपयोग करता हूं और अब मैं पंजे को (रचनात्मक) उप-वर्गों में विभाजित करने की कोशिश कर रहा हूं।

मैंने प्रत्येक पंजा की 2 डी सरणी बनाई, जिसमें प्रत्येक सेंसर के लिए अधिकतम मान होते हैं जो समय के साथ पंजा द्वारा लोड किया गया है। यहां एक पंजा का एक उदाहरण दिया गया है, जहां मैंने एक्सेल का उपयोग उन क्षेत्रों को आकर्षित करने के लिए किया था जिन्हें मैं 'पहचान' करना चाहता हूं। ये स्थानीय अधिकतममा के साथ सेंसर के चारों ओर 2 से 2 बक्से हैं, जिनके साथ सबसे बड़ा योग है।

तो मैंने कुछ प्रयोग करने की कोशिश की और बस प्रत्येक कॉलम और पंक्ति की अधिकतम सीमाओं को देखने का फैसला किया (पंजा के आकार के कारण एक दिशा में नहीं देख सकता)। ऐसा लगता है कि अलग पैर की उंगलियों का स्थान काफी अच्छी तरह से पता चलता है, लेकिन यह पड़ोसी सेंसर भी चिह्नित करता है।

तो पाइथन को बताने का सबसे अच्छा तरीका क्या होगा जो इन अधिकतमताओं में से हैं जिन्हें मैं चाहता हूं?

नोट: 2x2 वर्ग ओवरलैप नहीं हो सकते हैं, क्योंकि उन्हें अलग पैर की अंगुली होनी चाहिए!

इसके अलावा मैंने एक सुविधा के रूप में 2x2 लिया, किसी भी उन्नत समाधान का स्वागत है, लेकिन मैं बस एक मानव आंदोलन वैज्ञानिक हूं, इसलिए मैं न तो असली प्रोग्रामर या गणितज्ञ हूं, इसलिए कृपया इसे 'सरल' रखें।

यहां एक संस्करण है जिसे np.loadtxt लोड किया जा सकता है

परिणाम

तो मैंने @ जेएक्सटीई समाधान की कोशिश की (नीचे दिए गए परिणाम देखें)। जैसा कि आप देख सकते हैं, यह सामने के पंजे पर बहुत काम करता है, लेकिन यह हिंद पैर के लिए कम अच्छी तरह से काम करता है।

अधिक विशेष रूप से, यह चौथे पैर की अंगुली की छोटी चोटी को पहचान नहीं सकता है। यह स्पष्ट रूप से इस तथ्य से निहित है कि लूप सबसे कम मूल्य की तरफ नीचे देखता है, यह ध्यान में रखे बिना कि यह कहां है।

क्या किसी को पता होगा कि @ jextee के एल्गोरिदम को कैसे ट्विक करें, ताकि यह चौथा पैर भी ढूंढ सके?

चूंकि मैंने अभी तक किसी अन्य परीक्षण को संसाधित नहीं किया है, इसलिए मैं किसी अन्य नमूने की आपूर्ति नहीं कर सकता। लेकिन मैंने जो डेटा दिया था वह प्रत्येक पंजा का औसत था। यह फ़ाइल प्लेट के साथ संपर्क करने के क्रम में 9 पंजा के अधिकतम डेटा के साथ एक सरणी है।

यह छवि दिखाती है कि वे प्लेट पर कैसे फैल गए थे।

अद्यतन करें:

मैंने रुचि रखने वाले किसी के लिए एक ब्लॉग स्थापित किया है और मैंने सभी कच्चे माप के साथ स्काईडाइव स्थापित किया है। तो किसी और को अधिक डेटा का अनुरोध करने के लिए: आपको अधिक शक्ति!

नई अपडेट:

तो मदद के बाद मुझे पंजा पहचान और पंजा सॉर्टिंग के बारे में मेरे सवालों के साथ मिला, मैं आखिर में हर पंजा के लिए पैर की अंगुली का पता लगाने में सक्षम था! बाहर निकलता है, यह किसी भी चीज में इतना अच्छा काम नहीं करता है, लेकिन अपने स्वयं के उदाहरण में पंजे का आकार बदलता है। निश्चित रूप से अंत में, यह 2x2 को मनमाने ढंग से चुनने के लिए मेरी अपनी गलती है।

यहां एक अच्छा उदाहरण दिया गया है कि यह कहां गलत हो जाता है: एक नाखून को पैर की अंगुली के रूप में पहचाना जा रहा है और 'एड़ी' इतनी व्यापक है, यह दो बार पहचाना जाता है!

पंजा बहुत बड़ा है, इसलिए बिना किसी ओवरलैप के 2x2 आकार लेना, कुछ पैर की उंगलियों को दो बार पता चला है। दूसरी तरफ, छोटे कुत्तों में यह अक्सर 5 वें पैर की अंगुली खोजने में विफल रहता है, जो मुझे संदेह है कि 2x2 क्षेत्र बहुत बड़ा होने के कारण होता है।

मेरे सभी मापों पर वर्तमान समाधान की कोशिश करने के बाद मैं चौंकाने वाले निष्कर्ष पर आया कि लगभग सभी छोटे कुत्तों के लिए इसे 5 वां पैर नहीं मिला और बड़े कुत्तों के 50% से अधिक प्रभावों में यह और अधिक पाएगा!

तो स्पष्ट रूप से मुझे इसे बदलने की जरूरत है। मेरा खुद का अनुमान neighborhood के आकार को छोटे कुत्तों के लिए छोटे और बड़े कुत्तों के लिए बड़ा बदल रहा था। लेकिन generate_binary_structure मुझे सरणी के आकार को बदलने नहीं देगा।

इसलिए, मैं उम्मीद कर रहा हूं कि किसी और के पास पैर की उंगलियों का पता लगाने के लिए बेहतर सुझाव है, शायद पंजा आकार के साथ पैर की अंगुली क्षेत्र पैमाने है?


मेरे सिर के शीर्ष से बस कुछ विचार:

  • स्कैन के ढाल (व्युत्पन्न) को लें, देखें कि क्या यह झूठी कॉल को समाप्त करता है
  • स्थानीय अधिकतम अधिकतम ले लो

आप ओपनसीवी पर भी एक नज़र डालना चाहते हैं, इसे काफी सभ्य पायथन एपीआई मिला है और इसमें कुछ ऐसे फ़ंक्शन हो सकते हैं जो आपको उपयोगी लगे।


खैर, यहां कुछ सरल और बहुत ही कुशल कोड नहीं है, लेकिन डेटा सेट के इस आकार के लिए यह ठीक है।

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]

I basically just make an array with the position of the upper-left and the sum of each 2x2 square and sort it by the sum. I then take the 2x2 square with the highest sum out of contention, put it in the best array, and remove all other 2x2 squares that used any part of this just removed 2x2 square.

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.ndimage.measurements.label का उपयोग करने के बाद आपको बस इतना करना है। फिर आप व्यक्तिगत रूप से उनके साथ खेल सकेंगे।

ध्यान दें कि विधि अच्छी तरह से काम करती है क्योंकि पृष्ठभूमि शोर नहीं है। यदि यह था, तो आप पृष्ठभूमि में अन्य अवांछित चोटियों का एक समूह का पता लगाएंगे। पड़ोस का आकार एक और महत्वपूर्ण कारक है। यदि शिखर आकार में परिवर्तन होता है (आपको लगभग आनुपातिक रहना चाहिए) तो आपको इसे समायोजित करने की आवश्यकता होगी।


कच्चे डेटा के लिए धन्यवाद। मैं ट्रेन में हूं और जहां तक ​​मुझे मिल गया है (मेरा स्टॉप आ रहा है)। मैंने आपकी txt फ़ाइल को regexps के साथ मालिश किया है और विज़ुअलाइज़ेशन के लिए कुछ जावास्क्रिप्ट के साथ इसे HTML पृष्ठ में फेंक दिया है। मैं इसे यहां साझा कर रहा हूं क्योंकि कुछ, खुद की तरह, इसे पाइथन से अधिक आसानी से हैक करने योग्य लगता है।

मुझे लगता है कि एक अच्छा दृष्टिकोण स्केल और रोटेशन इनवेरिएंट होगा, और मेरा अगला कदम गॉसियन के मिश्रण की जांच करेगा। (प्रत्येक पंजा पैड एक गाऊशियन का केंद्र होता है)।

    <html>
<head>
    <script type="text/javascript" src="http://vis.stanford.edu/protovis/protovis-r3.2.js"></script> 
    <script type="text/javascript">
    var heatmap = [[[0,0,0,0,0,0,0,4,4,0,0,0,0],
[0,0,0,0,0,7,14,22,18,7,0,0,0],
[0,0,0,0,11,40,65,43,18,7,0,0,0],
[0,0,0,0,14,61,72,32,7,4,11,14,4],
[0,7,14,11,7,22,25,11,4,14,65,72,14],
[4,29,79,54,14,7,4,11,18,29,79,83,18],
[0,18,54,32,18,43,36,29,61,76,25,18,4],
[0,4,7,7,25,90,79,36,79,90,22,0,0],
[0,0,0,0,11,47,40,14,29,36,7,0,0],
[0,0,0,0,4,7,7,4,4,4,0,0,0]
],[
[0,0,0,4,4,0,0,0,0,0,0,0,0],
[0,0,11,18,18,7,0,0,0,0,0,0,0],
[0,4,29,47,29,7,0,4,4,0,0,0,0],
[0,0,11,29,29,7,7,22,25,7,0,0,0],
[0,0,0,4,4,4,14,61,83,22,0,0,0],
[4,7,4,4,4,4,14,32,25,7,0,0,0],
[4,11,7,14,25,25,47,79,32,4,0,0,0],
[0,4,4,22,58,40,29,86,36,4,0,0,0],
[0,0,0,7,18,14,7,18,7,0,0,0,0],
[0,0,0,0,4,4,0,0,0,0,0,0,0],
],[
[0,0,0,4,11,11,7,4,0,0,0,0,0],
[0,0,0,4,22,36,32,22,11,4,0,0,0],
[4,11,7,4,11,29,54,50,22,4,0,0,0],
[11,58,43,11,4,11,25,22,11,11,18,7,0],
[11,50,43,18,11,4,4,7,18,61,86,29,4],
[0,11,18,54,58,25,32,50,32,47,54,14,0],
[0,0,14,72,76,40,86,101,32,11,7,4,0],
[0,0,4,22,22,18,47,65,18,0,0,0,0],
[0,0,0,0,4,4,7,11,4,0,0,0,0],
],[
[0,0,0,0,4,4,4,0,0,0,0,0,0],
[0,0,0,4,14,14,18,7,0,0,0,0,0],
[0,0,0,4,14,40,54,22,4,0,0,0,0],
[0,7,11,4,11,32,36,11,0,0,0,0,0],
[4,29,36,11,4,7,7,4,4,0,0,0,0],
[4,25,32,18,7,4,4,4,14,7,0,0,0],
[0,7,36,58,29,14,22,14,18,11,0,0,0],
[0,11,50,68,32,40,61,18,4,4,0,0,0],
[0,4,11,18,18,43,32,7,0,0,0,0,0],
[0,0,0,0,4,7,4,0,0,0,0,0,0],
],[
[0,0,0,0,0,0,4,7,4,0,0,0,0],
[0,0,0,0,4,18,25,32,25,7,0,0,0],
[0,0,0,4,18,65,68,29,11,0,0,0,0],
[0,4,4,4,18,65,54,18,4,7,14,11,0],
[4,22,36,14,4,14,11,7,7,29,79,47,7],
[7,54,76,36,18,14,11,36,40,32,72,36,4],
[4,11,18,18,61,79,36,54,97,40,14,7,0],
[0,0,0,11,58,101,40,47,108,50,7,0,0],
[0,0,0,4,11,25,7,11,22,11,0,0,0],
[0,0,0,0,0,4,0,0,0,0,0,0,0],
],[
[0,0,4,7,4,0,0,0,0,0,0,0,0],
[0,0,11,22,14,4,0,4,0,0,0,0,0],
[0,0,7,18,14,4,4,14,18,4,0,0,0],
[0,4,0,4,4,0,4,32,54,18,0,0,0],
[4,11,7,4,7,7,18,29,22,4,0,0,0],
[7,18,7,22,40,25,50,76,25,4,0,0,0],
[0,4,4,22,61,32,25,54,18,0,0,0,0],
[0,0,0,4,11,7,4,11,4,0,0,0,0],
],[
[0,0,0,0,7,14,11,4,0,0,0,0,0],
[0,0,0,4,18,43,50,32,14,4,0,0,0],
[0,4,11,4,7,29,61,65,43,11,0,0,0],
[4,18,54,25,7,11,32,40,25,7,11,4,0],
[4,36,86,40,11,7,7,7,7,25,58,25,4],
[0,7,18,25,65,40,18,25,22,22,47,18,0],
[0,0,4,32,79,47,43,86,54,11,7,4,0],
[0,0,0,14,32,14,25,61,40,7,0,0,0],
[0,0,0,0,4,4,4,11,7,0,0,0,0],
],[
[0,0,0,0,4,7,11,4,0,0,0,0,0],
[0,4,4,0,4,11,18,11,0,0,0,0,0],
[4,11,11,4,0,4,4,4,0,0,0,0,0],
[4,18,14,7,4,0,0,4,7,7,0,0,0],
[0,7,18,29,14,11,11,7,18,18,4,0,0],
[0,11,43,50,29,43,40,11,4,4,0,0,0],
[0,4,18,25,22,54,40,7,0,0,0,0,0],
[0,0,4,4,4,11,7,0,0,0,0,0,0],
],[
[0,0,0,0,0,7,7,7,7,0,0,0,0],
[0,0,0,0,7,32,32,18,4,0,0,0,0],
[0,0,0,0,11,54,40,14,4,4,22,11,0],
[0,7,14,11,4,14,11,4,4,25,94,50,7],
[4,25,65,43,11,7,4,7,22,25,54,36,7],
[0,7,25,22,29,58,32,25,72,61,14,7,0],
[0,0,4,4,40,115,68,29,83,72,11,0,0],
[0,0,0,0,11,29,18,7,18,14,4,0,0],
[0,0,0,0,0,4,0,0,0,0,0,0,0],
]
];
</script>
</head>
<body>
    <script type="text/javascript+protovis">    
    for (var a=0; a < heatmap.length; a++) {
    var w = heatmap[a][0].length,
    h = heatmap[a].length;
var vis = new pv.Panel()
    .width(w * 6)
    .height(h * 6)
    .strokeStyle("#aaa")
    .lineWidth(4)
    .antialias(true);
vis.add(pv.Image)
    .imageWidth(w)
    .imageHeight(h)
    .image(pv.Scale.linear()
        .domain(0, 99, 100)
        .range("#000", "#fff", '#ff0a0a')
        .by(function(i, j) heatmap[a][j][i]));
vis.render();
}
</script>
  </body>
</html>


Maybe a naive approach is sufficient here: Build a list of all 2x2 squares on your plane, order them by their sum (in descending order).

First, select the highest-valued square into your "paw list". Then, iteratively pick 4 of the next-best squares that don't intersect with any of the previously found squares.


अपने डेटा सेट का विश्लेषण करने के लिए लगातार होमोलॉजी का उपयोग करके मुझे निम्नलिखित परिणाम मिलते हैं (विस्तृत करने के लिए क्लिक करें):

यह इस SO उत्तर में वर्णित चरम पहचान विधि का 2 डी संस्करण है। उपर्युक्त आंकड़ा दृढ़ता से क्रमबद्ध 0-आयामी लगातार होमोलॉजी कक्षाओं को दिखाता है।

मैंने scipy.misc.imresize () का उपयोग कर 2 के कारक द्वारा मूल डेटासेट को अपस्केल किया था। हालांकि, ध्यान दें कि मैंने चार पंजाों को एक डेटासेट के रूप में माना था; इसे चार में विभाजित करना समस्या को आसान बना देगा।

क्रियाविधि। इस काफी सरल के पीछे विचार: फ़ंक्शन के फ़ंक्शन ग्राफ़ पर विचार करें जो प्रत्येक पिक्सेल को अपना स्तर निर्दिष्ट करता है। यह इस तरह दिख रहा है:

अब ऊंचाई 255 पर पानी के स्तर पर विचार करें जो लगातार निम्न स्तर तक गिरता है। स्थानीय मैक्सिमा द्वीपों में पॉप अप (जन्म)। सैडल पॉइंट्स पर दो द्वीप मर्ज करते हैं; हम निचले द्वीप को उच्च द्वीप (मृत्यु) में विलय करने पर विचार करते हैं। तथाकथित दृढ़ता आरेख (0-वें आयामी होमोलॉजी कक्षाओं, हमारे द्वीपों) में सभी द्वीपों के जन्म-मूल्यों पर मृत्यु दर्शाती है:

एक द्वीप की दृढ़ता तब जन्म और मृत्यु-स्तर के बीच का अंतर है; ग्रे मुख्य विकर्ण के लिए एक बिंदु की ऊर्ध्वाधर दूरी। यह आंकड़ा दृढ़ता से कम करके द्वीपों को लेबल करता है।

पहली तस्वीर द्वीपों के जन्म के स्थानों को दिखाती है। यह विधि न केवल स्थानीय अधिकतमता प्रदान करती है बल्कि उपर्युक्त दृढ़ता से उनके "महत्व" को भी प्रमाणित करती है। फिर एक बहुत कम दृढ़ता वाले सभी द्वीपों को फ़िल्टर करेगा। हालांकि, आपके उदाहरण में प्रत्येक द्वीप (यानी, हर स्थानीय अधिकतम) एक चोटी है जिसे आप ढूंढते हैं।


मुझे यकीन है कि अब तक आपके पास जाने के लिए पर्याप्त है, लेकिन मैं मदद नहीं कर सकता लेकिन के-साधन क्लस्टरिंग विधि का उपयोग करने का सुझाव देता हूं। के-साधन एक असुरक्षित क्लस्टरिंग एल्गोरिदम है जो आपको डेटा ले जाएगा (किसी भी संख्या में आयामों में - मैं इसे 3 डी में करता हूं) और इसे अलग-अलग सीमाओं के साथ के क्लस्टर में व्यवस्थित करता हूं। यह यहां अच्छा है क्योंकि आप जानते हैं कि इन कुत्ते (कितने) के कितने पैर हैं।

इसके अतिरिक्त, यह सिसि में लागू किया गया है जो वास्तव में अच्छा है ( http://docs.scipy.org/doc/scipy/reference/cluster.vq.html )।

3 डी क्लस्टर को स्थानिक रूप से हल करने के लिए यह क्या कर सकता है इसका एक उदाहरण यहां दिया गया है:

आप जो करना चाहते हैं वह थोड़ा अलग है (2 डी और दबाव मान शामिल है), लेकिन मुझे अभी भी लगता है कि आप इसे एक शॉट दे सकते हैं।


यहां एक विचार है: आप छवि के (असतत) Laplacian की गणना। मैं उम्मीद करता हूं कि यह अधिकतम (नकारात्मक और) अधिकतम में अधिकतम होगा, जो कि मूल छवियों की तुलना में अधिक नाटकीय है। इस प्रकार, अधिकतमता को ढूंढना आसान हो सकता है।

यहां एक और विचार है: यदि आप उच्च दबाव वाले स्पॉट के सामान्य आकार को जानते हैं, तो आप इसे अपनी छवि को उसी आकार के गॉसियन के साथ घूमकर पहली बार चिकनी बना सकते हैं। यह आपको प्रक्रिया करने के लिए सरल छवियां दे सकता है।


भौतिक विज्ञानी का समाधान:
अपने पद X_i द्वारा पहचाने गए 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) आसपास 2x2 वर्ग में औसत बल है, alfa प्रयोगात्मक रूप से X_i वाला पैरामीटर है)

अब कुछ मेट्रोपोलिस-हेस्टिंग्स जादू करने का समय:
1. यादृच्छिक मार्कर का चयन करें और इसे एक पिक्सेल द्वारा यादृच्छिक दिशा में ले जाएं।
2. डीई की गणना करें, इस कदम के कारण ऊर्जा का अंतर।
3. 0-1 से एक समान यादृच्छिक संख्या प्राप्त करें और इसे आर कहते हैं।
4. यदि dE<0 या exp(-beta*dE)>r , चाल को स्वीकार करें और 1 पर जाएं; यदि नहीं, तो चाल को पूर्ववत करें और 1 पर जाएं।
यह तब तक दोहराया जाना चाहिए जब तक मार्कर पंजे तक नहीं पहुंच जाएंगे। बीटा ट्रेडऑफ को अनुकूलित करने के लिए स्कैनिंग को नियंत्रित करता है, इसलिए इसे प्रयोगात्मक रूप से भी अनुकूलित किया जाना चाहिए; यह सिमुलेशन (अनुरूपित एनीलिंग) के समय भी लगातार बढ़ाया जा सकता है।


एक और दृष्टिकोण है जिसका उपयोग मैंने बड़े दूरबीन के लिए कुछ करने के दौरान किया था:

1) उच्चतम पिक्सेल के लिए खोजें। एक बार आपके पास यह हो जाने के बाद, 2x2 (शायद 2x2 योग को अधिकतम करने के लिए) के लिए सबसे अच्छे फिट के लिए खोजें, या उच्चतम पिक्सेल पर केंद्रित 4x4 के उप क्षेत्र के अंदर 2 डी गाऊशियन फिट करें।

फिर उन 2x2 पिक्सल को सेट करें जिन्हें आपने शीर्ष केंद्र के आसपास शून्य (या शायद 3x3) पाया है

1 पर वापस जाएं) और दोहराएं जब तक कि उच्चतम चोटी शोर सीमा से नीचे न हो, या आपके पास आवश्यक सभी पैर की अंगुली हो


It seems you can cheat a bit using jetxee's algorithm. He is finding the first three toes fine, and you should be able to guess where the fourth is based off that.


भौतिकविदों द्वारा कुछ गहराई में इस समस्या का अध्ययन किया गया है। ROOT में एक अच्छा कार्यान्वयन है। TSpectrum कक्षाओं (विशेष रूप से आपके मामले के लिए TSpectrum2 2) और उनके लिए प्रलेखन देखें।

संदर्भ:

  1. एम। मोरहाक एट अल .: बहुआयामी संयोग गामा-रे स्पेक्ट्रा के लिए पृष्ठभूमि उन्मूलन विधियां। भौतिकी अनुसंधान परमाणु उपकरण और तरीके ए 401 (1 99 7) 113-132।
  2. एम। मोरहाक एट अल .: कुशल एक- और द्वि-आयामी गोल्ड deconvolution और इसके आवेदन गामा-रे स्पेक्ट्रा अपघटन के लिए। भौतिकी अनुसंधान परमाणु उपकरण और तरीके ए 401 (1 99 7) 385-408।
  3. एम। मोरहाक एट अल .: बहुआयामी संयोग गामा-रे स्पेक्ट्रा में चोटियों की पहचान। अनुसंधान भौतिकी में परमाणु उपकरण और तरीके ए 443 (2000), 108-125।

... और उन लोगों के लिए जिनके पास एनआईएम की सदस्यता तक पहुंच नहीं है:


बस आपको बताना चाहते हैं कि पाइथन के साथ छवियों में स्थानीय अधिकतमता खोजने का एक अच्छा विकल्प है।

from skimage.feature import peak_local_max

या skimage 0.8.0 के लिए

from skimage.feature.peak import peak_local_max

http://scikit-image.org/docs/0.8.0/api/skimage.feature.peak.html


एक मोटा रूपरेखा ...

आप शायद प्रत्येक पंजा क्षेत्र को अलग करने के लिए एक कनेक्टेड घटक एल्गोरिदम का उपयोग करना चाहते हैं। विकी का यहां एक सभ्य वर्णन है (कुछ कोड के साथ): http://en.wikipedia.org/wiki/Connected_Component_Labeling

आपको 4 या 8 कनेक्टिविटी का उपयोग करना है या नहीं, इसके बारे में निर्णय लेना होगा। व्यक्तिगत रूप से, ज्यादातर समस्याओं के लिए मैं 6-कनेक्टिविटी पसंद करता हूं। वैसे भी, एक बार जब आप एक जुड़े क्षेत्र के रूप में प्रत्येक "पंजा प्रिंट" को अलग कर लेते हैं, तो यह क्षेत्र के माध्यम से पुन: प्रयास करना और अधिकतमता को ढूंढना काफी आसान होना चाहिए। एक बार जब आप अधिकतम प्राप्त कर लेते हैं, तो आप इस क्षेत्र को तब तक बढ़ा सकते हैं जब तक कि आप इसे "पैर की अंगुली" के रूप में पहचानने के लिए पूर्व निर्धारित सीमा तक नहीं पहुंच जाते।

यहां एक सूक्ष्म समस्या यह है कि जैसे ही आप कंप्यूटर दृष्टि तकनीकों का उपयोग शुरू करने के लिए सही / बाएं / सामने / पीछे के पंजे के रूप में पहचानते हैं और आप व्यक्तिगत पैर की अंगुली को देखना शुरू करते हैं, आपको घूर्णन, स्काई और अनुवादों को ध्यान में रखना शुरू करना होगा। यह तथाकथित "क्षण" के विश्लेषण के माध्यम से पूरा किया जाता है। दृष्टि अनुप्रयोगों में विचार करने के लिए कुछ अलग-अलग क्षण हैं:

केंद्रीय क्षण: अनुवाद invariant सामान्यीकृत क्षण: स्केलिंग और अनुवाद invariant hu क्षण: अनुवाद, पैमाने, और रोटेशन invariant

क्षणों के बारे में अधिक जानकारी विकी पर "छवि क्षण" खोजकर पाई जा सकती है।


What if you proceed step by step: you first locate the global maximum, process if needed the surrounding points given their value, then set the found region to zero, and repeat for the next one.


Interesting problem. The solution I would try is the following.

  1. Apply a low pass filter, such as convolution with a 2D gaussian mask. This will give you a bunch of (probably, but not necessarily floating point) values.

  2. Perform a 2D non-maximal suppression using the known approximate radius of each paw pad (or toe).

This should give you the maximal positions without having multiple candidates which are close together. Just to clarify, the radius of the mask in step 1 should also be similar to the radius used in step 2. This radius could be selectable, or the vet could explicitly measure it beforehand (it will vary with age/breed/etc).

Some of the solutions suggested (mean shift, neural nets, and so on) probably will work to some degree, but are overly complicated and probably not ideal.





image-processing