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

Question

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

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

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

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

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

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

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

---

परिणाम

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

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

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

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

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

अपडेट करें:

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

---

नई अपडेट:

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

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

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

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

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

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

Comments

मैं यह लेता हूं कि अल्पविराम मूल्य विभाजक के बजाय दशमलव स्थान हैं?

— मैथ सिप

हाँ, वे अल्पविराम हैं। और @ क्रिसियन, मैं इसे एक आसान पठनीय फ़ाइल में रखने की कोशिश कर रहा हूं, लेकिन यहां तक ​​कि मुझ पर विफल रहता है :(

— इवो ​​फ्लिप

जैसा कि मैं एक व्यवहार्यता अध्ययन कर रहा हूँ, कुछ भी वास्तव में चला जाता है। इसलिए मैं दबाव को परिभाषित करने के कई तरीकों की तलाश कर रहा हूं, जिसमें सबग्रेशन भी शामिल है। इसके अलावा, मुझे 'बड़े पैर की अंगुली' और 'छोटे पैर की अंगुली' के बीच भेदभाव करने में सक्षम होना चाहिए, ताकि अभिविन्यास का अनुमान लगाया जा सके। लेकिन चूंकि यह पहले नहीं किया गया है, इसलिए कोई भी नहीं बता रहा है कि हमें :-)

— इवो ​​फ्लिप

@ रॉन: इस अध्ययन का एक लक्ष्य यह देखना है कि कुत्तों का आकार / वजन किस प्रणाली के लिए उपयुक्त है, इसलिए हां जबकि यह कुत्ता लगभग 20 किलो का था। मेरे पास कुछ ऐसे हैं जो काफी छोटे (और बड़े) हैं और उम्मीद करते हैं कि मैं वास्तविक छोटे लोगों के लिए ऐसा नहीं कर पाऊंगा।

— इवो ​​फ्लिप् सिप

@ पंजे समय के साथ मापा जाता है, इसलिए तीसरा आयाम। हालांकि, वे अपने स्थान से नहीं हटते हैं (अपेक्षाकृत बोलने वाले) इसलिए मैं ज्यादातर दिलचस्पी रखता हूं जहां पैर की अंगुली 2 डी में स्थित है। 3D पहलू उसके बाद मुफ्त में आता है

— Ivo Flipse

Answer 1

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

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

Comments

(Eroded_background ^ local_peaks) की तुलना में एक सरल समाधान है। बस करो (अग्रभूमि और स्थानीय चोटियाँ)

— रयान सोकलस्की

Answer 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अधिकतम खोजने के लिए, या 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 मामले।

Comments

उसे मैन्युअल रूप से पंजे को छानना होगा, आपकी रिजल्ट लिस्ट दी जाएगी ... चार सर्वोच्च परिणाम चुनने पर उसे 2x2 वर्ग के निर्माण की चार संभावनाएँ मिलेंगी जिसमें अधिकतम मूल्य 6.8 होगा

— जोहान्स

2x2 बक्से को ओवरलैप नहीं किया जा सकता है, क्योंकि अगर मैं आंकड़े करना चाहता हूं, तो मैं उसी क्षेत्र का उपयोग नहीं करना चाहता हूं, मैं क्षेत्रों की तुलना करना चाहता हूं :-)

— Ivo Flipse

मैंने उत्तर संपादित किया। अब परिणामों में कोई अतिव्यापी वर्ग नहीं हैं।

— 15

मैं इसे बाहर की कोशिश की और यह सामने के पंजे के लिए काम करने लगता है, लेकिन हिंद लोगों के लिए इतना कम। लगता है कि हमें कुछ ऐसा प्रयास करना होगा जो जानता है कि कहां देखना है

— Ivo Flipse

मैंने अपना विचार समझाया कि कैसे छद्म कोड में उंगलियों का पता लगाया जा सकता है। यदि आप इसे पसंद करते हैं, तो मैं कल शाम इसे लागू करने का प्रयास कर सकता हूं।

— सस्तानिन

Answer 3

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

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

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

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

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

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

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

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

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

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

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

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

Comments

समस्या यह है, कि पंजे अपने अभिविन्यास को बदलते हैं और मेरे पास शुरू करने के लिए एक सही पंजे का कोई अंशांकन / आधार रेखा नहीं है। इसके अलावा मुझे डर है कि बहुत सारे छवि मान्यता एल्गोरिदम मेरे लीग से थोड़ा बाहर हैं।

— Ivo फ्लिप

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

— केकमास्टर

मुझे लगता है कि आपका सुझाव हिंद पंजे की मान्यता को ठीक करने में मदद करेगा, मुझे अभी पता नहीं 'कैसे'

— इवो ​​फ्लिप

मैंने एक और विचार जोड़ा है। वैसे अगर आपके पास अच्छे डेटा का भार है तो इसे कहीं ऑनलाइन रखना अच्छा होगा। यह इमेज प्रोसेसिंग / मशीन लर्निंग का अध्ययन करने वाले लोगों के लिए उपयोगी हो सकता है और आपको इससे कुछ और कोड मिल सकता है ...

— CakeMaster

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

— इवो Flipse

Answer 4

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

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

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

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

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

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

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

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

Answer 5

भौतिकविदों द्वारा इस समस्या का कुछ गहराई से अध्ययन किया गया है। 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

Comments

लेख पर नज़र रखने के लिए ऐसा लगता है कि मैं यहाँ जो कोशिश कर रहा हूँ, वही डेटा प्रोसेसिंग का वर्णन करता हूँ, हालाँकि मुझे डर है कि यह मेरे प्रोग्रामिंग कौशल को पार कर गया :(

— Ivo Flipse

@ इवो: मैंने कभी इसे खुद लागू करने की कोशिश नहीं की। मैं सिर्फ रूट का उपयोग करता हूं। अजगर बाँध रहे हैं, कोई भी कम नहीं है, लेकिन ध्यान रखें कि जड़ बहुत भारी पैकेज है।

— dmckee --- पूर्व-मध्यस्थ ने बिल्ली का बच्चा

@ इवो फ्लिप: मैं dmckee से सहमत हूं। आपके पास अन्य उत्तरों में बहुत सारे होनहार लीड हैं। यदि वे सभी विफल हो जाते हैं और आपको कुछ समय निवेश करने का मन करता है, तो आप ROOT में तल्लीन हो सकते हैं और यह (संभवतः) वही करेगा जो आपको इसकी आवश्यकता है। मैंने कभी किसी को नहीं जाना, जिन्होंने अजगर को बाइंडिंग (प्राकृतिक सी ++ के बजाय) के माध्यम से सीखने की कोशिश की है, इसलिए मैं आपको शुभकामनाएं देता हूं।

— भौतिक विज्ञान

Answer 6

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

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

Answer 7

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

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

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

Comments

ढाल के साथ, आपका मतलब है कि मुझे ढलान की स्थिरता की गणना करनी चाहिए, एक बार यह एक निश्चित मूल्य से ऊपर हो जाता है मुझे पता है कि 'चोटी' है? मैंने यह कोशिश की, लेकिन कुछ पैर की उंगलियों में केवल कुछ अन्य (8 एन / सेमी) की तुलना में बहुत कम चोटियां (1.2 एन / सेमी) हैं। तो मुझे बहुत कम ग्रेडिएंट वाली चोटियों को कैसे संभालना चाहिए?

— इवो ​​फ्लिप

अतीत में मेरे लिए क्या काम हुआ अगर मैं ग्रेडिएंट का उपयोग सीधे नहीं कर सकता था तो ग्रेडिएंट और मैक्सिमा को देखना था, जैसे अगर ग्रेडिएंट एक स्थानीय एक्स्ट्रेमा है और मैं स्थानीय मैक्सिमा पर हूं, तो मैं एक बिंदु पर हूं ब्याज।

— क्रिस

Answer 8

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

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

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

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

Answer 9

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

Comments

मुझे लगता है कि यह अवधारणा का प्रमाण है कि अनुशंसित गौसियन तकनीक काम कर सकती है, अब अगर केवल कोई इसे पायथन ;-) में साबित कर सकता है

— इवो ​​फ्लिप

Answer 10

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

Comments

यह दिखाने के लिए कि यह मेरे उदाहरण पर कैसे काम करेगा? जैसा कि मैं वास्तव में उच्च स्तर के गणित में नहीं हूं, इसलिए मेरे पास पहले से ही आपके द्वारा प्रस्तावित फार्मूले को

— जानने का

यह हाई स्कूल का गणित है, शायद मेरी धारणा सिर्फ मोटे तौर पर है। मेरे पास इसकी जाँच करने की योजना है, इसलिए बने रहें।

— mbq 20

मैं एक कण भौतिकवादी हूं। लंबे समय तक हमारे अनुशासन में जाने वाले सॉफ्टवेयर टूल को PAW कहा जाता था, और इसमें ग्राफ़ से संबंधित एक इकाई थी जिसे "मार्कर" कहा जाता था। आप कल्पना कर सकते हैं कि इस उलझन को मैंने पहले दो बार के आसपास कैसे पाया ...

— dmckee --- पूर्व-मध्यस्थ ने बिल्ली का बच्चा

Answer 11

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

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

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

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

Comments

एक कोड उदाहरण साझा करने की परवाह है जो ऐसा करता है? मैं अनुसरण कर सकता हूं कि आप क्या करने की कोशिश कर रहे हैं, लेकिन यह पता नहीं है कि इसे खुद को कैसे

— कोडित किया जाए

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

— इवो ​​फ्लिप

Answer 12

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

Comments

यदि यह परेशानी के लायक है, तो मैं हाथ से एक बड़े नमूने की व्याख्या करने में बुरा नहीं मानूंगा। मेरी समस्या यह होगी: मैं इसे कैसे लागू करूंगा, क्योंकि मुझे तंत्रिका नेटवर्क के प्रोग्रामिंग के बारे में कुछ नहीं पता है

— Ivo Flipse

Answer 13

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

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

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

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

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

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

Answer 14

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

Answer 15

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

Answer 16

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

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

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

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

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

Comments

मेरे पास कन्वेक्शन मैट्रिसेस और गाऊसी फिल्टर के साथ 0 अनुभव है, तो क्या आप यह दिखाना चाहेंगे कि यह मेरे उदाहरण पर कैसे काम करेगा?

— इवो ​​फ्लिप 22

Answer 17

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

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 वर्ग से एक वर्ग का चयन करता है, लेकिन दूसरा बाईं ओर है। सौभाग्य से, भाग्य से हम उस एक को चुनना चाहते हैं जो आप चाहते हैं, लेकिन इसके लिए कुछ अन्य विचारों का उपयोग करने की आवश्यकता हो सकती है जो वास्तव में आप सभी चाहते हैं।

Comments

मुझे लगता है कि आपके परिणाम @ Jextee के उत्तर के समान हैं। या कम से कम तो यह मुझे लगता है कि यह परीक्षण से है।

— इवो ​​फ्लिप

Answer 18

बस आप लोगों को बताना चाहता हूं कि 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

Answer 19

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

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

Comments

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

— 13

हाँ, किसी प्रकार का शब्दकोश आवश्यक होगा। मुझे लगता है कि ग्रिड का आपका प्रतिनिधित्व पहले से ही किसी प्रकार का है।

— जोहान्स चार

अच्छी तरह से जो छवि आप ऊपर देख रहे हैं वह एक सुव्यवस्थित सरणी है। शेष वर्तमान में बहुआयामी सूची में संग्रहीत है। शायद ऐसा करना बंद करना बेहतर होगा, हालाँकि मैं शब्दकोशों पर ध्यान देने से परिचित नहीं हूँ

— Ivo Flipse

Answer 20

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

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

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 स्रोत-निष्कर्षण चुनौतियों के लिए भी खोज कर सकते हैं।

...

Answer 21

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

Comments

हम्म कि शून्य पर सेट करना कम से कम इसे किसी भी आगे की गणना से हटा देगा, जो उपयोगी होगा।

— 13

शून्य पर सेट करने के बजाय, आप हाथ से चुने गए मापदंडों के साथ एक गॉसियन फ़ंक्शन की गणना कर सकते हैं और मूल दबाव रीडिंग से पाए गए मानों को घटा सकते हैं। इसलिए यदि पैर की अंगुली आपके सेंसर को दबा रही है, तो उच्चतम दबाव बिंदु को खोजने के द्वारा, आप इसका उपयोग सेंसर पर उस पैर के अंगूठे के प्रभाव को कम करने के लिए करते हैं, इस प्रकार, उच्च दबाव मूल्यों के साथ पड़ोसी कोशिकाओं को समाप्त करते हैं। en.wikipedia.org/wiki/File:Gaussian_2d.png

— दानियार

मेरे नमूना डेटा @ दानियार पर आधारित एक उदाहरण दिखाने के लिए परवाह है? जैसा कि मैं वास्तव में इस तरह के डेटा प्रोसेसिंग से परिचित नहीं हूं

— Ivo Flipse

Answer 22

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

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

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

Comments

मैं कोशिश कर रहा हूँ और एक नज़र है और देख रहा हूँ कि क्या मैं इसे पायथन कोड में बदल सकता हूँ :-)

— Ivo Flipse

यदि यह एक उचित लंबाई है, तो कृपया कोड को पोस्ट में ही शामिल करें, बजाए एक लिंक के।

— agf