Discussion :

[BenjaminLustrement]

Bonjour à tous, je travaille sur un projet qui comprend une fonction qui permet de découper le centre d'une image passée en paramètre:

Code :

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

1
2
3
 
prototype :
float *retailler(int PetitX, int PetitY, int GrandX, int Grand Y, MIL_ID *Buffer);

Je passe en paramètre : les dimensions de l'image contenue dans buffer ainsi que les dimensions souhaitées.

Dans mon programme je suis amené à appeler souvent cette fonction (elle est dans une boucle. Pour faire simple : J'acquiert une image provenant d'une caméra, je découpe son centre, puis j'affiche le centre et je recommence).

Or, au bout de 3 fois, J'obtiens une erreur "Violation d'accès (0xc0000005) à l'adresse ....." de la part de Dr Watson (le pc sur lequel je travaille est un PII300 avec NT4)....

J'ai donc décortiqué le code de ma petite fonction, et je me suis aperçu que la ligne qui provoquait ce message etait en fait un malloc :

Code :

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

1
2
 
pixel = (unsigned char*)malloc(GrandX*GrandY*sizeof(unsigned char));

Je tiens à préciser que je le libère à la fin de ma fonction. En fait, ça marche... 2 fois seulement.

Si vous avez une idée de la cause de cette erreur, je suis preneur !

Merci beaucoup !


PS : J'ai en fait un paquet de problèmes très bizarres. Le PC a l'air hanté
A vrai dire, juste après le malloc, j'ai la ligne de code suivante :

Code :

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

1
2
 
pixel = (unsigned char*)Buffer;

L'adresse que le malloc a renvoyé ne me sert donc à rien ! vous trouvez ça stupide ? ouais... moi aussi, mais si je mets pas le malloc, le programme ne fonctionne plus... (pas d'erreur, mais il ne m'affiche pas mon image).

Je pense que les bibliothèques fournies avec la carte sur laquelle est branchée la caméra sont un peu ... pas bien...

[joellel]

Comment déclares tu pixel?

[BenjaminLustrement]

comme ça :

unsigned char *pixel;

[joellel]

Envoie ton code!

[BenjaminLustrement]

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
 
/******************************************************************************/
/*                   			retailler l'image                     */
/*----------------------------------------------------------------------------*/
/*    Fonction  : Fonction qui découpe l'image aux dimensions PetitX*PetitY   */
/*									      */
/*    Entrées : PetitX => Longueur de l'image après découpage			      */
/*              PetitY => Largeur de l'image après découpage			      */
/*              GrandX => Largeur de l'image avant découpage			      */
/*              GrandY => Largeur de l'image avant découpage			      */
/*              buf    => Tampon contenant l'image au format MIL_ID   		      */
/*    Sortie :  Pointeur (float) vers l'adresse contenant l'image   			      */
/*                                                                            */
/******************************************************************************/
 
float *retailler(int PetitX, int PetitY, int GrandX, int GrandY, MIL_ID *buf)
{
 
int deltaX;		//'Marges' quand la petite image est centrée sur la grande
int deltaY;
 
int i,j; 		//Indices de boucle
 
float *pixelfloat;		  			//Pointeur pour l'image en float
unsigned char *pixel,*pixel_i;   //Pointeur pour l'image en char
 
 
//Allocation de la mémoire pour les deux images
pixel = (unsigned char *)malloc(GrandX*GrandY);	//Cette ligne fait planter le prog !
pixel_i = pixel;             //pixel_i pour garder l'adresse initiale
pixelfloat = (float*)malloc(PetitX*PetitY*sizeof(float));
 
//on place la pointeur de char sur l'adresse de début de l'image en Mil_id
pixel = (unsigned char *)buf;   
 
//Calcul des marges
deltaX = (GrandX-PetitX)/2;
deltaY = (GrandY-PetitY)/2;
 
for(j=0;j<GrandY;j++)
{
    	for(i=0;i<GrandX;i++)
      {  //Si le pixel lu dans la grande image n'est pas dans les marges
      	if(i>=deltaX && i<(PetitX + deltaX) && j>=deltaY && j<(PetitY + deltaY))
         {
         	 //On l'ajoute à la petite image
             *pixelfloat = (float)*pixel;
             //On passe au pixel suivant sur la petite image
             pixelfloat++;
         }
         //Dans tous les cas, on doit lire le pixel suivant sur la grande image
         pixel++;
      }
}
 
//libération mémoire
free(pixel_i);
//Renvoi de l'image en 512*512 float
return(pixelfloat - PetitX*PetitY);
}

[joellel]

Pas évident...
As tu regardé les valeurs de GrandX et GrandY avant le malloc??
Teste aussi à chaque fois le code retour de ton malloc.