Discussion :

[BenjaminLustrement]

Bonjour à tous, je galère depuis quelques temps pour essayer de comprendre un programme que je suis en train de revoir et d'améliorer.
Actuellement, il existe deux programmes, un premier (grab) qui permet de récupérer une image provenant d'une caméra (768*576, niveau xde gris sur 8bits -> 256). Ce programme sauvegarde l'image récupérée dans un fichier .raw d'environ 450ko.
Le deuxième programme effectue un traitement sur cette image. Pour ce faire, il doit d'abord charger cette image. Or, le traitement (un truc mathématique) se fait sur des valeurs en float (nécessité d'avoir des nombres complexes etc...), et sur des images en 512*512 (en fait des matrices en 2^n, pour la rapidité).

Il existe donc une fonction (ci dessous) qui permet de charger l'image, la redimensionner, et "convertir les pixels en float".

Une partie de mon travail consiste à regrouper ces deux programmes de telle sorte que j'acquiert l'image de la caméra, je fais le traitement, et je l'affiche aussitôt.

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
 
float *chargement_image(int *IX,int *JY)
{
FILE *dfraw;                              /* descripteur fichier image        */
float *pixelfloat,*pimage;
unsigned char *pixel;
 
/********** allocation mémoires ******************************************/
 
pixelfloat=pimage=(float*)malloc((*IX)*(*JY)*sizeof(float));
pixel=(unsigned char*)malloc(sony_X*sony_Y);
 
/************** lecture de l'image dans pointeur pixel ************************/
 
dfraw=fopen(nom_raw,"rb");
fread(pixel,sony_X,sony_Y,dfraw);
 
/************** conversion image en 512*512 floats           ******************/
 
for(j=0;j<sony_Y;j++)
    {
    if(j<512)
    for(i=0;i<sony_X;i++)
      {
      if(i<512)
             {
             *pixelfloat=(float)(*pixel);
             pixelfloat++;
             }
      pixel++;
      }
    /***** sinon, on arrête la lecture de l'image  ***/
    }
fclose(dfraw);
return(pimage); /** renvoi de l'image en floats***/
 
}

Dans cette fonction, on lit tous les pixels provenant du fichier les uns après les autres au format "unsigned char" (logique car 8bits), et on les convertit en float (eventuellement : si ces pixels sont dans la plage des 512*512).
Le pointeur renvoyé est donc l'adresse à laquelle se trouve l'image, en floats.

Mon problème est le suivant. Puisque je n'enregistre plus l'image, je dois convertir en float directement ce qui me vient de la caméra ! or, cette chose est un type de données (MIL_ID spécifique à matrox) de 4octets qui contient 4 pixels. (par exemple, si je veux que mes 4 premiers pixels de mon image soient au niveau de gris 200, la première valeur 'MIL_ID' sera 0xc8c8c8c8).
Je dois donc récupérer chaque octet de ce type de variable, et le convertir en float (si j'ai bien compris, d'apres le bout de programme ci dessus, un float contient un pixel ?).

voilà, j'espere que j'ai été clair, n'hésitez pas à me poser des questions dans le cas contraire, je suis un peu dans la .... et à force j'arrive plus à rien !

Merci à vous !

[joellel]

je dois convertir en float directement ce qui me vient de la caméra ! or, cette chose est un type de données (MIL_ID spécifique à matrox) de 4octets qui contient 4 pixels. (par exemple, si je veux que mes 4 premiers pixels de mon image soient au niveau de gris 200, la première valeur 'MIL_ID' sera 0xc8c8c8c8).
Je dois donc récupérer chaque octet de ce type de variable, et le convertir en float

Je ne sais pas pour la conversion des images, mais la récupération de tes octets semble facile:

Code :

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

1
2
3
4
5
 
union {
MIL_ID typeMatrox;
unsigned char mesPixels[4];
} lu;

Tu recuperes ce qui vient de la camera dans lu.typeMatrox et tu fais une boucle de conversion de chacun de tes pixels: lu.mesPixels[i].
Ca c'est pour faire joli, car tu pourrait certainement récupérer directement tes pixels dans le tableau.

[ToTo13]

Bonjour,

lorsque je veux faire comme toi, je récupère la bibliothèque adaptée au type de fichier que je veux lire et je mets les fichiers lu dans une structure image qui me convient (en général des short, mais on peux les convertir en float).

[BenjaminLustrement]

Merci bien, je vais regarder tout ça !

[Pragmateek]

Pour le code:

Code :

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

pixelfloat=pimage=(float*)malloc((*IX)*(*JY)*sizeof(float));

Le cast n'est pas necessaire et on fait "sizeof" de l'élément pointé:

Code :

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

pixelfloat=pimage=malloc((*IX)*(*JY)*sizeof(*pimage));

L'ouverture correcte du fichier n'est pas vérifiée et "dfraw" n'est pas initialisé, comportement indéfini.

Code :

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

dfraw=fopen(nom_raw,"rb");

Code :

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

1
2
3
4
5
FILE *dfraw=NULL;
...
if(dfraw=fopen(nom_raw,"rb")){
...
}

[Pouic]

et "dfraw" n'est pas initialisé, comportement indéfini.

Code :

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

FILE *dfraw=NULL;

Non. C'est inutile.

[Pragmateek]

Non. C'est inutile.

Oui en effet vu que "fopen" renvoie "NULL" en cas d'échec.
C'est juste une bonne habitude d'initialiser les pointeurs à "NULL".

[NewbiZ]

Donc si j'ai bien compris on a cette situation :

Code :

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

1
2
3
4
5
 
typedef
struct {
   unsigned char pixels[4];
} MIL_ID;

Et tu disposes d'un

Code :

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

1
2
 
MIL_ID* image;

Et tu veux obtenir un

Code :

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

1
2
 
float* pixels;

Jusque là je ne me trompe pas ?
Bon, l'image de base fait 768x576 pixels, et chaque pixel est stoqué sur 1 octet, ces octets étant regroupés par 4 dans des structures MIL_ID, on a donc :
(768 * 576)/4 = 27648 structures MIL_ID dans notre tableau image ?
Et donc 768 * 576 = 442368 float dans notre tableau pixels ?
Donc on commence par déclarer pixels :

Code :

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

1
2
3
4
5
 
#define NBMIL_IF 27648
#define NBFLOAT 442368
float* pixels = NULL;
pixels = (float*)malloc(sizeof(float)*NBFLOAT);

Ensuite il faut remplir ce tableau, et la c'est plus embetant parceque les float et les unsigned char ne font pas la même taille. On pourrait faire une union, mais tant qu'à faire autant directement considérer image comme un tableau de char :

Code :

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

1
2
3
4
5
6
 
unsigned char* p = (unsigned char*)image;
for (int i=0; i<NBFLOAT; i++) // pour chaque élément de image
{
   pixels[i] = (float)p[i];
}