Discussion :

[highdesign]

Bonjour à tous,

c'est mon premier message sur Developpez.net donc je ne sais pas trop comment ça se passe ^^

J'ai un problème sur une petit programme, je doit lire une image.pgm et la retranscrire en changeant certaine valeur.

Le problème est que je débute en C (Je suis orienté vers .Net qui est somme doute différent ^^) et la philosophie de ce langage m'est un peu difficile a comprendre

Donc pour l'instant j'arrive a lire l’entête (Mon fichier est en p6) mais le reste des pixels étant en binaires, je n'arrive pas a le lire !

Si vos âmes charitables sont capable de m'aider, je vous en serait très reconnaissant ^^

(EDIT: Je dois passer exclusivement par C (Pas de C++) )
Le 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
32
33
34
35
36
37
38
39
40
41
 
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
// Fonction Main
int _tmain(int argc, _TCHAR* argv[])
{
	// Définitions des variables
	unsigned char x[3];
	char *chemin =(char*) malloc(255 * sizeof(char));
 
	FILE* descr;
	strcpy(chemin,"monCheminAbsolue/test.pgm");
 
	printf("Chemin du fichier: %s \n",chemin);
 
	// Ouverture du fichier
	if(descr = fopen(chemin,"r+b"))
	{
		printf("Le fichier est ouvert \n");
		while(!feof(descr))
		{
				fscanf(descr,"%s",x);
				printf("Valeur: %s \n",x);
		}
 
	}
	else
	{
		printf("non ouvert \n");
	}
 
 
 
	getchar();
	// system("pause");
	return 0;
}

[Bousk]

Bonjour,

voici un lien indiquant la spec du format
http://netpbm.sourceforge.net/doc/pgm.html
ou http://users.wpi.edu/~cfurlong/me-593n/pgmimage.html
Les données peuvent être en plain text ou binaire apparemment.

Commence par lire le header, la suite devrait venir toute seule.

[highdesign]

Merci pour la réponse, en faite, j'arrive déjà a lire le header mon fichier est en P6 (De p1 a p3 tu as du texte, de P4 a P6 du binaire) je doit pouvoir gérer n'importe quel type en faite

EDIT: Mon programme me renvoi bien l’entête, mais n'arrive pas a lire le binaire CV image:

http://imageshack.us/f/14/capturepbb.png/

[Bktero]

Première remarque : l'utilisation de foef() --> http://c.developpez.com/faq/index.ph...eneral#ES_feof

Ensuite sur la lecture :

• fscanf cherche a récupérer une chaine de caractères
• lors de l'en-tête ASCII, il doit y arriver
• lors du passage à la partie binaire, cela ne doit plus marcher
• pour le vérifier, il faut tester la valeur retour de la fonction --> http://man.developpez.com/man3/fscanf.3.php
• je mettrai un bemol sur l'utilisation de scanf et un buffer de 3 : si la chaine est plus grande, on n'écrit à des emplacements qui ne nous "appartiennent" pas. Voir la rubrique BOGUE sur la page de manuel :
  

  La conversion %s devrait toujours être accompagnée d'une longueur maximale de chaîne de caractères. En effet, il existe un risque de débordement de buffer, qui peut conduire à un trou de sécurité important dans un programme Set-UID ou Set-GID.

[highdesign]

Merci pour les pistes, comment peut-tu lire du binaire avec un fscanf?


J'ai corrigé le code avec tes indications, en revanche la partie binaire n'est pas lu, mon fscanf lit du texte non du binaire, est il possible de lire plusieurs format avec un seul fscanf?

Sachant que je j'ai lu, je ne sais plus ou que fopen() en mode "r+b" correspondait binaire.

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
 
 
// Chargement des librairies
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
// Fonction Main
int _tmain(int argc, _TCHAR* argv[])
{
	// Définitions des variables
	unsigned char x[3];
	char *chemin =(char*) malloc(255 * sizeof(char));
 
 
	strcpy(chemin,"C:/Users/Hdes/Desktop/test.pgm");
	FILE* descr = fopen(chemin,"r+b");
 
	printf("Chemin du fichier: %s \n",chemin);
 
	if (descr == NULL)
	{
       printf("La fonction fopen a echoue.\n");
	}
	else
    {
		int c;
        long taille = 0;
 
        while ((c = fgetc(descr)) != EOF)
        {
			fscanf(descr,"%s",x);
			printf("Valeur: %s \n",x);
            taille++;
        }
 
        if (feof(descr))
        {
            printf("Fin de fichier atteinte !\n");
            printf("La taille du fichier est : %ld octets.\n", taille);
        }
        else
        {
            if (ferror(descr))
                printf("Arret du programme en raison d'une erreur de lecture !\n");
        }
	}
 
	getchar();
	return 0;
}

[Bktero]

Je présume que tes nombres sont stockées sur 8 bits. Cela correspond à un objet de type char, ce qui correspond à un format %c.

[highdesign]

On avance, on avance !^^

En mettant en %c je récupère le même caractère pour toutes mes valeurs... mais a chaque fois que je re-compile ce caractère change...


EDIT: Voila quelques impressions d'écran pour imager.


Ce à quoi ressemble mon image(Sous notepadd++) :

http://imageshack.us/f/692/capture3xb.png/

Ce que fais mon programme avec les ¨%s:

http://imageshack.us/f/96/capturelke.png/
donc j'ai bien mon header...

Ce que fais mon programme avec les %c

http://imageshack.us/f/42/capture2yg.png/
sachant qu'a chaque compilation la valeur change

[Bktero]

Ast-tu utiliser le format %c pour afficher les valeurs binaires ? Le format %c interprète les 8 bits comme un caractère ASCII et ne te donnent pas forcément une valeur affichable. Le fait que la valeur soit tout le temps la même peut venir du fait que ta mémoire est initialiser à une valeur donnée et que tu ne modifies pas la mémoire.

[highdesign]

Voila le 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
// Chargement des librairies
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
// Fonction Main
int _tmain(int argc, _TCHAR* argv[])
{
	// Définitions des variables
	signed char x[3];
	char *chemin =(char*) malloc(255 * sizeof(char));
 
	strcpy(chemin,"C:/Users/Hdes/Desktop/test.pgm");
	FILE* descr = fopen(chemin,"r+b");
 
	printf("Chemin du fichier: %s \n",chemin);
 
	if (descr == NULL)
	{
       printf("La fonction fopen a echoue.\n");
	}
	else
    {
		int c;
        long taille = 0;
 
        while ((c = fgetc(descr)) != EOF)
        {
			fscanf(descr,"%c",x);
			printf("Valeur: %c \n",x);
            taille++;
        }
 
        if (feof(descr))
        {
            printf("Fin de fichier atteinte !\n");
            printf("La taille du fichier est : %ld octets.\n", taille);
        }
        else
        {
            if (ferror(descr))
                printf("Arret du programme en raison d'une erreur de lecture !\n");
        }
	}
 
	getchar();
	return 0;
}

Les histoire de mémoire et co' ça deviens compliqué la ^^ Je débute vraiment en C donc j'ai pas encore la philosophie ... Vb.net est quand même plus simple ^^ et Php même si il en descend n'as pas autant de contrainte

[Bousk]

Il y a un truc qui me gène dans ce format et que tu ne sembles pas avoir pris en compte :

Each pixel in the raster has white space before and after it. There must be at least one character of white space between any two pixels, but there is no maximum.

Donc tu ne peux pas lire directement la valeur du pixel, puisqu'il s'agit potentiellement d'un blanc qu'il faut sauter.

Code :

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

1
2
3
4
5
6
7
8
char getNextPixel(File* file)
{
 char px;
 do {
  fread(&px, sizeof(char), 1, file);
 } while (px == ' ' || px == '\n');
 return px;
}

devrait être capable de skipper les blanc, je suis moins sûr pour la fin de ligne (\n ou \r\n ou ..?).

[highdesign]

Je suis pas sur d'avoir compris, tu voudrais dire que le format serait:

" 1 0 1 0 1 1 0 0 1 0 1 0"?

Par contre je viens de me poser une question... ma fonction récupère le contenu du fichier ligne par ligne, et au final la limite de 3caractère peu faire flanché le tout car on arrive a une ligne qui contient X caractère car tout le binaire est sur la même ligne?

[Bktero]

Tu ne confondrais pas bit et pixel ?

Je t'ai fait remarqué la possibilité de dépassement...

Pourrais-tu transmettre ton fichier image stp ? Je suis curieux de voir le contenu.

[highdesign]

Y'a des chances... Je maîtrise pas du tout le sujet sur lequel je travail, et j'ai eu aucune explication, donc j'essaie de comprendre petit a petit désolé, en effet tu m'avais fais la remarque mais je n'avais pas compris exactement pourquoi.

Voila l'image:

http://www.gigaup.fr/?g=UFOC15ANII

(Sa correspond juste a une image noir de 10px*10px codé en P6(Photoshop ne m'a pas permit de choisir le format...))

[Bktero]

On va reprendre depuis le début alors

La mémoire est un champ de bits, des 0 et/ou des 1. On regroupe les bits pour former des entités plus grosses, notamment des octets qui en contiennent 8. Généralement, un octet = un byte. En C, chaque objet correspond à un certain nombre d'octets. Un char est toujours d'un octet. Un int est généralement de 4 octets, soit 32 bits, sur une machine 32 bits. Dans ton cas, les valeurs des pixels semblent comprises entre 0 et 255, donc 8 bits suffisent pour coder un pixel (2^8 - 1). Tu peux donc utiliser un char, qui fait 8 bits, pour stocker un pixel.

Parlons de ton programme. Que souhaites-tu faire ? Simplement lire cette image en particulier ou faire un lecteur robuste de fichiers pgm ? Dans le premier cas, l'algorithme est simple ; dans le second, ça se complique. Au-delà de ta méconnaissance du C, ce qui est normal quand on débute, tu ne sembles pas avoir tirer au clair ce que tu souhaites faire.

[highdesign]

En faite pour faire simple, le sujet m'a été donné sans plus d'explication par un tiers

C'est sympa de ta part s de t'y attarder !

Donc au final:

Dans un premier temps je dois ouvrir un fichier PGM en récupérer les infos pour en faire une "copie"

Dans un seconde temps il faudra modifier la structure pour changer les propriété de l'image.

CJ le sujet:

http://imageshack.us/f/814/scn0011u.jpg/

Sur le fond ça n'a pas l'air si dur que ça, sur la forme c'est autre chose ^^

Les seul infos qu'on m'a donné sont sur le format de l’entête

P1 pour une image en noir et blanc codée en texte
P2 pour une image en niveau de gris codée en texte
P3 pour une image couleur codée en texte

P4 pour une image en noir et blanc codée en binaire
P5 pour une image en niveau de gris codée en binaire
P6 pour une image couleur codée en binaire

mon image est en P6

[Bousk]

Je suis pas sur d'avoir compris, tu voudrais dire que le format serait:

" 1 0 1 0 1 1 0 0 1 0 1 0"?

Par contre je viens de me poser une question... ma fonction récupère le contenu du fichier ligne par ligne, et au final la limite de 3caractère peu faire flanché le tout car on arrive a une ligne qui contient X caractère car tout le binaire est sur la même ligne?

Je t'ai indiqué 2 liens qui donnent les explications sur le format de fichier.
En voilà un 3° qui indique plus spécifiquement le P6 : http://netpbm.sourceforge.net/doc/ppm.html
Apparemment les espaces ne sont présents que dans le style text plain. Ce qui est logique, et en binaire les éléments sont des bytes contigus.
Les bytes sont lus de gauche à droite et de haut en bas.

P6 indique que le fichier est en binaire, et il suit ce format

Each PPM image consists of the following:

A "magic number" for identifying the file type. A ppm image's magic number is the two characters "P6".
Whitespace (blanks, TABs, CRs, LFs).
A width, formatted as ASCII characters in decimal.
Whitespace.
A height, again in ASCII decimal.
Whitespace.
The maximum color value (Maxval), again in ASCII decimal. Must be less than 65536 and more than zero.
A single whitespace character (usually a newline).
A raster of Height rows, in order from top to bottom. Each row consists of Width pixels, in order from left to right. Each pixel is a triplet of red, green, and blue samples, in that order. Each sample is represented in pure binary by either 1 or 2 bytes. If the Maxval is less than 256, it is 1 byte. Otherwise, it is 2 bytes. The most significant byte is first.

Selon maxval, les pixels seront codés sur 1 ou 2 bytes. Dans ce dernier cas, le MSB est en premier on est en big endian.

Un des liens indique même une libnetbpm pour lire ces fichiers.

[Bktero]

Parce que le sujet m'intéressait, j'ai fait un programme qui lit ton image. Il est loin d'être parfait (buffer avec des grandes tailles, des risques de dépassement, des non-vérifications de fonctions de conversion, ne gère que le cas des données sur 1 octet...) et ne répond pas complètement au sujet. Il devrait te donner une bonne base pour commencer.

Mon approche est de d'abord lire l'en-tête, en mode texte, et de stocker tout ça dans une structure. Ensuite, je réouvre le fichier en mode binaire et je vais directement à la partie binaire. Je la lis et je l'affiche.

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
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
 
#define BUFFER_SIZE 10000
 
void errno_and_quit(void)
{
    fprintf(stdin, "Errno = [%d] = [%s]\n", errno, strerror(errno));
    exit(EXIT_FAILURE);
}
 
typedef enum
{
    P1, P2, P3, P4, P5, P6, INVALID
} PGM_TYPE_t;
 
typedef struct
{
    char chemin[BUFFER_SIZE];
    PGM_TYPE_t type;
    int hauteur;
    int largeur;
    int valeurMax;
} PGM_HEADER_t;
 
PGM_TYPE_t PGM_strtotype(char *str)
{
    if(strlen(str)!=2 || str[0]!='P')
    {
        puts("Chaine invalide");
        return (PGM_TYPE_t) INVALID;
    }
 
    switch(str[1])
    {
        case '1':
            return (PGM_TYPE_t) P1;
        case '2':
            return (PGM_TYPE_t) P2;
        case '3':
            return (PGM_TYPE_t) P3;
        case '4':
            return (PGM_TYPE_t) P4;
        case '5':
            return (PGM_TYPE_t) P5;
        case '6':
            return (PGM_TYPE_t) P6;
        default:
            return (PGM_TYPE_t) INVALID;
    }
}
 
void PGM_print(PGM_HEADER_t entete)
{
    printf("Chemin : %s\n", entete.chemin);
    printf("Type : %d\n", entete.type+1);
    printf("Hauteur : %d\n", entete.hauteur);
    printf("Largeur : %d\n", entete.largeur);
    printf("ValeurMax : %d\n", entete.valeurMax);
}
 
PGM_HEADER_t PGM_getHeader(const char* cheminFichier)
{
    char buffer[BUFFER_SIZE] = {0};
    PGM_HEADER_t entete;
    FILE * fichier = fopen(cheminFichier,"r");
 
    if(fichier == NULL)
    {
        puts("Fichier impossible a ouvrir");
        errno_and_quit();
    }
 
    // Sauvegarder chemin
    strcpy(entete.chemin, cheminFichier);
 
    // Recuperation en-tete
    if( (fgets(buffer, BUFFER_SIZE-1, fichier)) == NULL)
    {
        puts("Lecture impossible");
        errno_and_quit();
    }
    buffer[2]=0; // supprimer '\n' de fin
    entete.type = PGM_strtotype(buffer);
 
    if( (fgets(buffer, BUFFER_SIZE-1, fichier)) == NULL)
    {
        puts("Lecture impossible");
        errno_and_quit();
    }
    entete.hauteur = strtol(buffer, NULL, 10);
 
    if( (fgets(buffer, BUFFER_SIZE-1, fichier)) == NULL)
    {
        puts("Lecture impossible");
        errno_and_quit();
    }
    entete.largeur = strtol(buffer, NULL, 10);
 
    if( (fgets(buffer, BUFFER_SIZE-1, fichier)) == NULL)
    {
        puts("Lecture impossible");
        errno_and_quit();
    }
    entete.valeurMax = strtol(buffer, NULL, 10);
 
    fclose(fichier);
    return entete;
}
 
 
 
void PGM_getData(PGM_HEADER_t entete)
{
    FILE *fichier = fopen(entete.chemin,"rb");
    //char buffer[BUFFER_SIZE] = {0};
    int i=0; // indice des lignes
    char j=0; // indice des colonnes
    char image[entete.largeur][entete.hauteur];
 
    // Skipper l'en-tete
    while(i!=4)
    {
        fscanf(fichier, "%c", &j);
        if(j=='\n')
        {
            i++;
            puts("Nouvelle ligne");
        }
    }
 
    // Lecture de l'image
    for(i=0;i<entete.hauteur;i++)
    {
        for(j=0;j<entete.largeur;j++)
        {
            fscanf(fichier, "%c", &(image[i][j]) );
        }
    }
 
    // Lire l'image
    for(i=0;i<entete.hauteur;i++)
    {
        for(j=0;j<entete.largeur;j++)
        {
            printf("%d", (int)image[i][j]);
        }
        printf("\n");
    }
 
    fclose(fichier);
}
 
 
 
int main(void)
{
    const char cheminFichier[] = "/home/pierre/test.pgm";
    PGM_HEADER_t entete = PGM_getHeader(cheminFichier);
    PGM_print(entete);
 
    puts("GetData");
    PGM_getData(entete);
    return 0;
}

Je ne sais pas qui est Elodie mais c'est sympa de ta part de coder un tel projet dans un langage que tu ne connais pas. ^^

[highdesign]

C'est une amie C'est d'autant plus sympa à toi de m'aider ! En effet ça risque de m’être plus que grandement utile ! c'est vraiment sympa de toute façon il faut bien que je mette au C ! Vb.net et Php/JavaScript/Ajax/Jquery c'est loin d’être suffisant sur un CV J'ai plus qu'à me mettre au boulot ^^ encore mille merci !

[Bktero]

J'ai retravaillé un peu dessus :

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
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
 
#define BUFFER_SIZE 10000
 
void errno_and_quit(const char* message)
{
    fprintf(stdin, "Erreur = %s", message);
    fprintf(stdin, "Errno = [%d] = [%s]\n", errno, strerror(errno));
    exit(EXIT_FAILURE);
}
 
 
typedef enum
{
    P1, P2, P3, P4, P5, P6, INVALID
} PGM_TYPE_t;
 
 
typedef struct
{
    char chemin[BUFFER_SIZE];
    PGM_TYPE_t type;
    int hauteur;
    int largeur;
    int valeurMax;
} PGM_HEADER_t;
 
 
typedef struct
{
    PGM_HEADER_t entete;
    int **donnees;
} PGM_IMAGE_t;
 
 
PGM_TYPE_t PGM_strtotype(char *str)
{
    if(strlen(str)!=2 || str[0]!='P')
    {
        puts("Chaine invalide");
        return (PGM_TYPE_t) INVALID;
    }
 
    switch(str[1])
    {
        case '1':
            return (PGM_TYPE_t) P1;
        case '2':
            return (PGM_TYPE_t) P2;
        case '3':
            return (PGM_TYPE_t) P3;
        case '4':
            return (PGM_TYPE_t) P4;
        case '5':
            return (PGM_TYPE_t) P5;
        case '6':
            return (PGM_TYPE_t) P6;
        default:
            return (PGM_TYPE_t) INVALID;
    }
}
 
 
PGM_HEADER_t PGM_getHeader(const char* cheminFichier)
{
    char buffer[BUFFER_SIZE] = {0};
    PGM_HEADER_t entete;
    FILE * fichier = fopen(cheminFichier,"r");
 
    if(fichier == NULL)
    {
        errno_and_quit("Fichier impossible a ouvrir");
    }
 
    // Sauvegarder chemin
    strcpy(entete.chemin, cheminFichier);
 
    // Recuperation en-tete
    if( (fgets(buffer, BUFFER_SIZE-1, fichier)) == NULL)
    {
        errno_and_quit("Lecture impossible");
    }
    buffer[2]=0; // supprimer '\n' de fin
    entete.type = PGM_strtotype(buffer);
 
    if( (fgets(buffer, BUFFER_SIZE-1, fichier)) == NULL)
    {
        errno_and_quit("Lecture impossible");
    }
    entete.hauteur = strtol(buffer, NULL, 10);
 
    if( (fgets(buffer, BUFFER_SIZE-1, fichier)) == NULL)
    {
        errno_and_quit("Lecture impossible");
    }
    entete.largeur = strtol(buffer, NULL, 10);
 
    if( (fgets(buffer, BUFFER_SIZE-1, fichier)) == NULL)
    {
        errno_and_quit("Lecture impossible");
    }
    entete.valeurMax = strtol(buffer, NULL, 10);
 
    fclose(fichier);
    return entete;
}
 
 
PGM_IMAGE_t* PGM_getData(PGM_HEADER_t entete_param)
{
    PGM_IMAGE_t *image = NULL;
    FILE *fichier = NULL;
    int i=0; // indice des lignes
    int j=0; // indice des colonnes
 
    // Initialisation de la structure image
    if( (image=malloc(sizeof(PGM_IMAGE_t))) == NULL )
    {
        errno_and_quit("Impossible d'allouer la structure PGM_IMAGE_t");
    }
 
    if( (image->donnees=malloc(entete_param.hauteur * sizeof(int*))) == NULL) // allouer N pointeurs pour les lignes
    {
        errno_and_quit("Impossible d'allouer la memoire des donnes image (ensemble des lignes)");
    }
 
    for(i=0;i<entete_param.hauteur;i++)
    {
        image->donnees[i]=malloc(entete_param.largeur * sizeof(int)); // allouer une ligne avec "largeur" colonnes
        if(image->donnees[i]==NULL)
        {
            errno_and_quit("Impossible d'allouer la memoire des donnes image (une ligne)");
        }
    }
 
    image->entete = entete_param;
 
    // Ouverture du fichier en mode binaire
    if( (fichier = fopen(entete_param.chemin,"rb")) == NULL )
    {
        errno_and_quit("Impossible d'ouvrir l'image en mode binaire");
    }
 
    // Skipper l'en-tete
    i=0;
    while(i!=4)
    {
        fscanf(fichier, "%c", (char*)&j);
        if(j=='\n')
        {
            i++;
        }
    }
 
    // Lecture de l'image
    for(i=0;i<entete_param.hauteur;i++)
    {
        for(j=0;j<entete_param.largeur;j++)
        {
            fscanf(fichier, "%c", (char*)&(image->donnees[i][j]) );
        }
    }
 
    fclose(fichier);
    return image;
}
 
 
void PGM_printHeader(PGM_HEADER_t entete)
{
    printf("Chemin : %s\n", entete.chemin);
    printf("Type : %d\n", entete.type+1);
    printf("Hauteur : %d\n", entete.hauteur);
    printf("Largeur : %d\n", entete.largeur);
    printf("ValeurMax : %d\n", entete.valeurMax);
}
 
 
void PGM_printData(PGM_IMAGE_t *image)
{
    int i=0;
    int j=0;
 
    // Afficher l'image
    for(i=0;i<image->entete.hauteur;i++)
    {
        for(j=0;j<image->entete.largeur;j++)
        {
            printf("%d", image->donnees[i][j]);
        }
        printf("\n");
    }
}
 
 
void PGM_printImage(PGM_IMAGE_t *image)
{
    PGM_printHeader(image->entete);
    PGM_printData(image);
}
 
 
int main(int argc, char *argv[])
{
    const char cheminFichier[] = "/home/pierre/test.pgm";
 
    puts("GetHeader");
    PGM_HEADER_t entete = PGM_getHeader(cheminFichier);
 
    puts("GetData");
    PGM_IMAGE_t* image = PGM_getData(entete);
 
    puts("PrintImage");
    PGM_printImage(image);
 
    return 0;
}

C'est quoi ton profil ? Le C n'a juste rien à voir avec le reste de ton CV. Je ne sais pas si un bon complément ^^ On va dire qu'il le diversifie mais pas forcément le complète.

[highdesign]

Fiou, encore merci!

En faite je suis en BAC +3 informatique de gestion, je suis développeur Web/Vba pour le service informatique d'une usine automobile du groupe Peugeot... Mais bon avoir un langage de plus ça peu pas faire de mal ! Surtout que le C est quand même plus rependu que le Vb.net