Miglioramenti per la trasformazione dell'asse circolare

Question

Sto lavorando a un algoritmo di riconoscimento dell'iride che elabora il tipo di immagini these in codici univoci a scopo di identificazione e autenticazione.

Dopo il filtraggio, la soglia intelligente, quindi trovare i bordi nell'immagine, il passo successivo è ovviamente quello di adattare i cerchi alla pupilla e all'iride. Ho guardato in giro la tecnica da usare è la circolare Hough Transform. Ecco il codice per la mia implementazione. Mi dispiace per i nomi delle variabili criptici.

print "Populating Accumulator..." 
# Loop over image rows 
for x in range(w): 
    # Loop over image columns 
    for y in range(h): 
     # Only process black pixels 
     if inp[x,y] == 0: 
      # px,py = 0 means pupil, otherwise pupil center 
      if px == 0: 
       ra = r_min 
       rb = r_max 
      else: 
       rr = sqrt((px-x)*(px-x)+(py-y)*(py-y)) 
       ra = int(rr-3) 
       rb = int(rr+3) 
      # a is the width of the image, b is the height 
      for _a in range(a): 
       for _b in range(b): 
        for _r in range(rb-ra): 
         s1 = x - (_a + a_min) 
         s2 = y - (_b + b_min) 
         r1 = _r + ra 
         if (s1 * s1 + s2 * s2 == r1 * r1): 
          new = acc[_a][_b][_r] 
          if new >= maxVotes: 
           maxVotes = new 
print "Done" 

# Average all circles with the most votes 
for _a in range(a): 
    for _b in range(b): 
     for _r in range(r): 
      if acc[_a][_b][_r] >= maxVotes-1: 
       total_a += _a + a_min 
       total_b += _b + b_min 
       total_r += _r + r_min 
       amount += 1 
top_a = total_a/amount 
top_b = total_b/amount 
top_r = total_r/amount 
print top_a,top_b,top_r 

Questo è scritto in python e utilizza la libreria di immagini Python per eseguire l'elaborazione delle immagini. Come puoi vedere, questo è un metodo di forza bruta molto ingenuo per trovare cerchi. Funziona, ma richiede diversi minuti. L'idea di base è di disegnare cerchi da rmin a rmax ovunque ci sia un pixel nero (dalla soglia e dal rilevamento dei bordi), costruire un array di accumulatori del numero di volte in cui una posizione sull'immagine è "votata". Qualunque sia la x, ye r abbia il maggior numero di voti è il cerchio di interesse. Ho cercato di usare il fatto che l'iride e l'allievo hanno circa lo stesso centro (variabili ra e rb) per ridurre parte della complessità del ciclo r, ma il rilevamento della pupilla richiede così tanto tempo che non ha importanza.

Ora, ovviamente la mia implementazione è molto ingenua. Usa uno spazio parametrico tridimensionale (x, y ed r), che purtroppo lo fa funzionare più lentamente di quanto sia accettabile. Che tipo di miglioramenti posso apportare? C'è un modo per ridurlo a uno spazio parametrico bidimensionale? Esiste un modo più efficiente di accedere e impostare i pixel di cui non sono a conoscenza?

Su una nota a margine, esistono altre tecniche per migliorare il tempo di esecuzione complessivo di questo algoritmo di cui non sono a conoscenza? Quali metodi per approssimare il raggio massimo della pupilla o dell'iride?

Nota: ho provato a utilizzare OpenCV anche per questo, ma non ho potuto regolare i parametri abbastanza per essere sempre accurati.

Fammi sapere se ci sono altre informazioni di cui hai bisogno.

NOTA: Ancora una volta ho interpretato male il mio codice. È tecnicamente 5-dimensionale, ma il ciclo tridimensionale x, y, r funziona solo su pixel neri.

Answer 1

supponendo che si desidera la posizione del cerchio piuttosto che una misura di R.

Se si dispone di una stima decente della gamma possibile di R poi una tecnica comune è quella di eseguire l'algoritmo per una prima ipotesi di fisso R, regolalo e riprova.