Discussion :

[schneed]

Bonjour,

Je souhaite afficher sur un fenêtre une vidéo issu de 2 caméras (type webcam) avec des flux récupérés via OpenCV.

Connaissez vous une méthode permettant de gérer cet affichage et consommant pas trop de mémoire ?

J'ai essayé avec l'affichage d'un wxMemoryDC directement sur un wxPanel, mais j'ai l'impression que ça consomme un maximum de ressources processeur. Avez vous déjà été confrontés à ce genre de problématique ? Toutes les idées sont bonnes à prendre

J'ai trouver dans un autre thread du forum wxCam, mais ce dernier est uniquement Linux, et notre ami Google est peu verbeux sur le sujet : -> je dois faire tourner ça sous Windows 10, mais je souhaiterais que la solution soit compatible Linux.

Merci de vos pistes ;-)

[wxXav]

Salut.

J'avais fait, il y a déjà quelques temps, un petit logiciel utilisant une webcam via OpenCV pour "surveiller" une pièce.

Je passais directement par un wxClientDC pour afficher l'image sur un wxPanel. Par contre, je suis incapable de te dire si c'était anormalement gourmand en utilisation CPU.

Après, si tu veux qu'on voie ce qui pourrait sur-consommer du CPU, il faut poster un peu de code.

@+
Xav'

[schneed]

Merci wxXav de ta réponse, toujours dans les starting blocks

Bon, je viens de reprendre des parties de ta solution, et j'obtiens les valeurs suivantes :

Lorsque je prend une image depuis ma webcam (640x480), j'obtiens une utilisation processeur à 6% pour l'affichage de 2 images.
Lorsque je tente d'afficher une image sensiblement () plus grande (1920x1080), j'obtiens une utilisation processeur à 25 % (bon, ok, c'est un peu extrême de par la taille de l'image, mais je ne fais encore aucun traitement ?!? ...)

J'ai tenté de lancer le programme de test avec l'analyse des perf de Visual Studio et celui ci indique les goulots d'étranglement suivants :

• La conversion de l'image cv::Mat en wxImage : 22% du temps cpu total
• La conversion de l'image wxImage en wxBitmap : 22% du temps cpu total
• L'affichage de l'image sur le DC avec la fonction DrawBitmap : 16% du temps cpu total

Ci dessous, les fonctions de conversion :

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
wxImage videoCanvas::convertMat(cv::Mat newFrame)
{
  // Convert cv::Mat to wxImage
    if(newFrame.channels() != 3)
      throw std::logic_error("Input image should be 3-channel");
 
    // data dimension
      int w = newFrame.cols;
      int h = newFrame.rows;
      int size = w * h * 3 * sizeof(unsigned char);
 
    // allocate memory for internal wxImage data
      unsigned char* wxData = (unsigned char*) malloc(size);
 
    // the matrix stores BGR image for conversion
      cv::Mat cvRGBImg = cv::Mat(h, w, CV_8UC3, wxData);
 
    // swap R&B channels
      int mapping[] = {0,2,1,1,2,0};                            // CV(BGR) to WX(RGB)
      mixChannels(&newFrame, 1, &cvRGBImg, 1, mapping, 3);
 
    // release data
      return wxImage(w, h, wxData);
}
 
[...]
 
wxImage temp_img = convertMat(m_lastFrame);
wxBitmap temp_bmp(temp_img);

L'idéal serait une solution permettant d'accrocher une fenêtre telle que l'on peut visualiser avec un imshow, à l’intérieur d'un panel...

Des idées ???

Merci

[wxXav]

Hello.

Je ne suis pas certain de pouvoir t'être d'un grand secours : je n'ai pas de très bonnes connaissances en OpenCV, et le petit projet que je t'ai filé commence à dater un peu (ça fait un bon bout de temps que je n'ai pas mis le nez dedans).

Malgré tout, voici quelques pistes.

Tout d'abord, l'utilisation d'une wxImage n'est là que pour permettre le redimensionnement de l'image avant de l'afficher.
Si tu n'en a pas besoin, tu peux essayer directement de créer un wxBitmap avec les octets reçus de la webcam (il y a un constructeur qui prend en paramètre les données brutes : http://docs.wxwidgets.org/stable/cla...f6e5c1de516f21 )

Tu peux ensuite tester les performances en remplaçant l'utilisation de DrawBitmap par Blit (il faut dans un premier temps sélectionner le wxBitmap avec un wxMemoryDC que tu utiliseras comme source). Je ne sais pas laquelle des deux fonctions est la plus performante (mais tu vas peut-être bientôt me le dire... )

Il y a une autre solution à laquelle je n'avais pas pensé quand j'ai fait ce petit logiciel, et je ne suis même pas sûr que ça va marcher :
Comme la taille mémoire nécessaire pour le stockage du wxBitmap est toujours la même tant que l'on n'a pas changé la résolution de la caméra, il est peut-être possible de faire l'allocation mémoire une seule fois, et ré-écrire les données dedans (dans ce cas, pas besoin de re-créer le wxBitmap à chaque fois, ses données devraient être mises à jour automatiquement).
C'est un coup de poker qu'à mon avis tu peut tester.

Tu peux aussi faire quelques tests avec les fonctions GDI (wxGraphicsContext) qui sont peut-être plus performantes (à voir).

Bonne chance, et tiens moi au courant stp.

@+
Xav'

[schneed]

Salut à tous,

Bon, j'ai pu faire quelques essais : 1 pas en avant, 2 pas en arrière

[...] l'utilisation d'une wxImage n'est là que pour permettre le redimensionnement de l'image avant de l'afficher.
Si tu n'en a pas besoin, tu peux essayer directement de créer un wxBitmap avec les octets reçus de la webcam (il y a un constructeur qui prend en paramètre les données brutes : http://docs.wxwidgets.org/stable/cla...f6e5c1de516f21 )[...]

Cette solution n'a pas l'air de fonctionner. J'ai utiliser la méthode suivante afin de créer un wxBitmap :

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
void convertMat(cv::Mat newFrame, wxBitmap &bmp)
{
  // Convert cv::Mat to wxBitmap
    if(newFrame.channels() != 3)
      throw std::logic_error("Input image should be 3-channel");
 
    // data dimension
      int w = newFrame.cols;
      int h = newFrame.rows;
      int size = w * h * 3 * sizeof(unsigned char);
 
    // allocate memory for internal wxImage data
      char* wxData = (char*) malloc(size);
 
    // the matrix stores BGR image for conversion
      cv::Mat cvRGBImg = cv::Mat(h, w, CV_8UC3, wxData);
 
    // swap R&B channels
      int mapping[] = {0,2,1,1,2,0};                            // CV(BGR) to WX(RGB)
      mixChannels(&newFrame, 1, &cvRGBImg, 1, mapping, 3);
 
    // Make wxBitmap
      bmp = wxBitmap(wxData, w, h, 3);
      free(wxData);
}

Le bitmap résultant n'a pas l'air valide. En tout cas, rien ne s'affiche... Lorsque que je mets la profondeur à 1, j'ai bien un bitmap 'valide' mais ce n'est en fait que de la 'neige'... Je vais refaire des essais en ce sens, car ce serait cool d'éliminer cette étape intermédiaire...

[...] Tu peux ensuite tester les performances en remplaçant l'utilisation de DrawBitmap par Blit (il faut dans un premier temps sélectionner le wxBitmap avec un wxMemoryDC que tu utiliseras comme source). Je ne sais pas laquelle des deux fonctions est la plus performante (mais tu vas peut-être bientôt me le dire... )[...]

Je n'ai pas regardé les pourcentage d'utilisation de la fonction Blit par rapport à Draw, mais je n'ai pas observé d'amélioration quand à l'utilisation CPU globale. J'ai l'impression que c'est une impasse...

Je vais m'attarder sur les deux autres propositions que tu as fait. D'après ce que j'ai pu lire sur les wxGraphicsContext, les utilisateurs avaient un avis mitigé... A voir.


A titre de comparaison, j'ai regardé ma consommation CPU lorsque j'affiche les 2 images avec la fonction imshow(...). Ça fout les miquettes : je plafonne à 13% en affichant les 2 jpg chacun dans une frame différente d'après le code, y'a de l'OpenGL et consort...

A suivre...