Il rilevamento del volto di Viola-Jones rivendica 180.000 funzionalità

Sto implementando un adattamento dell'algoritmo di rilevamento dei volti di Viola-Jones . La tecnica si basa sul posizionamento di un subframe di 24x24 pixel all'interno di un'immagine e successivamente sul posizionamento di elementi rettangolari al suo interno in ogni posizione con ogni dimensione possibile.

Queste caratteristiche possono essere costituite da due, tre o quattro rettangoli. Viene presentato il seguente esempio.

Affermano che il set completo è più di 180k (sezione 2):

Dato che la risoluzione di base del rilevatore è 24x24, l'insieme esauriente di funzioni rettangolari è piuttosto ampio, oltre 180.000. Si noti che a differenza della base Haar, l'insieme di elementi rettangolari è troppo completo.

Le seguenti affermazioni non sono esplicitamente dichiarate nel documento, quindi sono ipotesi da parte mia:

1. Ci sono solo 2 elementi a due rettangoli, 2 elementi a tre rettangoli e 1 elementi a quattro rettangoli. La logica alla base di questo è che stiamo osservando la differenza tra i rettangoli evidenziati, non esplicitamente il colore o la luminanza o qualcosa del genere.
2. Non possiamo definire il tipo di elemento A come un blocco di pixel 1x1; deve essere almeno 1x2 pixel. Inoltre, il tipo D deve essere almeno 2x2 pixel e questa regola vale di conseguenza per le altre funzionalità.
3. Non possiamo definire il tipo di elemento A come un blocco di 1x3 pixel poiché il pixel centrale non può essere partizionato e sottraendolo da se stesso è identico a un blocco di 1x2 pixel; questo tipo di caratteristica è definito solo per larghezze pari. Inoltre, la larghezza dell'elemento di tipo C deve essere divisibile per 3 e questa regola vale di conseguenza per gli altri elementi.
4. Non possiamo definire una caratteristica di larghezza e / o altezza di 0. Pertanto, iterare x di e y a 24 meno la dimensione della funzione.

Sulla base di questi presupposti, ho contato il set completo:

const int frameSize = 24;
const int features = 5;
// All five feature types:
const int feature[features][2] = {{2,1}, {1,2}, {3,1}, {1,3}, {2,2}};

int count = 0;
// Each feature:
for (int i = 0; i < features; i++) {
    int sizeX = feature[i][0];
    int sizeY = feature[i][1];
    // Each position:
    for (int x = 0; x <= frameSize-sizeX; x++) {
        for (int y = 0; y <= frameSize-sizeY; y++) {
            // Each size fitting within the frameSize:
            for (int width = sizeX; width <= frameSize-x; width+=sizeX) {
                for (int height = sizeY; height <= frameSize-y; height+=sizeY) {
                    count++;
                }
            }
        }
    }
}

Il risultato è 162.336 .

L'unico modo che ho trovato per approssimare gli "oltre 180.000" di cui parlano Viola & Jones è stato quello di eliminare l'ipotesi n. 4 e di introdurre bug nel codice. Ciò comporta la modifica di quattro righe rispettivamente in:

for (int width = 0; width < frameSize-x; width+=sizeX)
for (int height = 0; height < frameSize-y; height+=sizeY)

Il risultato è quindi 180.625 . (Notare che questo impedirà efficacemente alle caratteristiche di toccare mai la destra e / o la parte inferiore del telaio ausiliario.)

Ora ovviamente la domanda: hanno commesso un errore nella loro implementazione? Ha senso considerare elementi con una superficie pari a zero? O la vedo nel modo sbagliato?

Ad uno sguardo più attento, il tuo codice mi sembra corretto; il che fa pensare se gli autori originali avessero un bug off-by-one. Immagino che qualcuno dovrebbe guardare a come OpenCV lo implementa!

Tuttavia, un suggerimento per renderlo più facile da capire è di capovolgere l'ordine dei cicli for andando prima su tutte le dimensioni, quindi ripetendo le possibili posizioni date le dimensioni:

#include <stdio.h>
int main()
{
    int i, x, y, sizeX, sizeY, width, height, count, c;

    /* All five shape types */
    const int features = 5;
    const int feature[][2] = {{2,1}, {1,2}, {3,1}, {1,3}, {2,2}};
    const int frameSize = 24;

    count = 0;
    /* Each shape */
    for (i = 0; i < features; i++) {
        sizeX = feature[i][0];
        sizeY = feature[i][1];
        printf("%dx%d shapes:\n", sizeX, sizeY);

        /* each size (multiples of basic shapes) */
        for (width = sizeX; width <= frameSize; width+=sizeX) {
            for (height = sizeY; height <= frameSize; height+=sizeY) {
                printf("\tsize: %dx%d => ", width, height);
                c=count;

                /* each possible position given size */
                for (x = 0; x <= frameSize-width; x++) {
                    for (y = 0; y <= frameSize-height; y++) {
                        count++;
                    }
                }
                printf("count: %d\n", count-c);
            }
        }
    }
    printf("%d\n", count);

    return 0;
}

con gli stessi risultati del precedente 162336

Per verificarlo, ho testato il caso di una finestra 4x4 e controllato manualmente tutti i casi (facile da contare poiché le forme 1x2 / 2x1 e 1x3 / 3x1 sono le stesse ruotate di soli 90 gradi):

2x1 shapes:
        size: 2x1 => count: 12
        size: 2x2 => count: 9
        size: 2x3 => count: 6
        size: 2x4 => count: 3
        size: 4x1 => count: 4
        size: 4x2 => count: 3
        size: 4x3 => count: 2
        size: 4x4 => count: 1
1x2 shapes:
        size: 1x2 => count: 12             +-----------------------+
        size: 1x4 => count: 4              |     |     |     |     |
        size: 2x2 => count: 9              |     |     |     |     |
        size: 2x4 => count: 3              +-----+-----+-----+-----+
        size: 3x2 => count: 6              |     |     |     |     |
        size: 3x4 => count: 2              |     |     |     |     |
        size: 4x2 => count: 3              +-----+-----+-----+-----+
        size: 4x4 => count: 1              |     |     |     |     |
3x1 shapes:                                |     |     |     |     |
        size: 3x1 => count: 8              +-----+-----+-----+-----+
        size: 3x2 => count: 6              |     |     |     |     |
        size: 3x3 => count: 4              |     |     |     |     |
        size: 3x4 => count: 2              +-----------------------+
1x3 shapes:
        size: 1x3 => count: 8                  Total Count = 136
        size: 2x3 => count: 6
        size: 3x3 => count: 4
        size: 4x3 => count: 2
2x2 shapes:
        size: 2x2 => count: 9
        size: 2x4 => count: 3
        size: 4x2 => count: 3
        size: 4x4 => count: 1

tutti. C'è ancora un po 'di confusione nelle carte di Viola e Jones.

Nel loro documento CVPR'01 si afferma chiaramente che

"Più specificamente, utilizziamo tre tipi di elementi. Il valore di un elemento a due rettangoli è la differenza tra la somma dei pixel all'interno di due regioni rettangolari. Le regioni hanno la stessa dimensione e forma e sono adiacenti orizzontalmente o verticalmente (vedi Figura 1). Una feature a tre rettangoli calcola la somma all'interno di due rettangoli esterni sottratta dalla somma in un rettangolo centrale. Infine una feature a quattro rettangoli ".

Nel documento IJCV'04 si dice esattamente la stessa cosa. Quindi, in tutto, 4 funzionalità . Ma stranamente, questa volta hanno affermato che il set completo di funzionalità è 45396! Questa non sembra essere la versione finale.Qui immagino che siano stati introdotti alcuni vincoli aggiuntivi, come min_width, min_height, rapporto larghezza / altezza e persino posizione.

Nota che entrambi i documenti sono scaricabili sulla sua pagina web .

Non avendo letto l'intero giornale, la formulazione della tua citazione mi colpisce

Dato che la risoluzione di base del rilevatore è 24x24, l'insieme esauriente di funzioni rettangolari è piuttosto ampio, oltre 180.000. Si noti che a differenza della base Haar, l'insieme di elementi rettangolari è troppo completo.

"L'insieme di elementi rettangolari è troppo completo" "Insieme esaustivo"

mi suona come una configurazione, in cui mi aspetto che l'autore della carta segua una spiegazione su come abbattere lo spazio di ricerca in un insieme più efficace, ad esempio eliminando casi banali come i rettangoli con zero superficie.

modifica: o utilizzando una sorta di algoritmo di apprendimento automatico, come suggerisce l'abstract. Un insieme esaustivo implica tutte le possibilità, non solo quelle "ragionevoli".

Non vi è alcuna garanzia che qualsiasi autore di qualsiasi articolo sia corretto in tutte le sue ipotesi e risultati. Se pensi che l'ipotesi n. 4 sia valida, mantienila e prova la tua teoria. Potresti avere più successo degli autori originali.

Osservazione abbastanza buona, ma potrebbero implicitamente azzerare il fotogramma 24x24 o "overflow" e iniziare a utilizzare i primi pixel quando esce dai limiti, come negli spostamenti rotazionali, o come ha detto Breton, potrebbero considerare alcune caratteristiche come "caratteristiche banali" e poi scartali con AdaBoost.

Inoltre, ho scritto versioni Python e Matlab del tuo codice in modo da poter testare il codice da solo (più facile da eseguire il debug e da seguire per me) e quindi le pubblico qui se qualcuno le trova utili prima o poi.

Pitone:

frameSize = 24;
features = 5;
# All five feature types:
feature = [[2,1], [1,2], [3,1], [1,3], [2,2]]

count = 0;
# Each feature:
for i in range(features):
    sizeX = feature[i][0]
    sizeY = feature[i][1]
    # Each position:
    for x in range(frameSize-sizeX+1):
        for y in range(frameSize-sizeY+1):
            # Each size fitting within the frameSize:
            for width in range(sizeX,frameSize-x+1,sizeX):
                for height in range(sizeY,frameSize-y+1,sizeY):
                    count=count+1
print (count)

Matlab:

frameSize = 24;
features = 5;
% All five feature types:
feature = [[2,1]; [1,2]; [3,1]; [1,3]; [2,2]];

count = 0;
% Each feature:
for ii = 1:features
    sizeX = feature(ii,1);
    sizeY = feature(ii,2);
    % Each position:
    for x = 0:frameSize-sizeX
        for y = 0:frameSize-sizeY
            % Each size fitting within the frameSize:
            for width = sizeX:sizeX:frameSize-x
                for height = sizeY:sizeY:frameSize-y
                    count=count+1;
                end
            end
        end
    end
end

display(count)

Nel loro documento originale del 2001 affermano solo che vengono utilizzati tre tipi di funzionalità:

usiamo tre tipi di funzionalità

Anche

Le regioni hanno la stessa dimensione e forma

Poiché ogni tipo ha due orientamenti, è ragionevole presumere che utilizzino 6 funzioni in totale (almeno per il calcolo del numero totale di elementi): 2 elementi a due rettangoli, 2 elementi a tre rettangoli e 2 elementi a quattro rettangoli. Con questo presupposto ci sono infatti oltre 180.000 funzionalità:

feature_types = [(1,2), (2,1), (1,3), (3,1), (2,2), (2,2)]
window_size = (24,24)

total_features = 0
for f_type in feature_types:
    for f_height in range(f_type[0], window_size[0] + 1, f_type[0]):
        for f_width in range(f_type[1], window_size[1] + 1, f_type[1]):
            total_features += (window_size[0] - f_height + 1) * (window_size[1] - f_width + 1)
            
print(total_features)
# 183072

Se si elimina un tipo di elementi a quattro rettangoli (che sembra essere il caso nella loro pubblicazione successiva), il numero totale di elementi è 162.336.