एक 2 डी सरणी में चोटी का पता लगाना

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

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

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

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

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

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

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

परिणाम

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

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

क्या किसी को पता होगा कि @ jextee का एल्गोरिथ्म कैसे बनाना है, ताकि यह 4 वें पैर के अंगूठे को भी ढूंढ सके?

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

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

अपडेट करें:

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

नई अपडेट:

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

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

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

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

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

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

मैंने स्थानीय अधिकतम फ़िल्टर का उपयोग करके चोटियों का पता लगाया । यहाँ 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अलग-अलग वस्तुओं को लेबल करने के लिए मास्क पर उपयोग करने के बाद आपको बस इतना करना होगा । तब आप उनके साथ व्यक्तिगत रूप से खेल सकेंगे।

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

समाधान

डेटा फ़ाइल: 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अधिकतम खोजने के लिए, या sort, या sortedचोटियों खोजने के लिए।

चोटियों के पदों को याद रखने के लिए मैं प्रत्येक मूल्य (योग) को एक चपटा सरणी (देखें 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 मामले।

यह एक छवि पंजीकरण समस्या है । सामान्य रणनीति है:

• एक ज्ञात उदाहरण है, या डेटा पर कुछ प्रकार से पहले ।
• अपने डेटा को उदाहरण के लिए फ़िट करें, या अपने डेटा के लिए उदाहरण फिट करें।
• यदि आपका डेटा मोटे तौर पर पहली जगह में संरेखित है, तो यह मदद करता है।

यहाँ एक कठिन और तैयार दृष्टिकोण है , "सबसे विनम्र चीज जो संभवतः काम कर सकती है":

• पांच पैर की अंगुली निर्देशांक के साथ शुरू करें, मोटे तौर पर आप जिस जगह की उम्मीद करते हैं।
• प्रत्येक के साथ, चलने के लिए पहाड़ी की चोटी पर चढ़ते हैं। यदि वर्तमान स्थिति दी गई है, तो अधिकतम पड़ोसी पिक्सेल पर जाएं, यदि इसका मूल्य वर्तमान पिक्सेल से अधिक है। तब रुकें जब आपके पैर के अंगुलियों का हिलना बंद हो गया हो।

ओरिएंटेशन समस्या का मुकाबला करने के लिए, आपके पास मूल दिशाओं (उत्तर, उत्तर पूर्व, आदि) के लिए 8 या इतनी प्रारंभिक सेटिंग्स हो सकती हैं। हर एक को व्यक्तिगत रूप से चलाएं और किसी भी परिणाम को फेंक दें जहां दो या अधिक पैर की उंगलियां एक ही पिक्सेल पर समाप्त होती हैं। मैं इसके बारे में कुछ और सोचूंगा, लेकिन इस तरह की चीज़ पर अभी भी इमेज प्रोसेसिंग में शोध किया जा रहा है - कोई सही उत्तर नहीं हैं!

थोड़ा और अधिक जटिल विचार: (भारित) K- साधन क्लस्टरिंग। इतना खराब नहीं है।

• पांच पैर की अंगुली निर्देशांक के साथ शुरू करें, लेकिन अब ये "क्लस्टर केंद्र" हैं।

फिर अभिसरण तक पुनरावृति:

• प्रत्येक पिक्सेल को निकटतम क्लस्टर में असाइन करें (बस प्रत्येक क्लस्टर के लिए एक सूची बनाएं)।
• प्रत्येक क्लस्टर के द्रव्यमान के केंद्र की गणना करें। प्रत्येक क्लस्टर के लिए, यह है: सम (समन्वय * तीव्रता मूल्य) / सम (समन्वय)
• प्रत्येक क्लस्टर को द्रव्यमान के नए केंद्र में ले जाएं।

यह विधि निश्चित रूप से लगभग बेहतर परिणाम देगी, और आपको प्रत्येक क्लस्टर का द्रव्यमान मिलेगा जो पैर की उंगलियों की पहचान करने में मदद कर सकता है।

(फिर, आपने सामने क्लस्टर्स की संख्या निर्दिष्ट की है। क्लस्टरिंग के साथ आपको घनत्व को एक या दूसरे तरीके से निर्दिष्ट करना होगा: या तो क्लस्टर्स की संख्या चुनें, इस मामले में उपयुक्त हैं, या एक क्लस्टर त्रिज्या चुनें और देखें कि आप कितने समाप्त होते हैं। साथ। उत्तरार्द्ध का एक उदाहरण मतलब-पारी है ।)

कार्यान्वयन विवरण या अन्य बारीकियों की कमी के बारे में क्षमा करें। मैं इसे कोड कर दूंगा लेकिन मुझे एक समय सीमा मिल गई है। अगर अगले हफ्ते तक कुछ और काम नहीं किया है तो मुझे बताएं और मैं इसे शॉट दूंगा।

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

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

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

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

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

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

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

अजगर कोड यहाँ पाया जा सकता है ।

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

संदर्भ:

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

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

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

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

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

मेरे सिर के ऊपर से विचारों की एक जोड़ी:

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

तुम भी OpenCV पर एक नज़र रखना चाहते हो सकता है , यह एक काफी सभ्य पायथन एपीआई मिल गया है और आप उपयोगी हो सकता है कुछ कार्य हो सकता है।

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

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

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

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

कच्चे डेटा के लिए धन्यवाद। मैं ट्रेन पर हूँ और यह जहाँ तक मुझे मिल गया है (मेरा स्टॉप ऊपर आ रहा है)। मैंने आपके 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>

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

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

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

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

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

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

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

एक कठिन रूपरेखा ...

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

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

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

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

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

शायद आप गौसियन मिक्सचर मॉडल जैसी किसी चीज़ का उपयोग कर सकते हैं। यहां GMM करने के लिए एक पायथन पैकेज (बस एक Google खोज किया गया) http://www.ar.media.kyoto-u.ac.jp/members/david/softwares/em/

ऐसा लगता है कि आप जेटक्सी के एल्गोरिथ्म का उपयोग करके थोड़ा धोखा दे सकते हैं। वह पहले तीन पैर की उंगलियों को ठीक कर रहा है, और आपको यह अनुमान लगाने में सक्षम होना चाहिए कि चौथा कहाँ पर आधारित है।

दिलचस्प समस्या है। समाधान मैं कोशिश करूँगा निम्नलिखित है।

1. एक कम पास फ़िल्टर लागू करें, जैसे कि 2 डी गाऊसी मुखौटा के साथ दृढ़ संकल्प। यह आपको (शायद, लेकिन जरूरी नहीं कि चल बिंदु) मूल्यों का एक गुच्छा देगा।

2. प्रत्येक पंजा पैड (या पैर की अंगुली) के ज्ञात अनुमानित त्रिज्या का उपयोग करके 2 डी गैर-अधिकतम दमन करें।

यह आपको कई उम्मीदवारों के बिना अधिकतम पद दे सकता है जो एक साथ पास हैं। बस स्पष्ट करने के लिए, चरण 1 में मुखौटा की त्रिज्या भी चरण 2 में उपयोग किए जाने वाले त्रिज्या के समान होनी चाहिए। यह त्रिज्या चयन करने योग्य हो सकती है, या पशु चिकित्सक स्पष्ट रूप से इसे पहले से माप सकता है (यह उम्र / नस्ल / आदि के साथ अलग-अलग होगा)।

सुझाए गए कुछ समाधान (मतलब पारी, तंत्रिका जाल, और इसी तरह) शायद कुछ हद तक काम करेंगे, लेकिन अत्यधिक जटिल हैं और शायद आदर्श नहीं हैं।

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

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 वर्ग को सबसे अधिक योग के साथ विवाद से बाहर निकालता हूंbest सरणी , और अन्य सभी 2x2 वर्गों को हटा देता , जो इसके हटाए गए 2x2 वर्ग के किसी भी हिस्से का उपयोग करते हैं।

यह अंतिम पंजे (आपकी पहली तस्वीर में सबसे दूर की छोटी राशि वाला) को छोड़कर ठीक काम करता है, यह पता चलता है कि दो अन्य पात्र 2x2 वर्ग हैं जिनमें एक बड़ा योग है (और उनके पास एक समान राशि है) एक दूसरे)। उनमें से एक अभी भी आपके 2x2 वर्ग से एक वर्ग का चयन करता है, लेकिन दूसरा बाईं ओर है। सौभाग्य से, भाग्य से हम उस एक को चुनना चाहते हैं जो आप चाहते हैं, लेकिन इसके लिए कुछ अन्य विचारों का उपयोग करने की आवश्यकता हो सकती है जो वास्तव में आप सभी चाहते हैं।

बस आप लोगों को बताना चाहता हूं कि maximaअजगर के साथ छवियों में स्थानीय खोजने के लिए एक अच्छा विकल्प है :

from skimage.feature import peak_local_max

या स्किमेज के लिए 0.8.0:

from skimage.feature.peak import peak_local_max

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

शायद एक भोली दृष्टिकोण यहां पर्याप्त है: अपने विमान पर सभी 2x2 वर्गों की एक सूची बनाएं, उन्हें उनकी राशि (अवरोही क्रम में) द्वारा ऑर्डर करें।

सबसे पहले, अपने "पंजा सूची" में उच्चतम-मूल्यवान वर्ग का चयन करें। फिर, पुनरावृत्तियाँ अगले-सर्वोत्तम वर्गों में से 4 चुनती हैं, जो पहले पाए गए वर्गों में से किसी के साथ प्रतिच्छेद नहीं करते हैं।

खगोल विज्ञान और ब्रह्मांड विज्ञान समुदाय से उपलब्ध सॉफ्टवेयर के कई और व्यापक टुकड़े हैं - यह ऐतिहासिक और वर्तमान में दोनों अनुसंधान का एक महत्वपूर्ण क्षेत्र है।

यदि आप एक खगोलविद नहीं हैं, तो चिंतित न हों - कुछ का उपयोग क्षेत्र के बाहर करना आसान है। उदाहरण के लिए, आप खगोल / फोटुटिल का उपयोग कर सकते हैं:

https://photutils.readthedocs.io/en/stable/detection.html#local-peak-detection

[यह उनके संक्षिप्त नमूना कोड को दोहराने के लिए थोड़ा असभ्य लगता है।]

तकनीक / पैकेज / लिंक की एक अधूरी और थोड़ी सी पक्षपाती सूची जो ब्याज की हो सकती है, नीचे दी गई है - टिप्पणियों में और जोड़ें और मैं इस उत्तर को आवश्यकतानुसार अपडेट करूंगा। बेशक, गणना संसाधनों की सटीकता बनाम व्यापार-बंद है। [ईमानदारी से, एक ही उत्तर में कोड उदाहरण देने के लिए बहुत सारे हैं जैसे कि मैं यह सुनिश्चित नहीं कर रहा हूं कि यह उत्तर उड़ जाएगा या नहीं।]

स्रोत चिमटा https://www.astromatic.net/software/sextractor

मल्टीनेस्ट https://github.com/farhanferoz/MultiNest [+ pyMultiNest]

ASKAP / EMU स्रोत-खोज चुनौती: https://arxiv.org/abs/1509.03931

आप प्लैंक और / या WMAP स्रोत-निष्कर्षण चुनौतियों के लिए भी खोज कर सकते हैं।

...

क्या होगा अगर आप कदम से कदम आगे बढ़ते हैं: आप पहले वैश्विक अधिकतम का पता लगाते हैं, प्रक्रिया करते हैं यदि आवश्यक हो तो आसपास के बिंदुओं को उनके मूल्य दिए जाएं, फिर पाया गया क्षेत्र शून्य पर सेट करें, और अगले एक के लिए दोहराएं।

मुझे यकीन नहीं है कि यह सवाल का जवाब देता है, लेकिन ऐसा लगता है कि आप सिर्फ उन उच्चतम चोटियों की तलाश कर सकते हैं जिनमें पड़ोसी नहीं हैं।

यहाँ है जिस्ट। ध्यान दें कि यह रूबी में है, लेकिन विचार स्पष्ट होना चाहिए।

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