Discussion :

[black_hole]

Bonjour,

Je suis en train d'étudier cette algorithme :
http://www.codeproject.com/Articles/...59#xx5284659xx

Je bute sur la partie classification, visiblement pour cette classification, il y a des plusieurs stages é executer et un stage contient plusieurs nodes. Un stage est un kernel a appliquer sur l'image (calcul des sommes pixels a l'interieurs d'une zone).

Je ne comprends pas dans le code qui suit donc on calcule grace à la méthode de l'intégrale d'image la somme des pixels dans un kernel.
Ensuite ayant la somme de ce kernel on verifie qu'il dépasse un seuil et en fonction on ajoute dans value la valeur du node gauche ou droit mais pourquoi faut-il faire ca?

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/// <summary>
///   Classifies an image as having the searched object or not.
/// </summary>
public bool Classify(IntegralImage2 image, int x, int y, double factor)
{
    double value = 0;
 
    // For each feature in the feature tree of the current stage,
    foreach (HaarFeatureNode[] tree in Trees)
    {
        int current = 0;
        do
        {
            // Get the feature node from the tree
            HaarFeatureNode node = tree[current]; 
 
            // Evaluate the node's feature
            double sum = node.Feature.GetSum(image, x, y);
 
            // And increase the value accumulator
            if (sum < node.Threshold * factor)
            {
                value += node.LeftValue;
                current = node.LeftNodeIndex;
            }
            else
            {
                value += node.RightValue;
                current = node.RightNodeIndex;
            }
        } while (current > 0);
    }
 
    // After we have evaluated the output for the
    //  current stage, we will check if the value
    //  is still lesser than the stage threshold. 
    if (value < this.Threshold)
    {
        // If it is, the stage has rejected the current
        // image and it doesn't contains our object.
        return false;
    }
    else
    {
        // The stage has accepted the current image
        return true;
    }
}

Pour moi dans le cas des haar feature, on applique le kernel sur une partie de l'image et si ca correspond a une valeur theorique ca colle ...

Quelqu'un pourrait-il m'apporter plus d'explication sur cette algorithme?

[patrick.bonnin]

Bonjour,

Voilà l'article original de Viola et Jones.
L'image intégrale permet d'optimiser les calculs.
Cordialement
Patrick Bonnin

[thy-sins]

Je ne comprends pas dans le code qui suit donc on calcule grace à la méthode de l'intégrale d'image la somme des pixels dans un kernel.
Ensuite ayant la somme de ce kernel on verifie qu'il dépasse un seuil et en fonction on ajoute dans value la valeur du node gauche ou droit mais pourquoi faut-il faire ca?

Bonjour,

grosso modo,pour detecter des caractéristiques particulières sur une image,on a besoin des "haar-like features",les caractéristiques de haar...
et ces caractéristiques de haar consistent a additionner et soustraire la somme des pixels de deux zones a l'intérieur.

Le truc,c'est que ce procédé est répété,des centaines de fois sur toute l'image...il faut imaginer cela comme une fenetre d'une certaine surface (on imagine par exemple 5x5 pixels)qui se déplacera sur ton image (imaginons une image en ultra HD,3840x2160) pendant qu'a l'interieur tu fasse passer toutes tes caracteristiques de haar.
cette fenetre tu va devoir l'agrandir a chaque fois qu'elle atteint la fin de l'image,jusqu'a ce qu'elle ait la taille de l'image entiere.

Je te laisse imaginer le nombre d'additions et de soustractions qu'il faudra faire si il fallait a chaque fois,dans chacune de ses fenetres,a chacune de ses tailles,faire ces opérations sur des pixels de l'image originelle...c'est hyper lent.

L'image intégrale,c'est une optimisation sur cette partie de l'algorithme...Au lieu d'avoir a refaire des additions,parfois sur les memes pixels d'ailleurs,tu calcule l'image integrale une seule fois.
Puis tu l'utilise a la place de ta photo ou image originelle,ça te permet de calculer en O(1) n'importe quelle somme de pixels sur n'importe quelle zone de ta photo.

Ensuite,concernant les poids des caractéristiques de haar,il faut savoir qu'il faut préalablement si je me rappelle bien,avoir entrainé un classifieur...je n'ai jamais touché personnellement la partie entrainement,je sais que c'est réalisé avec une variante de l'algorithme d'adaboost,mais j'ai utilisé un fichier xml ou des classifieurs de haar étaient déja entrainés a detecter des visages...y'a des fichiers en xml de cascades de haar générés par OpenCV que tu peux utiliser et qui sont dispo sur internet.

le truc de left node et right node n'est en fait du qu'a la structure en xml des classifieurs...



Grosso modo,il faut voir tout ça comme une liste de stages,chaque noeud de cette liste contient un arbre de caractéristiques de haar et un poids.

ce poids la,celui de chaque noeuds du stage,correspond a "this.threshold" dans ton algorithme.

Donc ce qu'on fait,c'est qu'a chaque fois qu'une fenetre de haar detecte quelque chose,on incrémente "value" avec la valeur du noeud fils droit.

et cette variable value on va la comparer au poids du stage.

les stages agissent en réalité comme des filtres...c'est une autre optimisation de l'algorithme qui sert a stopper la recherche en cour si rien n'est trouvé.

Si suffisamment de caracteristiques de haar ont renvoyé une detection positive (par exemple,un nez,des yeux etc),on passe le stage vers le suivant.

Sinon,on arrete la recherche de cette fenetre et on la déplace plus en avant dans l'image.

Considère qu'une fenetre a detecté un visage (ou quelque chose qui s'y approche) si celle ci a passé tous les stages de la cascade.

cette fenetre c'est justement le cadre qui est censé etre dessiné a l'image pour detecter le visage.

A la fin de ton algorithme,tu te retrouvera avec beaucoup de fenetres,s'agglutinant plus ou moins sur le ou les visages de la photo...il suffira juste que tu fasse une "moyenne" de toutes ces fenetres afin d'en avoir une seule...la tu peux essayer plein de trucs,j'imagine que ça doit bien marcher par exemple avec la segmentation d'image pour voir quelle zone de l'image regroupe le plus de fenetres,ou bien tu peux déduire ça trés simplement avec un peu de géométrie...


J'espere que j'ai été clair,hésitez pas a relever si j'ai fait quelques erreurs.