fclose et segmentation fault

Version imprimable

Bonjour,

Voilà, après deux jours de recherche sur ce forum et d'autre, je n'arrive pas à mettre la main sur ce bug bien embêtant.

Mon fichier lit un fichier ppm en entrée, parse quelques valeurs, la taille de l'image, sa profondeur et stocke le tout dans une matrice, mais lors de l'appel à fclose, le programme se plante.

J'ai essayé de comprendre les traces de valgrind, je soupçonne une mauvaise utilisation de ma structure mais je n'arrive pas à trouver d'exemple qui contredise l'utilisation que j'en fait.

Voilà le code source, la fonction incriminée est chargerImage

LirePPM.c

Code:

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include <stdlib.h>
#include <string.h>
 
#include "LirePPM.h"
#define TAILLE_MAX 70 /* spécification fichier ppm */
 
 
int chargerImage(char *nomFichier, Image *img) {
     FILE *fichier = NULL;
     char ligne[TAILLE_MAX];
     int tmp;
     int i, j;
 
     fichier = fopen(nomFichier, "r+");
 
     /* ouverture du fichier */
     if (fichier != NULL) {
 
	  /* récupération du nom de fichier */
	  fscanf(fichier, "%s", ligne);
	  if (strcmp(ligne, "P2") != 0) {
	       printf("Fichier non valide...\n");
	       exit(EXIT_FAILURE);
	  }
	  printf("Fichier valide...\n");
 
	  /* récupération dimension image */
	  while (fscanf(fichier, "%d %d", &img->nbColonnes, &img->nbLignes) != 2) {
	       fscanf(fichier, "%s", ligne);
	  }
	  printf("Chargement d'une image de %dx%d", img->nbLignes, img->nbColonnes);
 
	  /* récupération profondeur */
	  while (fscanf(fichier, "%d", &img->profondeur) != 1) {
	       fscanf(fichier, "%s", ligne);
	  }
	  printf(" de profondeur %d...\n", img->profondeur);
 
	  fclose(fichier);
 
 
 
	  /* Allocation de la matrice */
	  img->image = malloc(img->nbLignes * sizeof(img->image));
 
	  for(i = 0; i < img->nbLignes; i++)
	  {
	       img->image[i] = malloc(img->nbColonnes * sizeof(img->image[i]));
	  }
 
	  printf("Allocation image done...\n");
 
	  i = j = 0;
 
/*      /\* Récupération des valeurs du fichier *\/ */
/*      while((fscanf(fichier, "%d", &tmp)) != EOF)  */
/*      { */
/* 	  img->image[i][j] = tmp; */
/* 	  j++; */
 
/* 	  if (j == img->nbColonnes)  */
/* 	  { */
/* 	       i++; */
/* 	       j = 0; */
/* 	  } */
/*      } */
 
/* 	printf("Pointeur fichier : %x\n", fichier); */
 
/*      fclose(fichier); */
     }
 
     return 1; /* chargement du fichier OK */
}
 
 
void detruireImage(Image *img) {
     int i;
 
     for (i = 0; i < img->nbLignes; i++) {
	  free(img->image[i]);
	  img->image[i] = NULL;
     }
 
     free(img->image);
     img->image = NULL;
}
 
int ecrireImage(const Image *img, char *nomFichier) {
     int i, j;
     FILE *fichier = fopen(nomFichier, "a");
 
     /* vérification de l'existence d'une image */
     if(img == NULL) {
	  return 0;
     }
 
     /* erreur création du fichier */     
     if (!fichier)
     {
	  return 0;
     }
 
     /* écriture identifiant fichier */
     fprintf(fichier, "%s\n", "P2");
 
     /* ériture nombre lignes et colonnes */
     fprintf(fichier, "%d %d\n", img->nbColonnes, img->nbLignes);
 
     /* écriture profondeur fichier */
     fprintf(fichier, "%d\n", img->profondeur);
 
     /* écriture des valeurs du fichier */
     for (i = 0; i < img->nbLignes; i++) {
	  for (j = 0; j < img->nbColonnes; j++) {
	       fprintf(fichier, "%d\n", img->image[i][j]);
	  }
     }
 
     /* fermeture du fichier */
     fclose(fichier);
 
     /* écriture ok */
     return 1;
}
 
int main(int argc, char **argv) {
     Image *img;
     int retourChargerImage;
     if (argc >= 2)
     {
	  img = malloc(sizeof(img));
	  retourChargerImage = chargerImage(argv[1], img);
 
	  if (argc == 3) {
	       printf("Ecriture image dans : %s", argv[2]);
	       ecrireImage(img, argv[2]);
	  }
 
	  printf("Destruction image...");
 
	  detruireImage(img);
	  printf(" done.\n");
     }
 
 
     return 0;
}

LirePPM.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#ifndef __LIRE_PPM__
#define __LIRE_PPM__
 
#include <stdio.h>
 
 
typedef struct {
     int **image;
     int profondeur;
     int nbLignes;
     int nbColonnes;
} Image;
 
int chargerImage(char *nomFichier, Image *img);
 
void detruireImage(Image *img);
 
int ecrireImage(const Image *img, char *nomFichier);
#endif

Trace du valgrind
http://pastebin.com/m626a0c45

Merci de votre aide.

Harold

15/11/2008, 21h02
matafan

Dur de deviner où est le problème, mais il est possible qu'un de tes scanf déborde du tableau "ligne" et aille écraser "fichier". scanf est très dangereux avec %s puisqu'il n'y a aucun contrôle sur la taille des données lues.
15/11/2008, 22h31
thbkrshw

Ah c'est vrai, je n'ai pas précisé la syntaxe d'un fichier PPM. Je corrige ça tout de suite.

J'ai essayé ce que tu m'as conseillé matafan, c'était une bonne erreur que je n'avais pas vu, le fait d'utiliser fscanf avec %s, je l'ai donc remplacé par des fgets afin de sauter les lignes qui ne peuvent pas être lu.

J'ai malheureusement toujours les mêmes erreurs dans valgrind et le même core dump en lançant le programme normalement.

Fichier PPM :
Ligne d'entête avec chiffre magique P2
Puis : nbColonnes, nbLignes
Puis : profondeur
Puis le reste des valeurs de l'image.

Je vois pas vraiment comment bien parser un fichier texte de cette nature. Il y a tant de méthodes différentes...
15/11/2008, 23h31
crocodilex
Citation:
Envoyé par thbkrshw

Code:

1 2 3 4 5 6 7 int main(int argc, char **argv) { Image *img; [...] img = malloc(sizeof(img)); [...] return 0; }
Si tu veux allouer de la mémoire de la taille de ta structure, c'est plutôt comme cela :

Code:

img = malloc(sizeof(*img));

Et ne pas oublier que malloc peut échouer. Donc penses à vérifier la valeur retournée. Et bien entendu, ne pas oublier de libérer la mémoire quand tu en as plus besoin.

PS : Tu as le même problème avec tes autres malloc....

Citation:

Envoyé par thbkrshw

Voilà, après deux jours de recherche sur ce forum et d'autre, je n'arrive pas à mettre la main sur ce bug bien embêtant.

Mon fichier lit un fichier ppm en entrée, parse quelques valeurs, la taille de l'image, sa profondeur et stocke le tout dans une matrice, mais lors de l'appel à fclose, le programme se plante.

J'ai essayé de comprendre les traces de valgrind, je soupçonne une mauvaise utilisation de ma structure mais je n'arrive pas à trouver d'exemple qui contredise l'utilisation que j'en fait.

Voilà le code source, la fonction incriminée est chargerImage

Si on ne met pas la bonne ligne de commande, il est d'usage d'afficher le mode d'emploi minimum...

Code:

1
2
3
4
5
6
 
 
Usage appli nom-de-fichier
 
Process returned 0 (0x0)   execution time : 0.049 s
Press any key to continue.

Je ne sais pas ce qu'est un fichier ppm...

J'ai mis le nom d'un fichier qui n'existe pas et c'est le crash...

On devrait avoir ceci :

Code:

1
2
3
4
5
 
in.ppm: No such file or directory
 
Process returned 0 (0x0)   execution time : 0.037 s
Press any key to continue.

J'en suis là...

Code:

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define TAILLE_MAX 70           /* spécification fichier ppm */
 
typedef struct
{
   int **image;
   int profondeur;
   int nbLignes;
   int nbColonnes;
}
Image;
 
static int chargerImage (char *nomFichier, Image * img)
{
   int ok;
 
   FILE *fichier = fopen (nomFichier, "r");
 
   /* ouverture du fichier */
   if (fichier != NULL)
   {
      char ligne[TAILLE_MAX];
      int i, j;
 
      /* récupération du nom de fichier */
      fscanf (fichier, "%s", ligne);
      if (strcmp (ligne, "P2") != 0)
      {
         printf ("Fichier non valide...\n");
         exit (EXIT_FAILURE);
      }
      printf ("Fichier valide...\n");
 
      /* récupération dimension image */
      while (fscanf (fichier, "%d %d", &img->nbColonnes, &img->nbLignes) != 2)
      {
         fscanf (fichier, "%s", ligne);
      }
      printf ("Chargement d'une image de %dx%d", img->nbLignes,
              img->nbColonnes);
 
      /* récupération profondeur */
      while (fscanf (fichier, "%d", &img->profondeur) != 1)
      {
         fscanf (fichier, "%s", ligne);
      }
      printf (" de profondeur %d...\n", img->profondeur);
 
      fclose (fichier);
 
      /* Allocation de la matrice */
      img->image = malloc (img->nbLignes * sizeof (img->image));
 
      for (i = 0; i < img->nbLignes; i++)
      {
         img->image[i] = malloc (img->nbColonnes * sizeof (img->image[i]));
      }
 
      printf ("Allocation image done...\n");
 
      i = j = 0;
 
/*      /\* Récupération des valeurs du fichier *\/ */
/*      while((fscanf(fichier, "%d", &tmp)) != EOF)  */
/*      { */
/* 	  img->image[i][j] = tmp; */
/* 	  j++; */
 
/* 	  if (j == img->nbColonnes)  */
/* 	  { */
/* 	       i++; */
/* 	       j = 0; */
/* 	  } */
/*      } */
 
/* 	printf("Pointeur fichier : %x\n", fichier); */
 
/*      fclose(fichier); */
      ok = 1;
   }
 
   else
   {
      perror (nomFichier);
      ok = 0;
   }
 
   return ok;                   /* chargement du fichier OK */
}
 
static void detruireImage (Image * img)
{
   int i;
 
   for (i = 0; i < img->nbLignes; i++)
   {
      free (img->image[i]);
      img->image[i] = NULL;
   }
 
   free (img->image);
   img->image = NULL;
}
 
static int ecrireImage (const Image * img, char *nomFichier)
{
   int i, j;
   FILE *fichier = fopen (nomFichier, "w");
 
   /* vérification de l'existence d'une image */
   if (img == NULL)
   {
      return 0;
   }
 
   /* erreur création du fichier */
   if (fichier == NULL)
   {
      return 0;
   }
 
   /* écriture identifiant fichier */
   fprintf (fichier, "%s\n", "P2");
 
   /* ériture nombre lignes et colonnes */
   fprintf (fichier, "%d %d\n", img->nbColonnes, img->nbLignes);
 
   /* écriture profondeur fichier */
   fprintf (fichier, "%d\n", img->profondeur);
 
   /* écriture des valeurs du fichier */
   for (i = 0; i < img->nbLignes; i++)
   {
      for (j = 0; j < img->nbColonnes; j++)
      {
         fprintf (fichier, "%d\n", img->image[i][j]);
      }
   }
 
   /* fermeture du fichier */
   fclose (fichier);
 
   /* écriture ok */
   return 1;
}
 
static void usage (void)
{
   printf ("\nUsage appli nom-de-fichier\n");
}
 
int main (int argc, char **argv)
{
   if (argc >= 2)
   {
      Image *img = malloc (sizeof (img));
      int ok = chargerImage (argv[1], img);
 
      if (ok)
      {
         if (argc == 3)
         {
            printf ("Ecriture image dans : %s", argv[2]);
            ecrireImage (img, argv[2]);
         }
 
         printf ("Destruction image...");
 
         detruireImage (img);
         printf (" done.\n");
      }
 
   }
   else
   {
      usage ();
   }
   return 0;
}

Bonjour,

Merci pour tous vos conseils

@crocodilex : J'ai rajouté des tests à chaque malloc pour bien vérifier la valeur de retour. Il ne me reste plus qu'à faire une fonction pour tout ça plutôt que de dupliqer le code un peu partout.
J'ai lu récemment qu'il fallait mieux faire un malloc avec la variable afin d'éviter les erreurs lors d'un changement de type, mais comme j'ai tendance à m'emmeler les pinceaux avec les pointeurs en ce moment, j'ai préféré remettre les types là où je n'étais pas sur.

@Emmanuel Delahaye : J'ai rajouté un usage de la ligne de commande et des tests pour la vérification de la présence des fichiers, moins de risque d'erreur maintenant. Je reposte mes codes sources accompagnés d'un fichier ppm (image bitmap) de test.

J'ai relancé mon programme dans valgrind et je n'ai aucune erreur de mémoire non libérée : victoire \o/ !

LirePPM.c

Code:

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
 
#include <stdlib.h>
 
#include <string.h>
 
 
 
#include "LirePPM.h"
 
#define TAILLE_MAX 70 /* spécification fichier ppm */
 
 
 
 
 
int chargerImage(char *nomFichier, Image *img) {
 
     FILE *fichier = NULL;
 
     char ligne[TAILLE_MAX];
 
     int tmp;
 
     int i, j;
 
 
 
     fichier = fopen(nomFichier, "r+");
 
 
 
     /* ouverture du fichier */
 
     if (fichier != NULL) {
 
 
 
	  /* récupération du nom de fichier */
 
	  fscanf(fichier, "%s", ligne);
 
	  if (strcmp(ligne, "P2") != 0) {
 
	       printf("Fichier non valide...\n");
 
	       exit(EXIT_FAILURE);
 
	  }
 
	  printf("Fichier valide...\n");
 
 
 
	  /* récupération dimension image */
 
	  while (fscanf(fichier, "%d %d", &img->nbColonnes, &img->nbLignes) != 2) {
 
	       fgets(ligne, TAILLE_MAX, fichier);
 
	  }
 
	  printf("Chargement d'une image de %dx%d", img->nbLignes, img->nbColonnes);
 
 
 
	  /* récupération profondeur */
 
	  while (fscanf(fichier, "%d", &img->profondeur) != 1) {
 
	       fgets(ligne, TAILLE_MAX, fichier);
 
	  }
 
	  printf(" de profondeur %d...\n", img->profondeur);
 
 
 
 
 
	  /* Allocation de la matrice */
 
	  img->image = malloc(img->nbLignes * sizeof(int**));
 
	  if (img->image == NULL) {
 
	       fprintf(stderr, "%s:%d erreur d'allocation\n", __FILE__, __LINE__);
 
	       exit(EXIT_FAILURE);
 
	  }
 
 
 
	  for(i = 0; i < img->nbLignes; i++)
 
	  {
 
	       img->image[i] = malloc(img->nbColonnes * sizeof(int*));
 
 
 
	       if (img->image[i] == NULL) {
 
		    fprintf(stderr, "%s:%d erreur d'allocation\n", __FILE__, __LINE__);
 
		    exit(EXIT_FAILURE);
 
	       }
 
 
 
	  }
 
	  printf("Allocation image done...\n");
 
 
 
	  /* Récupération des valeurs du fichier */
 
	  i = j = 0;
 
 
 
	  while((fscanf(fichier, "%d", &tmp)) != EOF)
 
	  {
 
	       img->image[i][j] = tmp;
 
	       j++;
 
 
 
	       if (j == img->nbColonnes)
 
	       {
 
		    i++;
 
		    j = 0;
 
	       }
 
	  }
 
 
 
	  fclose(fichier);
 
     }
 
 
 
     return 1; /* chargement du fichier OK */
 
}
 
 
 
 
 
void detruireImage(Image *img) {
 
     int i;
 
 
 
     for (i = 0; i < img->nbLignes; i++) {
 
	  free(img->image[i]);
 
	  img->image[i] = NULL;
 
     }
 
 
 
     free(img->image);
 
     img->image = NULL;
 
}
 
 
 
int ecrireImage(const Image *img, char *nomFichier) {
 
     int i, j;
 
     FILE *fichier = fopen(nomFichier, "a");
 
 
 
     /* vérification de l'existence d'une image */
 
     if(img == NULL) {
 
	  exit(EXIT_FAILURE);
 
     }
 
 
 
     /* erreur création du fichier */     
 
     if (!fichier)
 
     {
 
	  fprintf(stderr, "erreur lors de la création du fichier %s\n", nomFichier);
 
	  exit(EXIT_FAILURE);
 
     }
 
 
 
     /* écriture identifiant fichier */
 
     fprintf(fichier, "%s\n", "P2");
 
 
 
     /* ériture nombre lignes et colonnes */
 
     fprintf(fichier, "%d %d\n", img->nbColonnes, img->nbLignes);
 
 
 
     /* écriture profondeur fichier */
 
     fprintf(fichier, "%d\n", img->profondeur);
 
 
 
     /* écriture des valeurs du fichier */
 
     for (i = 0; i < img->nbLignes; i++) {
 
	  for (j = 0; j < img->nbColonnes; j++) {
 
	       fprintf(fichier, "%d\n", img->image[i][j]);
 
	  }
 
     }
 
 
 
     /* fermeture du fichier */
 
     fclose(fichier);
 
 
 
     /* écriture ok */
 
     return 1;
 
}
 
 
 
void afficherUsage(char *nomProgramme) {
 
     fprintf(stderr, "Usage : %s fichierEntree.ppm [fichierSortie.ppm]\n", nomProgramme);
 
}
 
 
 
int fichierPresent(char *nomFichier) {
 
     FILE *fp = fopen(nomFichier, "r");
 
 
 
     if (fp == NULL) {
 
	  return 0;
 
     } else {
 
	  fclose(fp);
 
	  return 1;
 
     }
 
}
 
 
 
int main(int argc, char **argv) {
 
     Image *img = NULL;
 
     int retourChargerImage;
 
 
 
     if (argc >= 2)
 
     {
 
	  if (fichierPresent(argv[1])) {
 
	       img = malloc(sizeof(*img));
 
 
 
	       if (img == NULL) {
 
		    fprintf(stderr, "%s:%d erreur d'allocation\n", __FILE__, __LINE__);
 
		    exit(EXIT_FAILURE);
 
	       }
 
 
 
	       retourChargerImage = chargerImage(argv[1], img);
 
 
 
	       if (retourChargerImage) {
 
		    if (argc == 3) {
 
			 printf("Ecriture image dans : %s", argv[2]);
 
			 ecrireImage(img, argv[2]);
 
		    }
 
		    detruireImage(img);
 
	       }
 
	       free(img);
 
	  }
 
     } else {
 
	  afficherUsage(argv[0]);
 
     }
 
 
 
     return 0;
 
}

LirePPM.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#ifndef __LIRE_PPM__
#define __LIRE_PPM__
 
#include <stdio.h>
 
 
typedef struct {
     int **image;
     int profondeur;
     int nbLignes;
     int nbColonnes;
} Image;
 
int chargerImage(char *nomFichier, Image *img);
 
void detruireImage(Image *img);
 
int ecrireImage(const Image *img, char *nomFichier);
 
int fichierPresent(char *nomFichier);
 
void afficherUsage(char *nomProgramme);
#endif

test.ppm

Code:

1
2
3
4
5
6
7
8
 
P2
10 4
255
1 10 20 30 40 50 60 70 80 90
1 10 20 30 40 50 60 70 80 90
1 10 20 30 40 50 60 70 80 90
1 10 20 30 40 50 60 70 80 90

Citation:

Envoyé par thbkrshw

J'ai relancé mon programme dans valgrind et je n'ai aucune erreur de mémoire non libérée : victoire \o/ !

test.ppm

Code:

1
2
3
4
5
6
7
8
 
P2
10 4
255
1 10 20 30 40 50 60 70 80 90
1 10 20 30 40 50 60 70 80 90
1 10 20 30 40 50 60 70 80 90
1 10 20 30 40 50 60 70 80 90

Avec ce code :

Code:

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
 
/* http://emmanuel-delahaye.developpez.com/clib.htm */
#include "ed/inc/prt.h"
 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
typedef struct
{
   int **image;
   int profondeur;
   int nbLignes;
   int nbColonnes;
}
Image;
 
#define TAILLE_MAX 70           /* spécification fichier ppm */
 
static void detruireImage (Image * img)
{
   int i;
 
   for (i = 0; i < img->nbLignes; i++)
   {
      free (img->image[i]);
      img->image[i] = NULL;
   }
   free (img->image);
   img->image = NULL;
}
 
static int chargerImage (char const *nomFichier, Image * img)
{
   int ok;
 
   /* ouverture du fichier */
   FILE *fichier = fopen (nomFichier, "r");
   if (fichier != NULL)
   {
      char ligne[TAILLE_MAX];
 
      /* récupération du nom de fichier */
      fscanf (fichier, "%s", ligne);
 
      if (strcmp (ligne, "P2") != 0)
      {
         printf ("Fichier non valide...\n");
         ok = 0;
      }
      else
      {
         printf ("Fichier valide...\n");
 
         /* récupération dimension image */
 
         while (fscanf (fichier, "%d %d", &img->nbColonnes, &img->nbLignes) !=
                2)
         {
            fgets (ligne, TAILLE_MAX, fichier);
         }
 
         printf ("Chargement d'une image de %dx%d", img->nbLignes,
                 img->nbColonnes);
 
         /* récupération profondeur */
 
         while (fscanf (fichier, "%d", &img->profondeur) != 1)
         {
            fgets (ligne, TAILLE_MAX, fichier);
         }
 
         printf (" de profondeur %d...\n", img->profondeur);
 
         /* Allocation de la matrice */
 
         img->image = malloc (img->nbLignes * sizeof (int **));
 
         if (img->image != NULL)
         {
            ok = 1;
            {
               int i;
               for (i = 0; i < img->nbLignes; i++)
               {
                  img->image[i] = malloc (img->nbColonnes * sizeof (int *));
 
                  if (img->image[i] == NULL)
                  {
                     fprintf (stderr, "%s:%d erreur d'allocation\n", __FILE__,
                              __LINE__);
                     ok = 0;
                  }
               }
            }
 
            if (ok)
            {
               printf ("Allocation image reussie...\n");
 
               /* Récupération des valeurs du fichier */
               {
                  int i = 0;
                  int j = 0;
                  int tmp;
                  while ((fscanf (fichier, "%d", &tmp)) != EOF)
                  {
                     img->image[i][j] = tmp;
                     j++;
                     if (j == img->nbColonnes)
                     {
                        i++;
                        j = 0;
                     }
                  }
               }
            }
            else
            {
               detruireImage (img);
            }
         }
         else
         {
            fprintf (stderr, "%s:%d erreur d'allocation\n", __FILE__,
                     __LINE__);
            ok = 0;
         }
      }
      fclose (fichier);
   }
   else
   {
      perror (nomFichier);
      ok = 0;
   }
   return ok;                   /* chargement du fichier OK */
 
}
 
static int ecrireImage (const Image * img, char const *nomFichier)
{
   int ok;
 
   /* vérification de l'existence d'une image */
   if (img != NULL && img->image != NULL)
   {
      FILE *fichier = fopen (nomFichier, "w");
 
      /* erreur création du fichier */
      if (fichier != NULL)
      {
         /* écriture identifiant fichier */
         fprintf (fichier, "%s\n", "P2");
         /* ériture nombre lignes et colonnes */
         fprintf (fichier, "%d %d\n", img->nbColonnes, img->nbLignes);
         /* écriture profondeur fichier */
         fprintf (fichier, "%d\n", img->profondeur);
         /* écriture des valeurs du fichier */
         {
            int i;
            for (i = 0; i < img->nbLignes; i++)
            {
               int j;
               for (j = 0; j < img->nbColonnes; j++)
               {
                  fprintf (fichier, "%d\n", img->image[i][j]);
               }
            }
         }
         /* fermeture du fichier */
         fclose (fichier);
         /* écriture ok */
         ok=1;
      }
      else
      {
         fprintf (stderr, "erreur lors de la création du fichier %s\n",
                  nomFichier);
         ok = 0;
      }
   }
   else
   {
         fprintf (stderr, "image non cree\n");
      ok = 0;
   }
 
   return ok;
}
 
static void afficherUsage (char const *nomProgramme)
{
   fprintf (stderr, "Usage : %s fichierEntree.ppm [fichierSortie.ppm]\n",
            nomProgramme);
}
 
static void afficherImage (Image const *img)
{
   PRT_I (img->profondeur);
   PRT_I (img->nbLignes);
   PRT_I (img->nbColonnes);
 
   {
      int lin;
      for (lin = 0; lin < img->nbLignes; lin++)
      {
         int col;
         for (col = 0; col < img->nbColonnes; col++)
         {
            printf ("%3d", img->image[lin][col]);
         }
         printf ("\n");
      }
   }
}
 
int main (int argc, char **argv)
{
   int ret;
   if (argc >= 2)
   {
      Image *img = malloc (sizeof (*img));
 
      if (img != NULL)
      {
         int ok = chargerImage (argv[1], img);
 
         if (ok)
         {
            afficherImage (img);
 
            if (argc == 3)
            {
               printf ("Ecriture image dans : %s", argv[2]);
               ecrireImage (img, argv[2]);
            }
            detruireImage (img);
         }
         free (img);
         ret = EXIT_SUCCESS;
      }
      else
      {
         fprintf (stderr, "%s:%d erreur d'allocation\n", __FILE__, __LINE__);
         ret = EXIT_FAILURE;
      }
   }
   else
   {
      afficherUsage (argv[0]);
      ret = EXIT_FAILURE;
   }
 
   return ret;
 
}

et ce fichier de données, j'obtiens :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Fichier valide...
Chargement d'une image de 4x10 de profondeur 255...
Allocation image reussie...
img->profondeur = 255
img->nbLignes = 4
img->nbColonnes = 10
  1 10 20 30 40 50 60 70 80 90
  1 10 20 30 40 50 60 70 80 90
  1 10 20 30 40 50 60 70 80 90
  1 10 20 30 40 50 60 70 80 90
Ecriture image dans : out.ppm
Process returned 0 (0x0)   execution time : 0.041 s
Press any key to continue.

Code:

C'est ce que tu voulais ?

16/11/2008, 17h17
thbkrshw

Oui, oui pas de problème pour le fichier obtenu, la norme indique seulement qu'une ligne ne doit pas dépasser 70 caractères et que le séparateur utlisé peut être au choix l'espace ou le saut de ligne.
16/11/2008, 19h05
Emmanuel Delahaye

Citation:

Envoyé par thbkrshw

Oui, oui pas de problème pour le fichier obtenu, la norme indique seulement qu'une ligne ne doit pas dépasser 70 caractères

Alors le tableau de char qui reçoit une ligne devrait faire au moins 72 caractères (70 utiles + 1 pour le \n et 1 pour le 0)

Citation:

et que le séparateur utlisé peut être au choix l'espace ou le saut de ligne.

Le séparateur '\n' vient de ton code originel.
18/11/2008, 12h38
thbkrshw

Citation:

Envoyé par Emmanuel Delahaye

Alors le tableau de char qui reçoit une ligne devrait faire au moins 72 caractères (70 utiles + 1 pour le \n et 1 pour le 0)
Le séparateur '\n' vient de ton code originel.

Ah oui, bien vu pour le tableau de char, je corrige ça tout de suite.

Le séparateur \n vient bien de mon code, dans le but de simplifier le code et ne pas avoir à gérer le saut à la ligne en comptant les caractères :D.

En tout cas merci de ton aide, ça m'a permis de bien avancer.