{"id":255,"date":"2017-04-07T07:12:13","date_gmt":"2017-04-07T07:12:13","guid":{"rendered":"http:\/\/learningcenter.paratools.com\/?p=255"},"modified":"2022-04-14T14:04:47","modified_gmt":"2022-04-14T14:04:47","slug":"dessiner-en-c-le-format-ppm","status":"publish","type":"post","link":"https:\/\/learningcenter.paratools.com\/?p=255","title":{"rendered":"Dessiner en C : le format PPM"},"content":{"rendered":"

L’un des probl\u00e8me parall\u00e8le les plus simple est le traitement d’image. Afin de permettre la mise en place de ce type d’exemple, il faut se donner les moyen de g\u00e9n\u00e9rer des images en C. C’est le but de cet article qui va d\u00e9finir une petite biblioth\u00e8que de dessin bas\u00e9e sur le format PPM.<\/p>\n

<\/p>\n

Portable PixMap<\/h1>\n

PPM signifie Portable PixMap c’est un format d’image extr\u00eamement portable vous pouvez en lire plus ICI<\/a>. Nous l’avons retenu car il est extr\u00eamement simple. Il permet de g\u00e9n\u00e9rer des images en quelques lignes de C!<\/p>\n

Afin de g\u00e9n\u00e9rer ce format de fichier, il faut avant tout en lire les sp\u00e9cifications http:\/\/netpbm.sourceforge.net\/doc\/ppm.html<\/a>. En consultant ce document on peut avoir une id\u00e9e plus claire du format:<\/p>\n

P6
\nLARGEUR(int)
\nHAUTEUR(int)
\nMAXCOULEUR(int)
\nRASTER DE PIXEL<\/p><\/blockquote>\n

Par simplicit\u00e9 nous avons retenu le retour \u00e0 la ligne comme s\u00e9parateur. Le raster de pixel, est tout simplement un tableau de LARGEUR * HAUTEUR \u00e9l\u00e9ments. Le type de l’\u00e9l\u00e9ment, comme indiqu\u00e9 dans la norme est un struxture regroupant les trois composantes sur un octet pour un MAXCOULEUR inf\u00e9rieur ou \u00e9gal \u00e0 256, et deux octets pour une valeur maximale de 65536. Nous allons couvir le cas o\u00f9 nous encodons sur un octet, tr\u00e8s classiquement pour une image. Les trois composantes sont Rouge, Vert et Bleu, not\u00e9es R, G et B dans le reste de cet article.<\/p>\n

Formaliser l’interface<\/h1>\n

En lisant les sp\u00e9cifications nous avons identifi\u00e9 deux objets, des pixels et une image. Cette image aura un ensemble de pixels et les attributs largeur et hauteur.<\/p>\n

Le pixel<\/h2>\n

On d\u00e9finit alors un pixel comme une structure C:<\/p>\n

\r\nstruct ppm_pixel\r\n{\r\n\tunsigned char r;\r\n\tunsigned char g;\r\n\tunsigned char b;\r\n};\r\n<\/pre>\n
On retrouve tr\u00e8s simplement nos trois composantes. Nous ajoutons \u00e9galement une fonction inline pour remplir un pixel. Une fonction quand d\u00e9finie dans le header peut \u00eatre \u00ab\u00a0recopi\u00e9e\u00a0\u00bb dans les diff\u00e9rents fichiers, devenant ainsi plus efficace. Il faut lui ajouter le mot-clef \u00ab\u00a0static\u00a0\u00bb pour ne pas cr\u00e9er de conflits de noms, cette fonction \u00e9tant alors d\u00e9finie dans tous les fichiers o\u00f9 le header a \u00e9t\u00e9 inclus. Pour le pixel d\u00e9finissons un setter:<\/p>\n
\r\nstatic inline void ppm_setpixel( struct ppm_pixel * px, unsigned char r , unsigned char g , unsigned char b)\r\n{\r\n\tpx->r = r;\r\n\tpx->g = g;\r\n\tpx->b = b;\r\n}\r\n<\/pre>\n
Cette fonction est extr\u00eamement simple, on place simplement les param\u00e8tres dans les membres de la structure.<\/p>\n
L’image<\/h2>\n
Ensuite d\u00e9finissons une image:<\/p>\n
\r\nstruct ppm_image\r\n{\r\n\tunsigned int width;\r\n\tunsigned int height;\r\n\tstruct ppm_pixel * px;\r\n};\r\n<\/pre>\n
Simple \u00e9galement, une largeur (width), une hauteur (height) et des pixels. Maintenant d\u00e9finissons les fonctions qui seront le point d’entr\u00e9e de l’utilisateur:<\/p>\n
\r\nint ppm_image_init( struct ppm_image *im , int w , int h );\r\nint ppm_image_release( struct ppm_image *im );\r\nvoid ppm_image_setpixel( struct ppm_image * im, int x, int y, unsigned char r , unsigned char g , unsigned char b);\r\nint ppm_image_dump( struct ppm_image *im, char * path );\r\n<\/pre>\n
Nous allons maintenant les couvrir une par une.<\/p>\n
ppm_image_init<\/h3>\n
Cette fonction doit instancier une image PPM, en particulier il s’agit de proc\u00e9der \u00e0 l’allocation m\u00e9moire de cette image pour la rendre manipulable par les primitives de dessin. Elle a \u00e9t\u00e9 impl\u00e9ment\u00e9e comme suit:<\/p>\n
\r\nint ppm_image_init( struct ppm_image *im , int w , int h )\r\n{\r\n\tmemset( im, 0, sizeof( struct ppm_image));\r\n\r\n\tim->width = w;\r\n\tim->height = h;\r\n\r\n\tim->px = calloc( sizeof(struct ppm_pixel), w*h );\r\n\r\n\tif( !im->px)\r\n\t{\r\n\t\tperror("malloc");\r\n\t\treturn 1;\r\n\t}\r\n\r\n\treturn 0;\r\n}\r\n<\/pre>\n
On vide le contenu de la structure, puis on sauve largeur et hauteur dans la structure. Enfin on utilise la fonction calloc pour allouer de la m\u00e9moire constituant notre raster de pixel. Calloc \u00e9tant une mani\u00e8re optimis\u00e9e d’allouer de la m\u00e9moire \u00e0 \u00ab\u00a00\u00a0\u00bb. (pas de malloc + memset!). Et voil\u00e0 la base de l’image est pr\u00eate.<\/p>\n
ppm_image_release<\/h3>\n
Ici on veut simplement lib\u00e9rer une image, tout en rendant la m\u00e9moire associ\u00e9e au syst\u00e8me.<\/p>\n
\r\nint ppm_image_release( struct ppm_image *im )\r\n{\r\n\tif( im == NULL )\r\n\t\treturn 1;\r\n\r\n\tfree( im->px );\r\n\tim->px = NULL;\r\n\r\n\tim->width = 0;\r\n\tim->height = 0;\r\n\r\n\treturn 0;\r\n}\r\n<\/pre>\n
On prends le temps de tout mettre \u00e0 z\u00e9ro dans la structure. Ensuite on fait \u00ab\u00a0free\u00a0\u00bb de la m\u00e9moire. Il est important de mettre le pointeur \u00e0 NULL. En effet free ne produit pas d’erreur si on lui passe un pointeur NULL. Ainsi vous couvrez le cas o\u00f9 une image est lib\u00e9r\u00e9e (par erreur) deux fois sans crasher.<\/p>\n
ppm_image_dump<\/h3>\n
Cette fonction va se charger d’\u00e9crire notre fichier au format PPM. Le processus est assez simple, il suffit de se reporter au standard.<\/p>\n
\r\nint ppm_image_dump( struct ppm_image *im, char * path )\r\n{\r\n\tFILE * out = fopen( path , "w");\r\n\r\n\tif( !out )\r\n\t{\r\n\t\tperror("fopen");\r\n\t\treturn 1;\r\n\t}\r\n\r\n\tfprintf(out, "P6\\n");\r\n\tfprintf(out, "%d\\n", im->width);\r\n\tfprintf(out, "%d\\n", im->height);\r\n\tfprintf(out, "255\\n");\r\n\tfwrite( im->px, sizeof(struct ppm_pixel) , im->width * im->height, out );\r\n\r\n\tfclose( out );\r\n\r\n\treturn 0;\r\n}\r\n<\/pre>\n
Ici nous ouvrons tout d’abord le fichier \u00ab\u00a0path\u00a0\u00bb en \u00e9criture. Ensuite, nous \u00e9crivons le \u00ab\u00a0magic number\u00a0\u00bb de PPM, le P6. Puis les largeurs et hauteurs. Enfin apr\u00e8s avoir donn\u00e9 la valeur maximum de 255 suivie d’un retour chariot, nous \u00e9crivons le raster de pixel directment en binaire. Et voil\u00e0, l’image est sauvegard\u00e9e.<\/p>\n
ppm_image_setpixel<\/h3>\n
Il faut bien s\u00fbr une fonction pour dessiner un pixel. Cette fonction \u00e9tant un accesseur soumis \u00e0 des contraintes de performances (de nombreux pixels modifi\u00e9s par cet appel de base), nous le placerons dans le header en static inline. Le code est le suivant:<\/p>\n
\r\nstatic inline void ppm_image_setpixel( struct ppm_image * im, int x, int y, unsigned char r , unsigned char g , unsigned char b)\r\n{\r\n\tstruct ppm_pixel * px = im->px + im->width * y + x;\r\n\tppm_setpixel( px, r, g, b);\r\n}\r\n<\/pre>\n
La seule complexit\u00e9 est le calcul de l’indice du pixel (tableau 2D) dans un tableau C issu d’une allocation lin\u00e9aire. Le principe est de se d\u00e9placer selon Y en blocs de la largeur et ensuite d’indicer ce d\u00e9placement par la position en X. Ensuite, nous appelons le setter de pixel qui est \u00e9galement static inline.<\/p>\n
Testons le tout<\/h1>\n
Il faut maintenant tester le tout en g\u00e9n\u00e9rant une image de test. Mais tout d’abord il faut compiler notre biblioth\u00e8que. Nous allons faire un makefile simple.<\/p>\n
\r\nCC=gcc\r\nCFLAGS=-O3 -g\r\n\r\nlibppm.so : ppm.c\r\n\t$(CC) $(CFLAGS)  -fpic -shared $^ -o $@\r\n<\/pre>\n
D\u00e9finissons tout d’abord une cible pour notre biblioth\u00e8que PPM. Notez que toute commande apr\u00e8s une cible doit<\/b> \u00eatre indend\u00e9e avec une tabulation. Pour compiler on passe \u00ab\u00a0-fpic\u00a0\u00bb qui compile le code de mani\u00e8re position ind\u00e9pendante (indispensable pour faire une biblioth\u00e8que dynamique). Ensuite \u00ab\u00a0-shared\u00a0\u00bb pour construire un .so. Puis \u00ab\u00a0$^\u00a0\u00bb renvoie aux d\u00e9pendances apr\u00e8s le \u00ab\u00a0:\u00a0\u00bb de la cible. Enfin, \u00ab\u00a0$@\u00a0\u00bb est le nom de la cible, construisant finalement \u00ab\u00a0libppm.so\u00a0\u00bb.<\/p>\n
Maintenant \u00e9crivons un petit fichier test (main.c):<\/p>\n
\r\n#include "ppm.h"\r\n\r\n\r\nint main(int argc, char *argv[])\r\n{\r\n\tstruct ppm_image im;\r\n\r\n\tppm_image_init( &im, 1024, 1024 );\r\n\r\n\tint i,j;\r\n\r\n\tfor (i = 0; i < 1024; ++i) {\r\n\t\tfor (j = 0; j < 1024; ++j) {\r\n\t\t\tppm_image_setpixel( &im, i, j, i%255, j%255, (i+j)%255);\r\n\t\t}\r\n\t}\r\n\r\n\tfor (i = 0; i < 1024; ++i) {\r\n\t\tppm_image_setpixel( &im, i, i, 255, 0, 0 );\r\n\t}\r\n\r\n\tppm_image_dump( &im , "test.ppm");\r\n\r\n\tppm_image_release( &im );\r\n\r\n\r\n\treturn 0;\r\n}\r\n<\/pre>\n
Ce code cr\u00e9e une image de 1024×1024, dessine des formes color\u00e9es et enfin une diagonale en rouge. Ce dernier test permet de v\u00e9rifier la signification des X et Y que nous avons d\u00e9finis tout \u00e0 l’heure. (0,0) \u00e9tant en haut \u00e0 gauche.<\/p>\n
Ajoutons maintenant la cible dans le Makefile:<\/p>\n
\r\nTARGET=test\r\n\r\nall: $(TARGET)\r\n\r\ntest: main.c libppm.so\r\n\t$(CC) $(CFLAGS) $(LDFLAGS) -lppm -L. main.c -o $@\r\n<\/pre>\n
Ici nous d\u00e9finissons la cible \u00ab\u00a0all\u00a0\u00bb qui est celle appel\u00e9e par d\u00e9faut (quand on appelle make). Cette cible d\u00e9pends de TARGET qui contient la cible \u00ab\u00a0test\u00a0\u00bb. All appelle donc test. Test d\u00e9pends de main.c (elle est appel\u00e9e si le fichier est modifi\u00e9) et de libpp.so. Ansi libppm.so est construite pour construire test. Enfin, dans la ligne de commande, nous ajoutons \u00ab\u00a0-lppm\u00a0\u00bb (notez que c’est la fin du nom de libppm, par standard) et \u00ab\u00a0-L.\u00a0\u00bb pour dire \u00e0 GCC de chercher les librairies dans le r\u00e9pertoire courant \u00ab\u00a0.\u00a0\u00bb.<\/p>\n
Maintenant si nous faisons Make:<\/p>\n
\r\nmake\r\ngcc -O3 -g  -fpic -shared ppm.c -o libppm.so\r\ngcc -O3 -g  -lppm -L. main.c -o test\r\n<\/pre>\n
Ajoutons une cible \u00ab\u00a0clean\u00a0\u00bb:<\/p>\n
\r\nclean:\r\n\trm -fr $(TARGET) *.so\r\n<\/pre>\n
Et voil\u00e0 le makefile est complet.<\/p>\n
Maintenant si on lance le test, on a une erreur :<\/p>\n
.\/test: error while loading shared libraries: libppm.so: cannot open shared object file: No such file or directory<\/p><\/blockquote>\n
Cela est d\u00fb au fait que nous n’avons pas inform\u00e9 le loader de la position du binaire. Il faut l’ajouter au LD_LIBRARY_PATH. On peut v\u00e9rifier d’o\u00f9 viennent les biblioth\u00e8ques avec \u00ab\u00a0ldd\u00a0\u00bb:<\/p>\n
\r\nldd .\/test                                                          \r\n\tlinux-vdso.so.1 =>  (0x00007ffdc674c000)\r\n\tlibppm.so => not found\r\n\tlibc.so.6 => \/lib64\/libc.so.6 (0x00007f35861de000)\r\n\t\/lib64\/ld-linux-x86-64.so.2 (0x00007f35865b9000)\r\n<\/pre>\n
Ajoutons le dossier courant \u00e0 LD_LIBRARY_PATH:<\/p>\n
\r\nexport LD_LIBRARY_PATH=$PWD:$LD_LIBRARY_PATH\r\n<\/pre>\n
Rev\u00e9rifions ldd:<\/p>\n
\r\nldd .\/test\r\n\tlinux-vdso.so.1 =>  (0x00007ffc0dd16000)\r\n\tlibppm.so => \/home\/jbbesnard\/ppm\/libppm.so (0x00007f15a8d89000)\r\n\tlibc.so.6 => \/lib64\/libc.so.6 (0x00007f15a89af000)\r\n\t\/lib64\/ld-linux-x86-64.so.2 (0x00007f15a8f8c000)\r\n<\/pre>\n
Et voil\u00e0, le programme peut s’\u00e9x\u00e9cuter. Vous obtiendrez alors une image PPM dans le dossier courant. Vous avez maintenant une biblioth\u00e8que simple de dessin \u00e0 votre disposition.<\/p>\n
\"\"<\/a><\/p>\n
Conclusion<\/h1>\n
Nous avons vu comment impl\u00e9menter une biblioth\u00e8que de dessin minimale supportant le format PPM. Cette biblioth\u00e8que servira de base \u00e0 des exemples de traitement d’image par la suite.<\/p>\n
Listings<\/h1>\n
Le code d’une biblioth\u00e8que PPM simpliste.<\/p>\n
ppm.h:<\/p>\n
\r\n#ifndef PPM_H\r\n#define PPM_H\r\n\r\nstruct ppm_pixel\r\n{\r\n\tunsigned char r;\r\n\tunsigned char g;\r\n\tunsigned char b;\r\n};\r\n\r\nstatic inline void ppm_setpixel( struct ppm_pixel * px, unsigned char r , unsigned char g , unsigned char b)\r\n{\r\n\tpx->r = r;\r\n\tpx->g = g;\r\n\tpx->b = b;\r\n}\r\n\r\nstruct ppm_image\r\n{\r\n\tunsigned int width;\r\n\tunsigned int height;\r\n\tstruct ppm_pixel * px;\r\n};\r\n\r\nint ppm_image_init( struct ppm_image *im , int w , int h );\r\nint ppm_image_release( struct ppm_image *im );\r\n\r\nstatic inline void ppm_image_setpixel( struct ppm_image * im, int x, int y, unsigned char r , unsigned char g , unsigned char b)\r\n{\r\n\tstruct ppm_pixel * px = im->px + im->width * y + x;\r\n\tppm_setpixel( px, r, g, b);\r\n}\r\n\r\nint ppm_image_dump( struct ppm_image *im, char * path );\r\n\r\n\r\n#endif \/* PPM_H *\/\r\n<\/pre>\n
ppm.c:<\/p>\n
\r\n#include "ppm.h"\r\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\n\r\nint ppm_image_init( struct ppm_image *im , int w , int h )\r\n{\r\n\tmemset( im, 0, sizeof( struct ppm_image));\r\n\r\n\tim->width = w;\r\n\tim->height = h;\r\n\r\n\tim->px = malloc( w * h * sizeof(struct ppm_pixel));\r\n\r\n\tif( !im->px)\r\n\t{\r\n\t\tperror("malloc");\r\n\t\treturn 1;\r\n\t}\r\n\r\n\treturn 0;\r\n}\r\n\r\nint ppm_image_release( struct ppm_image *im )\r\n{\r\n\tif( im == NULL )\r\n\t\treturn 1;\r\n\r\n\tfree( im->px );\r\n\tim->px = NULL;\r\n\r\n\tim->width = 0;\r\n\tim->height = 0;\r\n\r\n\treturn 0;\r\n}\r\n\r\nint ppm_image_dump( struct ppm_image *im, char * path )\r\n{\r\n\tFILE * out = fopen( path , "w");\r\n\r\n\tif( !out )\r\n\t{\r\n\t\tperror("fopen");\r\n\t\treturn 1;\r\n\t}\r\n\r\n\tfprintf(out, "P6\\n");\r\n\tfprintf(out, "%d\\n", im->width);\r\n\tfprintf(out, "%d\\n", im->height);\r\n\tfprintf(out, "255\\n");\r\n\tfwrite( im->px, sizeof(struct ppm_pixel) , im->width * im->height, out );\r\n\r\n\tfclose( out );\r\n\r\n\treturn 0;\r\n}\r\n<\/pre>\n
Makefile:<\/p>\n
\r\nCC=gcc\r\nCFLAGS=-O3 -g\r\n\r\nTARGET=test\r\n\r\nall: $(TARGET)\r\n\r\nlibppm.so : ppm.c\r\n\t$(CC) $(CFLAGS)  -fpic -shared $^ -o $@\r\n\r\ntest: main.c libppm.so\r\n\t$(CC) $(CFLAGS) $(LDFLAGS) -lppm -L. main.c -o $@\r\n\r\nclean:\r\n\trm -fr $(TARGET) *.so\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
L’un des probl\u00e8me parall\u00e8le les plus simple est le traitement d’image. Afin de permettre la mise en place de ce type d’exemple, il faut se donner les moyen de g\u00e9n\u00e9rer des images en C. C’est le but de cet article qui va d\u00e9finir une petite biblioth\u00e8que de dessin bas\u00e9e sur le format PPM.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[12,36],"tags":[37,38,39],"_links":{"self":[{"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/posts\/255"}],"collection":[{"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=255"}],"version-history":[{"count":13,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/posts\/255\/revisions"}],"predecessor-version":[{"id":269,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=\/wp\/v2\/posts\/255\/revisions\/269"}],"wp:attachment":[{"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=255"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=255"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/learningcenter.paratools.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=255"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}