स्थानीय मॅक्सिमा/चोटियों और हिस्टोग्राम

Question

ठीक है की न्यूनतम/घाटियों ढूँढना, तो मैं एक हिस्टोग्राम (ints की एक सरणी द्वारा प्रतिनिधित्व) है, और मैं स्थानीय मॅक्सिमा और न्यूनतम खोजने के लिए सबसे अच्छा तरीका है के लिए देख रहा हूँ। प्रत्येक हिस्टोग्राम में 3 चोटियां होनी चाहिए, उनमें से एक (पहला वाला) शायद दूसरों की तुलना में बहुत अधिक हो।

1. पहले "घाटी" पहली शिखर निम्नलिखित (क्रम में चित्र में पूरी तरह पहली शिखर से छुटकारा पाने के)

2. खोजें खोजें:

   मैं कई बातें करना चाहता हूँ में शेष दो चोटियों के बीच चित्र

   अलग करने के लिए इष्टतम "घाटी" मूल्य मैं पहले से ही कैसे Otsu का एक संस्करण को लागू करने से चरण 2 करने के लिए पता है। लेकिन मैं चरण 1

3. के साथ संघर्ष कर रहा हूं यदि दो शेष चोटियों के बीच घाटी पर्याप्त नहीं है, तो मैं एक चेतावनी देना चाहता हूं।

इसके अलावा, छवि काफी के लिए

क्या कदम 1 और 3 करने के लिए जानवर बल एल्गोरिदम होगा खाते में कम शोर के साथ स्वच्छ है? मुझे ओत्सु को लागू करने का एक तरीका मिल सकता था, लेकिन क्रूर बल मुझे बच रहा है, गणित के अनुसार। यह पता चला है, वहाँ Otsu तरह के तरीकों के बारे में अधिक कर प्रलेखन है, और बस चोटियों और घाटियों खोजने पर कम। मैं जो कुछ भी काम करता है उससे ज्यादा कुछ नहीं ढूंढ रहा हूं (यानी यह एक अस्थायी समाधान है, बस उचित समय सीमा में लागू किया जाना चाहिए, जब तक कि मैं इसमें अधिक समय नहीं लगा सकता)

मैं यह सब सी #

जिस पर किसी भी मदद लेने की सराहना की जाएगी कदम! आपको बहुत बहुत धन्यवाद!

संपादित करें: कुछ और डेटा:

सबसे हिस्टोग्राम, पहले एक तरह होने की संभावना है पहले शिखर पृष्ठभूमि को दर्शाता है।

Answer 1

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

स्रोत: UCF CV CAP5415 lecture 9 slides

नीचे है मेरी कोड:

public static List<int> PeakinessTest(int[] histogram, double peakinessThres) 
{ 
    int j=0; 
    List<int> valleys = new List<int>(); 

    //The start of the valley 
    int vA = histogram[j]; 
    int P = vA; 

    //The end of the valley 
    int vB = 0; 

    //The width of the valley, default width is 1 
    int W = 1; 

    //The sum of the pixels between vA and vB 
    int N = 0; 

    //The measure of the peaks peakiness 
    double peakiness=0.0; 

    int peak=0; 
    bool l = false; 

    try 
    { 
     while (j < 254) 
     { 

      l = false; 
      vA = histogram[j]; 
      P = vA; 
      W = 1; 
      N = vA; 

      int i = j + 1; 

      //To find the peak 
      while (P < histogram[i]) 
      { 
       P = histogram[i]; 
       W++; 
       N += histogram[i]; 
       i++; 
      } 


      //To find the border of the valley other side 
      peak = i - 1; 
      vB = histogram[i]; 
      N += histogram[i]; 
      i++; 
      W++; 

      l = true; 
      while (vB >= histogram[i]) 
      { 
       vB = histogram[i]; 
       W++; 
       N += histogram[i]; 
       i++; 
      } 

       //Calculate peakiness 
      peakiness = (1 - (double)((vA + vB)/(2.0 * P))) * (1 - ((double)N/(double)(W * P))); 

      if (peakiness > peakinessThres & !valleys.Contains(j)) 
      { 
       //peaks.Add(peak);       
       valleys.Add(j); 
       valleys.Add(i - 1); 
      } 

      j = i - 1; 
     } 
    } 
    catch (Exception) 
    { 
     if (l) 
     { 
      vB = histogram[255]; 

      peakiness = (1 - (double)((vA + vB)/(2.0 * P))) * (1 - ((double)N/(double)(W * P))); 

      if (peakiness > peakinessThres) 
       valleys.Add(255); 

       //peaks.Add(255); 
      return valleys; 
     } 
    } 

     //if(!valleys.Contains(255)) 
     // valleys.Add(255); 

    return valleys; 
}