Ricerca dei massimi/picchi e dei minimi/valli degli istogrammi locali

Question

Ok, quindi ho un istogramma (rappresentato da una serie di ints), e sto cercando il modo migliore per trovare massimi e minimi locali. Ogni istogramma dovrebbe avere 3 picchi, uno di questi (il primo) probabilmente molto più alto degli altri.

voglio fare diverse cose:

1. trovare il primo "valle" dopo il primo picco (al fine di sbarazzarsi del primo picco del tutto nella foto)

2. Trova il valore ottimale "valle" tra i due picchi rimanenti per separare l'immagine

   So già come eseguire il passaggio 2 implementando una variante di Otsu. Ma ho difficoltà con il passaggio 1

3. Nel caso in cui la valle tra i due picchi rimanenti non sia sufficientemente bassa, vorrei dare un avvertimento.

Inoltre, l'immagine è abbastanza pulito con poco rumore per tenere conto di

Quali sarebbero gli algoritmi brute-force per fare punti 1 e 3? Potrei trovare un modo per implementare Otsu, ma la forza bruta mi sta sfuggendo, in termini di matematica. A quanto pare, c'è più documentazione sul fare metodi come otsu, e meno sulla semplice ricerca di picchi e valli. Non sto cercando nulla di più di quello che fa il lavoro (cioè è una soluzione temporanea, deve essere implementabile in un lasso di tempo ragionevole, finché non posso passare più tempo)

Sto facendo tutto questo in C#

Qualsiasi aiuto su quali passi prendere sarebbe apprezzato! Grazie mille!

EDIT: alcuni dati di più:

più istogramma sono suscettibili di essere come il primo, con il primo picco corrispondente sfondo.

Answer 1

Usa peakiness-test. È un metodo per trovare tutti i picchi possibili tra due minimi locali e misurare il picco in base a una formula. Se il picco è superiore a una soglia, il picco viene accettato.

Fonte: UCF CV CAP5415 lecture 9 slides

Qui di seguito è il mio codice:

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; 
}