Discussion :

[Flophx]

Bonjour à tous, je demande votre aide car j'ai besoin d'optimiser un programme informatique;

J'ai actuellement un programme qui permet de faire des captures d'image issue d'une WebCam. Avec la forme actuelle du programme, j'arrive à environ 10 images par seconde.

Je voudrais pouvoir monter à au moins 20 images par seconde afin d'arriver à reconstituer une vidéo avec ffmpeg.

J'aurais besoin de pistes pour améliorer la capacité de mon programme à récupérer des images

Toute idée st la bienvenue!!

[fearyourself]

Bonjour à tous, je demande votre aide car j'ai besoin d'optimiser un programme informatique;

J'ai actuellement un programme qui permet de faire des captures d'image issue d'une WebCam. Avec la forme actuelle du programme, j'arrive à environ 10 images par seconde.

Je voudrais pouvoir monter à au moins 20 images par seconde afin d'arriver à reconstituer une vidéo avec ffmpeg.

J'aurais besoin de pistes pour améliorer la capacité de mon programme à récupérer des images

Toute idée st la bienvenue!!

Il faut déterminer avec un profileur (programme qui regarde le comportement d'un programme) quelles sont les zones de code qui utilisent beaucoup de ressources et se concentrer sur celles-là.

Jc

[Thierry Chappuis]

Ma première recommandation est d'utiliser un profiler afin de localiser les goulots d'étranglement. Ensuite, tu pourras optimiser de manière ciblée, voir poster des bouts de code provenant d'une fonction particulièrement gourmande en ressources. L'optimisation est un vaste sujet, et il est difficile de répondre comme cela, en toute généralité. Le conseil de débutant que je peux donner pour le moment est: "optimise où c'est nécessaire"

Thierry

[Flophx]

Bien, alors pour commencer,lequel me recommandez-vous?

[souviron34]

Tout dépend.

Si ton programme est assez simple, la mniére la plus rapide est de faire des printfs entourant les endroits que tu penses difficiles, et le regarder tourner..

Ensuite, tu peux utiliser gprof (tu compiles avec -pg) ou prof (-p). Là tu as statistiques de temps de passage, de nombres d'appels, etc...

[Flophx]

Je pense que dans mon cas il me faut qqch de relativement précis, parce que je soupconne l'acquisition de l'image (ca mise en mémoire), puis la création du fichier .ppm comme étant le plus couteux en temps... Et les printf me semble un peu limité non?

[souviron34]

Encore une fois tout dépend

ça peut donner une première idée.. Moi en général c'est ce que je fais..

Si là (et je suppose qu'avec ce que tu dis, je suis presque sûr que c'est dans la génération du .ppm) tu ne vois rien d'évident, tu passes à gprof ou prof..

Très rapide aussi... Et la sortie est un fichier te listant l'ensemble des routines avec les pourcentages de temps, d'appels, etc..

[Flophx]

J'ai une question à ajouter: je développe actuellement ce programme sur un PC 3,2 GHz, et 512 Mo de RAM. Il est destiné à être implanté sur une carte munie d'un processeur 100 MHz, avec 16Mo de RAM. L'impact du changement d'environnement sera t-il tel que même bien optimisé, la destinée de mon programme sera vaine??

[Emmanuel Delahaye]

J'ai une question à ajouter: je développe actuellement ce programme sur un PC 3,2 GHz, et 512 Mo de RAM. Il est destiné à être implanté sur une carte munie d'un processeur 100 MHz, avec 16Mo de RAM. L'impact du changement d'environnement sera t-il tel que même bien optimisé, la destinée de mon programme sera vaine??

Tu crois vraiment qu'on peut répondre sérieusement à cette question ? On t'a dit de faire du profiling, tu l'as fait ?

[Flophx]

Bien, voilà ce que j'ai fait:
j'avais des tableaux intermédiares qui effectivement ne servait à rien, je les ai supprimer, mais sur 1min, j'ai environ gagné 10 images....

sinon, j'ai exécuté gprof, et voici ce qu'il me retourne:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name    
100.00      0.06     0.06       10     6.00     6.00  extractPix
  0.00      0.06     0.00        1     0.00    60.00  captureImage
  0.00      0.06     0.00        1     0.00     0.00  closeCam
  0.00      0.06     0.00        1     0.00     0.00  openCam
  0.00      0.06     0.00        1     0.00     0.00  printCap
  0.00      0.06     0.00        1     0.00     0.00  setImage
  0.00      0.06     0.00        1     0.00     0.00  setWin

et

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
 
index % time    self  children    called     name
                0.06    0.00      10/10          captureImage [2]
[1]    100.0    0.06    0.00      10         extractPix [1]
-----------------------------------------------
                0.00    0.06       1/1           main [3]
[2]    100.0    0.00    0.06       1         captureImage [2]
                0.06    0.00      10/10          extractPix [1]
-----------------------------------------------
                                                 <spontaneous>
[3]    100.0    0.00    0.06                 main [3]
                0.00    0.06       1/1           captureImage [2]
                0.00    0.00       1/1           openCam [5]
                0.00    0.00       1/1           printCap [6]
                0.00    0.00       1/1           setWin [8]
                0.00    0.00       1/1           setImage [7]
                0.00    0.00       1/1           closeCam [4]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[4]      0.0    0.00    0.00       1         closeCam [4]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[5]      0.0    0.00    0.00       1         openCam [5]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[6]      0.0    0.00    0.00       1         printCap [6]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[7]      0.0    0.00    0.00       1         setImage [7]
-----------------------------------------------
                0.00    0.00       1/1           main [3]
[8]      0.0    0.00    0.00       1         setWin [8]
-----------------------------------------------

Sans surprise, c'est la fonction qui recoit en paramètr el'image contenue dans le budffer et qui la transforme en PPM qui prend le plus du temps...
Mais là comme ca, ca apporte peu d'eau à mon moulin non?
N'y aurait il pas plus précis pour voir ou se situe le goulot d'étranglement??

[souviron34]

100.00 0.06 0.06 10 6.00 6.00 extractPix
0.00 0.06 0.00 1 0.00 60.00 captureImage

Bon ya quelque chose que je comprends pas trop dans la sortie, mais en gros c'st sur ces 2 routines que ça se passe, ton étranglement, non ??

[Flophx]

Dans l'exemple donné, j'ai fait un test pour 10 captures.
EN fait, captureimage est appelé dans le main, et fait comme suit:
1) capture l'image
2) passe l'image en paramètre de la fonction extraxpix, qui crée le PPM
Il le fait normalement en continu (while(1))....

[Flophx]

Bien, je vous donne le code tel qu'il est au niveau du goulot d'étranglement:

image.c:

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
 
/*
 * Conversion en format PPM*/
#include <string.h>
#include "image.h"
void extractPix(unsigned char* imgbuffer, int hauteur, int largeur, int num)
{
 
    sprintf(nom_image,"Image_%.05d.ppm", num);
    printf("nom_image = '%s'\n",nom_image);
 
    fp = fopen(nom_image, "w");
 
    if(fp==NULL)
    {
        printf("Impossible d'ouvrir le fichier\n");
        exit(-1);
    }
 
    fprintf(fp, "P6\n%d %d\n255\n",largeur, hauteur);
 
    p=1;
    jDebut=1;
    j = jDebut;
    for(ligne=0;ligne<hauteur;ligne++)   
    {
        if(ligne%2!=0)
            j=jDebut;
        else
            jDebut=j;
        for(colonne=0;colonne<largeur;colonne++)
        {
 
            b = 1.164*(imgbuffer[p]-16)+2.018*(imgbuffer[taille_totale+j]-128);p++;
            g = 1.164*(imgbuffer[p]-16)-0.813*(imgbuffer[taille_totale+j]-128)-0.391*(imgbuffer[5*taille_totale/4+j]
            r = 1.164*(imgbuffer[p]-16)+1.596*(imgbuffer[5*taille_totale/4+j]-128);
 
 
            putc(r, fp);
            putc(g, fp);
            putc(b, fp);
 
            if(colonne%2==0)
                j++;
        }
    }
 
    fflush(fp);
    fclose(fp);
}

et image.h:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <stdio.h>
#include <stdlib.h>
#include "camera.h"
 
FILE* fp;
unsigned int ligne,colonne;
unsigned char  r,g,b;
unsigned char nom_image[17] = "";
unsigned int taille_totale = HEIGHT*WIDTH;
unsigned int j, jDebut;
unsigned int p;
void extractPix(unsigned char* imgbuffer, int hauteur, int largeur, int num);

Si quelqu'un a des idées pour optimiser cette partie, là j'avoue être un poil perdu...

[O( N )]

Bonjour ,

( Je réalise un logiciel sur le format PPM pour faire du traitement numérique destiné à l'OPEN SOURCE, avec des cours, des explications, des liens, le code et l'exécutable si stable )

Si tu cherche à devélopper dedans, si cela t'intéresse tu peux me MP

Sinon pour ton truc, juste une petite idée comme çà

Si tu connais le nombre d 'images que tu génères à chaque fois ! Au lieu de faire un sprintf tu fais pointé 'nom_image sur le tableau de chaines de caractères contenant déjà les noms de fichiers 'Image_00001.ppm' ... .

Voilà @+