OpenNI : problème affichage trop lent

**Shurtagh** · 13/05/2011, 15h50

Bonjour à tous,

Je travail actuellement sur l'utilisation de la caméra Kinect de Microsoft (caméra capable de voir en profondeur) sur ordinateur afin de développer une application destinée au tracking de la main.

J'utilise la bibliothèque OpenNI pour ce qui est de la partie récupération des données de la caméra et la bibliothèque OpenCV pour ce qui est de la partie traitement d'image.

J'ai cependant un petit problème avec OpenCV. En effet je souhaite dans un premier temps faire un affichage classique de la caméra VGA dans une fenêtre.
Je récupère alors les données pour ensuite en faire une matrice que j'affiche à l'aide de la fonction cv::imshow.

L'image apparaît mais l'affichage est saccadé (là est mon problème). J'ai mesuré le temps d'exécution, il est à environ 25ms (ce qui équivaut je croix à approximativement 40 fps). Je ne comprend pas pourquoi l'affichage est aussi lent alors que le traitement semble supérieur à 30 fps.

Ceci est mon premier poste sur ce forum (et j'espère pas le dernier

) je suis donc débutant en OpenCV (même plus généralement en traitement d'image

).

Voici le code que j'utilise :

Code :

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
        /*
        INITIALISATION DES OBJETS OPENNI
        (ces objets me permettent par la suite de récupérer les données
        de la caméra)
        */
 
    //variable(s) pour test des erreurs
    XnStatus rc;
    //initialise le context
    rc = g_context.InitFromXmlFile(SAMPLE_XML_PATH);
    CHECK_RC(rc, "initialisation du context\n");
    //initialise générateur de profondeur
    rc = g_context.FindExistingNode(XN_NODE_TYPE_DEPTH, g_depth);
    CHECK_RC(rc, "initialisation du générateur de profondeur\n");
    //initialise métadonnées de profondeur
    g_depth.GetMetaData(g_depthMD);
    //initialise générateur d'image
    rc = g_context.FindExistingNode(XN_NODE_TYPE_IMAGE, g_image);
    CHECK_RC(rc, "initialisation du générateur d'image\n");
    //initialise métadonnées d'image
    g_image.GetMetaData(g_imageMD);
 
 
    //generation des donnees
    rc = g_context.StartGeneratingAll();
    CHECK_RC(rc, "generating all context\n");
 
 
 
        /* j'utilise pour le moment une boucle infinie pour l'affichage */
while(true){<div style="margin-left:40px">
        //début du timer destiné à calculer le temps d'exécution
        double tt = (double)cvGetTickCount();
 
        //variables
        int nbColone = g_imageMD.XRes();
        int nbLigne = g_imageMD.YRes();
 
        //déclaration , alocation qui pointe sur les future pixels à afficher
unsigned char* picture = new unsigned char[nbLigne * nbColone * 3];
 
                //initialisation avec les données récupérées
                memcpy(picture, (unsigned char*)g_imageMD.RGB24Data(),nbLigne * nbColone * 3);
 
                //bascule du sens du Rouge et du bleu pour avec le format RGB
        for(int i = 0 ; i < nbLigne * nbColone ; i++){<div style="margin-left:40px">unsigned char temp = picture[i*3];
            picture[i*3] = picture[i*3+2];
            picture[i*3+2] = temp;</div>}
 
        //transfère dans une matrice puis affichage
        cv::Mat couleurMatRes(nbLigne, nbColone, CV_8UC3, picture);     
        cv::imshow("Christophe",couleurMatRes);
 
                //attente d'une ms
        cvWaitKey(1);
 
        //libération de la mémoire couleur
        delete[] picture;
 
        //fin du timer et calcul du temps écoulé
        tt = (double)cvGetTickCount() - tt;
                cout << "Temps d'extraction : " << tt/(cvGetTickFrequency()*1000.) << "ms" << endl;</div>}

J'espère avoir était clair, merci de votre attention

.

Shurtagh

**snowpy** · 16/05/2011, 15h24

Salut

déjà balise code sinon tu vas te faire taper dessus ^^

ensuite moi j'enlèverais toutes les déclarations de variable d'une boucle infinie (sous openCV générallement tu crée une fonction traitement et tu l'appelle dans ta boucle while pour pas avoir tout dans le while et tu déclares toutes tes variables en global, avec une init dans la fonction)

//bascule du sens du Rouge et du bleu pour avec le format RGB

ca, je pense qu'en cherchant un peu tu trouveras la fonction à utiliser.

Code :

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

unsigned char* picture = new unsigned char[nbLigne * nbColone * 3];

j'utiliserais plus une Iplimage moi comme ca tu es tranquil pour les traitements derrières, pareil pour le transfert dans ta matrice et l'affichage avec une iplimage les fonctions sont toutes faites.

Tu es bien à 40 ips mais as tu vérifié ton image. afficher une image dans une fenêtre et vérifier sa validité ?

(évite une boucle while infini mets plutot une condition de sortie avec un wait key)

J'ai un vague souvenir d'une tempo dans le while si le traitement est trop rapide, car ton programme n'a pas le temps de traiter ta première image que tu es déjà à la suivante et ainsi de suite.

**Shurtagh** · 16/05/2011, 16h56

Salut,

Tout d'abord merci pour ta réponse, je m'excuse pour le non balisage en code, étant nouveau sur le forum je n'ai pas eu ce reflex

c'est noté pour la prochaine fois*.

Merci pour tes différents conseils, tu as raison c'est beaucoup plus clair de cette manière (éviter la déclaration de variables dans une boucle infinie et utiliser des variables globales), l'utilisation d'un waitKey() simplifie aussi la vie

.

Dans mon programme j'effectue différents traitements, il est plus conséquent et organisé. J'avais fait rapidement ce petit exemple pour montrer mon problème.
Il m'arrive par exemple de recopier des "bouts" d'image pour en faire d'autres. C'est pourquoi j'étais resté ""bas niveau"" avec un unsigned char*pour mes images (je pouvais facilement recopier des morceaux de mon tableau). Je les basculais en cv::Mat à la fin juste pour l'affichage. Pour les IplImages, je ne sais pas tout ce que l'on peut faire avec, mais j'essayerais de plus les utiliser.

Est-il mieux d'afficher avec une matrice (imshow) ou avec une IplImage (cvShowImage) ?

Autrement les images (saccadées) qui s'affiche à l'écran sont pleines et bien formées. Il m'était aussi arrivé de les enregistrer et il n'y avait pas de problème.

Pour remédier à ce problème je pense que je vais faire un gros buffer de mes images pour les enregistrer en vidéo afin de voir si l'affichage est toujours saccadé (la difficulté est qu'il faudra que je stocke également les données de profondeur fournies par la caméra à l'aide du capteur infra-rouge), je devrais cependant remédier à ce problème d'affichage.

Je pense que la piste du traitement effectué trop rapidement par rapport à l'affichage peut être une piste effectivement.

Merci.

**snowpy** · 16/05/2011, 17h39

hum en theorie matrice ou image c'est similaire, mais la theorie a du mal à rejoindre la pratique quelques fois ^^

pour ca il faudrait s'intéresser à ce qui se passe en couche basse avec une Iplimage chose que je n'ai jamais faite

L'Iplimage est intéressante car elle permet la récupération d'information sur ton image directement de part sa structure sans traitement, à voir si cela t'es nécessaire.

essaye les deux si le résultat est similaire ton problème ne vient pas de la. En passant si ton flux vient d'une caméra il est normallement possible de récupérer directement l'image avec un cvgrabframe par exemple (tu trouveras pas mal d'exemple sur le forum)

Concernant le temps, normallement il faut qu'il soit supèrieur à 10 ms mais ceci avec un grabframe, de ton côté il faudrait que tu vérifie que ton système d'acquisition d'image est robuste à 25 ms par exemple.

**Shurtagh** · 17/05/2011, 09h41

Je n'ai pas testé mais effectivement je pense que si il y a une différence elle doit être minime.

En effet, l'iplimage propose ensuite de nombreuses possibilités, je penserais à plus (+) l'utiliser. Certaines de ces possibilités pourront êtres utiles.

Pour l'acquisition d'image j'utilise OpenNI, je n'ai pas essayé le cvgrabframe. Cependant avec OpenNI est fourni des applications de test qui utilisent glut32 pour l'affichage et l'intéraction Homme-Machine, il n'y a aucun problème. L'affichage est fluide. J'ai donc pris leur application et j'y ai ajouté OpenCV, dans leur fonction dessin j'ai appelé la mienne (utilisant openCV). L'affichage était bien et sans latence.

Je ne peux pas cependant garder cette méthode, utiliser deux librairies graphiques pour une même chose n'est pas judicieux. J'utilise quelques fonctions d'OpenCV et je ne peux pas pour le moment refaire leur algo (même si ça pourrait être intéressant) car je n'ai pas le temps et pour certaines pas le niveau. D'autant plus qu'elles doivent être optimisées sur OpenCV.

Avec glut32 le programme utilise une méthode mainloop qui se charge d'appeler en boucle les différentes fonctions notamment la fonction display.

J'ai créé un projet vide et j'y ai ajouté OpenNI et OpenCV. Le système d'acquisition marche donc mais peut être que je l'utilise mal avec mon projet (même si il me semble que ce soit bon =/);

**Shurtagh** · 18/05/2011, 12h11

C'est bon j'ai résolu mon problème ! C'était bien une mauvais utilisation de OpenNI lors de l'acquisition de l'image et le problème ne venait pas de OpenCV.

En effet, dans ma boucle infinie pour récupérer les données je me contentais de faire :

//initialisation avec les données récupérées
memcpy(picture, (unsigned char*)g_imageMD.RGB24Data(),nbLigne * nbColone * 3);

Je pensais que le g_imageMD.RGB24Data() suffisait pour récupérer la nouvelle image. D'autant plus que mon affichage, même si ça était de façon saccadée, s'actualisait.

Mais cela ne suffit pas, après une lecture de la documentation je me suis rendu compte qu'il faut mettre à jour le contexte avec un g_context.WaitAnyUpdateAll(); puis ensuite mettre à jour les données de l'image correspondante avec un g_image.GetMetaData(g_imageMD);.

Cela donne:

Code :

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

1
2
3
4
5
6
 
        //MODIFICATION : MISE A JOUR CORRECT DES DONNES
	// lecture d'une nouvelle image
	rc = g_context.WaitAnyUpdateAll();
	CHECK_RC(rc, "Mise à jour de l'image\n");
	g_image.GetMetaData(g_imageMD);

Et si je reprends le code précédant cela donne :

Code :

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
/*VARIABLES GLOBALES*/
Context g_context;
DepthGenerator g_depth;
ImageGenerator g_image;
DepthMetaData g_depthMD;
ImageMetaData g_imageMD;
 
 
/*Debut de la fonction main*/
 
 
/*
INITIALISATION DES OBJETS OPENNI
(ces objets me permettent par la suite de récupérer les données
de la caméra)
*/
 
//variable(s) pour test des erreurs
XnStatus rc;
//initialise le context
rc = g_context.InitFromXmlFile(SAMPLE_XML_PATH);
CHECK_RC(rc, "initialisation du context\n");
//initialise générateur de profondeur
rc = g_context.FindExistingNode(XN_NODE_TYPE_DEPTH, g_depth);
CHECK_RC(rc, "initialisation du générateur de profondeur\n");
//initialise métadonnées de profondeur
g_depth.GetMetaData(g_depthMD);
//initialise générateur d'image
rc = g_context.FindExistingNode(XN_NODE_TYPE_IMAGE, g_image);
CHECK_RC(rc, "initialisation du générateur d'image\n");
//initialise métadonnées d'image
g_image.GetMetaData(g_imageMD);
 
 
//generation des donnees
rc = g_context.StartGeneratingAll();
CHECK_RC(rc, "generating all context\n");
 
 
 
/* j'utilise pour le moment une boucle infinie pour l'affichage */
while(true){
 
 
    //début du timer destiné à calculer le temps d'exécution
    double tt = (double)cvGetTickCount();
 
    //variables
    int nbColone = g_imageMD.XRes();
    int nbLigne = g_imageMD.YRes();
 
        //MODIFICATION : MISE A JOUR CORRECT DES DONNES
	// lecture d'une nouvelle image
	rc = g_context.WaitAnyUpdateAll();
	CHECK_RC(rc, "Mise à jour de l'image\n");
	g_image.GetMetaData(g_imageMD);
 
    //déclaration , alocation qui pointe sur les future pixels à afficher
    unsigned char* picture = new unsigned char[nbLigne * nbColone * 3];
 
    //initialisation avec les données récupérées
    memcpy(picture, (unsigned char*)g_imageMD.RGB24Data(),nbLigne * nbColone * 3);
 
    //bascule du sens du Rouge et du bleu pour avec le format RGB
    for(int i = 0 ; i < nbLigne * nbColone ; i++){
 
        unsigned char temp = picture[i*3];
        picture[i*3] = picture[i*3+2];
        picture[i*3+2] = temp;
 
    }
 
    //transfère dans une matrice puis affichage
    cv::Mat couleurMatRes(nbLigne, nbColone, CV_8UC3, picture);
    cv::imshow("Christophe",couleurMatRes);
 
    //attente d'une ms
    cvWaitKey(1);
 
    //libération de la mémoire couleur
    delete[] picture;
 
    //fin du timer et calcul du temps écoulé
    tt = (double)cvGetTickCount() - tt;
    cout << "Temps d'extraction : " << tt/(cvGetTickFrequency()*1000.) << "ms" << endl;
 
}

A savoir que si vous utilisez seulement l'image vous pouvez remplacer le g_context.WaitAnyUpdateAll(); par un g_context.WaitOneUpdateAll(g_image);. Le g_context.WaitAnyUpdateAll(); actualise également d'autres données comme la profondeur récupérée avec le capteur infrarouge.

Bien sur tout ceci est sous réserve d'erreur de compréhension, d'utilisation ou de recopiage

. Si il y en a une merci de le signaler.

**Adous** · 19/05/2011, 06h42

Bonjour Christophe

moi je suis nouveau dans l utilisation de kinect et d opencv

je veux faire comme toi en utilisant opencv pour demarrer le kinect

et faire d autres traitements par la suite

je reste a ton ecoute pour tes explications

merci d avance

**Shurtagh** · 19/05/2011, 15h36

Salut Adous,

Je serai ravi de répondre à toutes les questions que tu te poses

du moins tant que j'en suis capable.

Pour faire un petit résumé :

OpenCV est une bibliothèque qui permet de faire du traitement d'image, je m'en sers pour faire quelques détections de contours, l'affichage etc ... mais je ne m'en sers pas pour récupérer les données de la caméra Kinect.

Pour récupérer les données de la caméra je me sers de la bibliothèque OpenNI. Mon programme possède donc les deux bibliothèques : OpenNI pour récupérer les données de la caméra et OpenCV pour faire des traitements dessus et afficher le résultat.

Tu trouves de très bon tutos pour installer OpenCV et OpenNI (il faut bien faire la distinction ce sont deux bibliothèques différentes).

***

A savoir que si tu veux, à la place de OpenNI tu peux utiliser la bibliothèque CLNUI (de Code Laboratories) pour utiliser kinect sur ton ordinateur. Si je ne trompe pas elle permet de récupérer les données de la caméra couleur, les données de la caméra profondeur et de diriger le moteur (pour faire incliner la caméra). Cependant OpenNi propose en plus de cela des outils plus haut niveau implémentés dans leur bibliothèque comme par exemple la détection de personnes et le célèbre skeleton.

Tu trouve également de très bon tutos pour installer CLNUI si tu le préfère à OpenNI.

***

Pour t'entraîner OpenNI propose des applications en exemple (qui s'installent en même temps que lui). Ces applications vont des choses les plus simples aux un peu plus complexes. Cependant elle n'utilise pas la bibliothèque OpenCV pour l’affichage mais la bibliothèque glut32.

Je te conseil de partir de ces applications pour comprendre le fonctionnement du OpenNI et ensuite de coupler ton travail avec OpenCV pour faire des traitements par dessus.

J'espère que mes explications n'étaient pas trop confuses.

lien utile : http://www.openni.org/documentation

**Adous** · 20/05/2011, 06h00

Salut Christophe,

merci de votre reponse

en ce moment je suis parti avec OpenNI

j ai suivi quelques tutos et j ai installe des drivers pour pouvoir connecter mon kinect a mon pc en ce moment cela marche sauf l audio je ne sais pas pourquoi

ayant une formation en RESEAU, je ne suis pas top en programmation

maintenant je veux utiliser un code ou il ya les deux bibliotheques openNI et openCV, mais j ai un probleme pour l implementation

je ne sais meme pas par ou commencer

merci d avance pour votre aide

**Adous** · 20/05/2011, 06h26

quelques precisions

je pense que je vais faire comme tu as dit travailler avec openNI et apres le coupler avec openCV

en ce moment j ai installe OpenCV, OpenNI et MS Visual Studio 2008

pour le tuto j ai fait les etapes de la section page 19 mais je comprends pas quoi faire sur la partie XML

je mets son lien direct sur le PATH ou bien

et apres les includes je ne vois pas quelles parties des codes du tuto copier

merci d avance

**Shurtagh** · 20/05/2011, 11h53

Concernant l'erreur d'installation de la partie audio c'est normale (du moins je croix) il ne fonctionne pas encore.

Mais te fais pas de soucis, normalement tant que tu as pu installer la caméra, même si son driver audio ne fonctionne pas ce n'est pas grave, tu pourras toujours récupérer les données couleur et profondeur.

Pour l'installation de OpenCV je peux pas trop t'aider =/ moi même j'ai du bidouiller plusieurs choses avec plusieurs tutos différents. Je ne me souviens plus exactement comment j'avais fais désolé.

J'avais gardé le lien de cette vidéo, il me semble que c'est ce que j'avais le plus utilisé pour installé OpenCV :

C'est une vidéo pour la version 2010 mais moi aussi je l'ai installé sur la version 2008, c'est quasiment pareil (si je dis pas de bêtise).

Pour commencer essayer de lancer une application toute faite de OpenNI pour voir si la caméra fonctionne correctement sur ton ordinateur. Tu vas dans démarrer, tous les programmes, openni, samples et tu lance NiSimpleRead ou NiSimpleViewer par exemple. Si le programme ne se lance pas il peut y avoir un problème d'installation.

Si cela fonctionne tu vas maintenant pouvoir aller regarder le code de ces applications. Par exemple pour voir le code de l'application NiSimpleViewer (qui affichage la caméra profondeur à l'écran en nuance de jaune) tu vas dans démarrer, tous les programmes, openni, samples, Samples Directories, NiSimpleViewer et tu lance le projet visual 2008 : NiSimpleViewer_2008;

A ce moment là tu accède au code de l'application avec visual studio 2008 et tu peux le modifier.

Une petite chose : dans le code il y a une petite erreur de lien qu'il faut corriger. En effet, l'application initialise le context avec un fichier XML et le liens n'est pas le bon.

il faut remplacer la ligne :

Code :

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

 #define SAMPLE_XML_PATH "../../../Data/SamplesConfig.xml"

par :

Code :

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

 #define SAMPLE_XML_PATH "../../Data/SamplesConfig.xml"

Il faut juste retirer un ../ . Cependant cela peut dépendre d'un ordinateur à l'autre, ce qui compte c'est que le chemin soit celui du fichier SampleConfig.xml qui est contenu dans le dossier Data où tu as installé openNI.

Une fois cela corrigé tu peux normalement exécuter le code. L'application se compile et se lance.

Cette application NiSimpleViewer est déjà configuré pour utiliser OpenNI, libre à toi de modifier le code comme tu le souhaite. Pour l'affichage elle utilise glut32, tu pourras par la suite la configurer pour pouvoir également utiliser OpenCV.

Tu peux autrement créer un projet de zéro et le configurer pour pouvoir utiliser OpenNi et OpenCV, mais il vaut mieux déjà essayer de comprendre les applications exemple. NiSimpleViewer est vraiment une application simple qui montre comment utiliser la caméra couleur et la caméra profondeur.

PS : Je viens de me rendre compte que j'utilise OpenCV en version 2.1 (même si j'ai la version 2.2). Tu peux utiliser soit l'une soit l'autre , peux importe. Tu dois également pouvoir trouver des tutos pour installer la version 2.1 notamment sur le site d'OpenCV.

OpenNI : problème affichage trop lent

OpenCV

Vue hybride

Discussions similaires

Partager

Partager