Discussion :

[olap75]

Bonjour ,

je cherche à résoudre le problème suivant, basique, que le traitement d'images:
je déclare deux structures, une structure pixel et une structure image comme suit :

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
struct pixel
  {
    int rouge;
    int vert;
    int bleu;
  };
 
struct image
  {
    int largeur;
    int hauteur;
    int maxval;
    struct pixel p[hauteur][largeur];
  };
 
struct image I;

le problème est que ca ne compile pas. à cause de la taille non définie du tableau de pixels p défini dans la structure image.
Or, je ne connais pas à l'avance la hauteur et la largeur del'image, elles dépendront de l'image saisie par l'utilisateur (scanf tout simple).

Je voudrais déclarer I en global, et définir la taille du tableau de pixels seulement une fois que l'utilisateur a saisi une image (alors je lis son entete pour connaitre la taille en pixels).

Je suis débutant en C.
Merci de me proposer une solution si ce problème vous inspire

[Obsidian]

La taille des variables et structures que tu définis est calculée à la compilation. Tu ne peux donc pas définir de manière formelle une structure dont la taille est directement fonction de la valeur d'un de ces membres.

Il faudra donc remplacer ton tableau par un pointeur que tu initialiseras à NULL et utiliser malloc() pour allouer de la mémoire au cas par cas. Tu déposeras alors le résultat de malloc() dans ce pointeur. Il faudra, bien sûr, penser à le vider ensuite.

[olap75]

j'ai modifié le code initial comme proposé par obsidian (cf ci-dessous).
Mais si je comprends bien, le pointeur peut être un tableau a une dimension. et I.p est un pointeur sur un tableau a une dimension de taille 6 (d'ailleurs il y a un moyen simple pour vérifier que la taille est bien égale à 6 ?). Or , je souhaitais un tableau a deux dimensions. j'aurais plutot envie d'écrire dans struct image:
struct pixel *p[largeur];
or largeur n'est pas défini... alors je peux écrire ceci : (?)
int *q;
struct pixel *p[*q]; ...par exemple... heu je crois que je vais aller dormir

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
struct pixel
  {
    int r;
    int v;
    int b;
  };
 
struct image
  {
    int largeur;
    int hauteur;
    int maxval;
    struct pixel *p
//   struct pixel p[hauteur][largeur]
  };
 
struct image I;
struct pixel pi;
 
I.hauteur=2;
I.largeur=3;
I.p = malloc(I.hauteur*I.largeur*sizeof(pi));

[jeroman]

http://c.developpez.com/faq/?page=al...LOC_tableau_2D

[olap75]

merci pour ces infos, j'avance, mais j'ai encore un petit souci :
voici mon code:

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
 
struct pixel
  {
    int r;
    int v;
    int b;
  };
 
struct image
  {
    int largeur;
    int hauteur;
    int maxval;
    struct pixel **p
//    struct pixel *p
//   struct pixel p[hauteur][largeur];
  };
 
struct image I;
struct pixel pi;
 
I.hauteur=2;
I.largeur=2;
 
int i;
struct pixel **p = malloc(I.hauteur * sizeof(pi));
for(i = 0; i < I.largeur; i++)
{
	p[i] = malloc(I.largeur * sizeof(pi));
}
I.p[1][1].r=3;

ca plante à I.p[1][1].r=3; j'ai le message d'erreur :
"Erreur de segmentation"

Quelle serait la bonne syntaxe ?

Merci !

[diogene]

Tu veux probablement faire quelque chose du genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
struct image I;
struct pixel pi;
I.hauteur=2;
I.largeur=2;
 
int i;
I.p = malloc(I.hauteur * sizeof &pi);
for(i = 0; i < I.hauteur; i++)
{
	I.p[i] = malloc(I.largeur * sizeof pi);
}
I.p[1][1].r=3;

[quetzacoatl]

As tu réservé tes tableaux ou dans le main(idem pour la libération)?
Poste plus de code pour qu'on puisse t'aider

[olap75]

Salut, merci pour ton message.

voici mon code :
en entrée, je donne un fichier image de type .pnm.
je récupère le nombre de pixels de l'image en largeur et hauteur.
je saisis également un entier taille_grille qui correspond à la taille de la grille. La grille est un élément qui passe sur l'image d'origine et transforme taille_grille * taille_grille pixels en un seul pixel (la moyenne des pixels de la grille). l'image transformée est l"image en sortie, dont le nom est saisi dans saisie_donnees. je ne peux pas joindre le fichier image sur lequel j'ai testé : bach.pnm (j'ai le messge d'erreur : fichier non valide). L4image fait 430 pixels sur 500.
le plantage intervient pour une grille de taille 11 * 11.

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
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
#include "stdio.h"
#include "stdlib.h"
 
char nom_fichier_in[40], nom_fichier_out[40];
int taille_grille;
int img_hauteur_in, img_largeur_in, img_maxval_in;
int img_hauteur_out, img_largeur_out, img_maxval_out;
int reste_largeur, reste_hauteur;
int division_largeur, division_hauteur;
 
 
struct pixel
  {
    int r;
    int v;
    int b;
  };
 
struct image
  {
    int largeur;
    int hauteur;
    int maxval;
    struct pixel **p		// pointeur sur un pointeur vers un pixel. 
//    struct pixel p[50][30];
  };
 
struct image I;
struct image J;
struct pixel pi;
 
 
struct pixel composition_pixel(int i, int j)
{
  int k,l;
  int nbre_pixels;
 
 
  struct pixel valeur;
  valeur.r=0;
  valeur.v=0;
  valeur.b=0;
 
  nbre_pixels=taille_grille * taille_grille;
  for (k=i; k<i+taille_grille; k++)
  {
    for (l=j; l<j+taille_grille; l++)
    {
		valeur.r = valeur.r + I.p[l][k].r;
		valeur.v = valeur.v + I.p[l][k].v;
		valeur.b = valeur.b + I.p[l][k].b;
    }
  }
  valeur.r=valeur.r / nbre_pixels;
  valeur.v=valeur.v / nbre_pixels;
  valeur.b=valeur.b / nbre_pixels;
 
  return valeur;
}
 
 
 
void calculs_modifications()
{
 
int reste_largeur_gauche, reste_largeur_droite, reste_hauteur_haut, reste_hauteur_bas;
int debut_ligne, debut_colonne, fin_ligne, fin_colonne;
int x, y;
int i, j;
 
printf("\nCALCUL_MODIFICATIONS\n");
printf("il reste %d colonnes a transformer sur %d colonnes\n",reste_largeur,I.largeur);
printf("il reste %d lignes a transformer sur %d lignes\n",reste_hauteur,I.hauteur);
 
reste_largeur_gauche=reste_largeur/2;
reste_largeur_droite=(reste_largeur/2)+(reste_largeur%2);
reste_hauteur_haut=reste_hauteur/2;
reste_hauteur_bas=(reste_hauteur/2)+(reste_hauteur%2);
 
J.hauteur=division_hauteur;
J.largeur=division_largeur;
J.maxval=I.maxval;
 
J.p = malloc(J.hauteur * sizeof(&pi));
for(i = 0; i < J.hauteur; i++)
{
	J.p[i] = malloc(J.largeur * sizeof(pi));
}
 
debut_ligne=reste_hauteur_haut;
debut_colonne=reste_largeur_gauche;
fin_ligne=I.hauteur-reste_hauteur_bas;
fin_colonne=I.largeur-reste_largeur_droite;
y=0;
x=0;
 
for(j=debut_ligne; j<fin_ligne; j=j+taille_grille)
{
	x=0;
	for(i=debut_colonne; i<fin_colonne+taille_grille; i=i+taille_grille)
	{
		J.p[y][x]=composition_pixel(i,j);
//printf("apres composition pixel, sur j:%d,i:%d, j'ai J.p[y][x].r=%d pour y=%d,x=%d\n",j,i,J.p[y][x].r,y,x);
		x++;		
	}
	y++;
}
printf("sortie MAJ J, y:%d, x:%d\n",y,x);
}
 
 
 
void choix_modification()
{
 
char choix_trt;
 
printf("\npour rappels on a :\n");
printf("nom_fichier:%s\n",nom_fichier_in);
printf("taille:%d\n",taille_grille);
printf("largeur:%d\n",I.largeur);
printf("hauteur:%d\n",I.hauteur);
printf("maxval:%d\n",I.maxval);
 
division_largeur=I.largeur/taille_grille;
division_hauteur=I.hauteur/taille_grille;
reste_largeur=I.largeur%taille_grille;
reste_hauteur=I.hauteur%taille_grille;
 
printf("il reste %d colonnes a transformer sur %d colonnes\n",reste_largeur,I.largeur);
printf("il reste %d lignes a transformer sur %d lignes\n",reste_hauteur,I.hauteur);
printf("il y a %d colonnes et %d lignes dans la nouvelle image si pas de trt du reste\n",division_largeur, division_hauteur);
 
}
 
 
void saisie_donnees()
{
 
printf("saisir le nom du fichier image en entrée:");
scanf("%s",nom_fichier_in);
 
printf("\nsaisir le nom du fichier image en sortiee:");
scanf("%s",nom_fichier_out);
 
printf("saisir la taille de la grille:");
scanf("%d",&taille_grille);
}
 
 
void lecture_fichier()
{
  char ch1, ch2;
  int i,j,k;
 
  FILE * fichier;
  fichier = fopen(nom_fichier_in, "r");
 
  fscanf(fichier,"%c",&ch1);
  fscanf(fichier,"%c",&ch2);
  fscanf(fichier,"%d",&(img_largeur_in));
  fscanf(fichier,"%d",&(img_hauteur_in));
  fscanf(fichier,"%d",&(img_maxval_in));
 
  I.largeur=img_largeur_in;
  I.hauteur=img_hauteur_in;
  I.maxval=img_maxval_in;
 
printf("avant manip **p,I.hauteur:%d,I.largeur:%d\n",I.hauteur,I.largeur);
printf("sizeof(pi):%d\n",sizeof(pi));
 	I.p = malloc(I.hauteur * sizeof(&pi));
printf("sizeof(I.p):%d, sizeof(&I.p):%d\n",sizeof(I.p),sizeof(&I.p));
	for(i = 0; i < I.hauteur; i++)
	{
		I.p[i] = malloc(I.largeur * sizeof(pi));
if (i>490) {printf("i:%d,I.p[i]:%d, sizeof(I.p[i]):%d\n",i,I.p[i],sizeof(I.p[i]));}
 
 
	}
 
printf("2 sizeof(I.p):%d, sizeof(&I.p):%d\n",sizeof(I.p),sizeof(&I.p));
 
 
  for (j=0; j < I.hauteur; j++)
  {
    for (i=0; i < I.largeur; i++)
    {
      fscanf(fichier,"%d\n",&(I.p[j][i].r));
      fscanf(fichier,"%d\n",&(I.p[j][i].v));
      fscanf(fichier,"%d\n",&(I.p[j][i].b));
    }
  }
  fclose(fichier);
 
  printf("FIN lecture_fichier, I.hauteur:%d,I.largeur:%d\n",I.hauteur,I.largeur);
}
 
 
void ecriture_fichier()
{
  int i,j;
 for(i = 0; i < I.hauteur; i++)
{
 
if (i>490) {printf("i:%d, I.hauteur:%d,I.p[i]:%d,sizeof(I.p[i]):%d\n",i,I.hauteur,I.p[i],sizeof(I.p[i]));}
	if (I.p[i] != NULL)
	{
	free(I.p[i]);
if (i>490) {printf("free OK\n");}
	}
}
 
printf("finfree1 I\n");
 
if (I.p != NULL)
{
	free(I.p);
}
 
printf("apres free I\n");
 
 
  FILE * fichier;
printf("apres FILE\n");
 
 
  fichier = fopen(nom_fichier_out, "w");
 
printf("apres ouverture fichier out\n");
 
 
  fprintf(fichier,"P3\n");
  fprintf(fichier,"%d %d\n",J.largeur,J.hauteur);
  fprintf(fichier,"%d \n",J.maxval);
 
printf("apres ecriture entete\n");  
 
  for (j=0; j < J.hauteur; j++)
  {
    for (i=0; i < J.largeur; i++)
    {
 //printf("ecriture fichier out, i:%d,j:%d, J.hauteur:%d,J.largeur:%d, r:%d\n",i,j,J.hauteur,J.largeur,J.p[j][i].r);
      fprintf(fichier,"%d\n",J.p[j][i].r);
      fprintf(fichier,"%d\n",J.p[j][i].v);
      fprintf(fichier,"%d\n",J.p[j][i].b);
    }
  }
 
printf("apres ecriture fichier out\n");  
 
/*
for(i = 0; i < J.hauteur; i++)
{
	if (J.p[i]!= NULL)
	{
	free(J.p[i]);
	}
}
 
if (J.p != NULL)
{
  free(J.p);
}
*/
  fclose(fichier);
  printf("fin ECRITURE\n");
 
}
 
 
void main()
{
saisie_donnees();
lecture_fichier();
choix_modification();
calculs_modifications();
ecriture_fichier();
}

[olap75]

il se passe un truc bizarre dans mon code que je ne comprends pas :
pour une grille de taille 20, lorsque je fais la boucle dans ecriture_fichier pour libérer de l'espace avec free, j'ai un plantage de type "Erreur de segmentation" dès i=0 : au niveau de free(I.p[0]);
j'ai regardé ce qu'il y avait dans I.p[0], j'ai trouvé la valeur 274. Or, après avoir fait malloc dans lecture_fichier sur I.p[0], et que j'interroge le contenu de I.p[0] par printf("I.p[0]:%d\n",I.p[0]), j'obtiens la valeur 145037640.

J'en déduis donc qu'à un moment donné, I.p[0] passe de 145037640 à 274. J'ai cherché l'endroit, j'ai mis des printf et j'ai trouvé que la modification s'effectue au retour de composition_pixel qui est appelée dans calcul_modifications:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
for(j=debut_ligne; j<fin_ligne; j=j+taille_grille)
{
if (j<50) {printf("dans boucle 1, I.p[0]:%d\n",I.p[0]);}
	x=0;
	for(i=debut_colonne; i<fin_colonne+taille_grille; i=i+taille_grille)
	{
if (j<50) {printf("avant composition_pixel, i:%d; j:%d; x:%d, y:%d, I.p[0]:%d\n",i,j,x,y,I.p[0]);}
	  J.p[y][x]=composition_pixel(i,j);
if (j<50) {printf("apres composition_pixel, i:%d; x:%d, y:%d, I.p[0]:%d\n",i,x,y,I.p[0]);}
		x++;		
	}
	y++;
}

j'ai également interrogé I.p[0] au début et à la fin de composition_pixel.
j'obtiens les messages :

avant composition_pixel, i:385; j:0; x:19, y:0, I.p[0]:161610056
apres composition_pixel, i:385; x:19, y:0, I.p[0]:161610056
avant composition_pixel, i:405; j:0; x:20, y:0, I.p[0]:161610056
apres composition_pixel, i:405; x:20, y:0, I.p[0]:161610056
avant composition_pixel, i:425; j:0; x:21, y:0, I.p[0]:161610056
Composition_pixel, I.p[0]:161610056
FIN Composition_pixel, I.p[0]:161610056
apres composition_pixel, i:425; x:21, y:0, I.p[0]:274
dans boucle 1, I.p[0]:274

J'en déduis donc que ce n'est pas dans composition_pixel que la modification de la valeur de I.p[0] a lieu, mais juste au retour de composition_pixel.
Je pense que cette modification de valeur est à l'origine de mon plantage dans ecriture_fichier (plus loin). Je ne comprends pas pourquoi j'ai ça. Quelqu'un peut-il m'aider ?
Merci