phundrak/surfaces-unies
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

code style

Browse Source
This commit is contained in:
Phuntsok Drak-pa 2018-11-24 21:58:55 +01:00
parent a27a31a0ae
commit a289cfbf2d
No known key found for this signature in database
GPG Key ID: 9CB34B6827C66D22
10 changed files with 111 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/compress.c
View File

@ -13,7 +13,7 @@
* \param[in] t_zone Zone à laquelle le pixel est éligible ou non * \param[in] t_zone Zone à laquelle le pixel est éligible ou non
* \return Valeur booléenne, `1` si le pixel est éligible, `0` sinon * \return Valeur booléenne, `1` si le pixel est éligible, `0` sinon
*/ */
bool sameColor(Pixel* t_pixel, Zone* t_zone) { bool sameColor(Pixel *t_pixel, Zone *t_zone) {
return t_pixel->r == t_zone->r && t_pixel->g == t_zone->g && return t_pixel->r == t_zone->r && t_pixel->g == t_zone->g &&
t_pixel->b == t_zone->b; t_pixel->b == t_zone->b;
} }
@ -31,14 +31,14 @@ bool sameColor(Pixel* t_pixel, Zone* t_zone) {
* \param[in] t_idx Index du pixel actuel dans l’image `t_img` * \param[in] t_idx Index du pixel actuel dans l’image `t_img`
* \param[out] t_zone Zone à laquelle sera potentiellement ajouté le pixel * \param[out] t_zone Zone à laquelle sera potentiellement ajouté le pixel
*/ */
void addPixelToSelectedZone(Image *t_img, long t_idx, Zone *t_zone) { void addPixelToSelectedZone(Image *t_img, int64_t t_idx, Zone *t_zone) {
const size_t img_size = darraySize(t_img->pixels); const size_t img_size = darraySize(t_img->pixels);
Pixel *current_pixel; Pixel *current_pixel;
const uint32_t y = (uint32_t)(t_idx / t_img->x); const uint32_t y = (uint32_t)(t_idx / t_img->x);
long left_limit, right_limit; int64_t left_limit, right_limit;
const long xd_limit = (long)t_img->x * (y + 1); const int64_t xd_limit = (int64_t)t_img->x * (y + 1);
if (t_idx >= (long)img_size || t_idx < 0) { if (t_idx >= (int64_t)img_size || t_idx < 0) {
return; return;
} }
current_pixel = darrayGet(t_img->pixels, (size_t)t_idx); current_pixel = darrayGet(t_img->pixels, (size_t)t_idx);
@ -54,7 +54,7 @@ void addPixelToSelectedZone(Image *t_img, long t_idx, Zone *t_zone) {
current_pixel->visited = 1; current_pixel->visited = 1;
} }
for (left_limit = t_idx; left_limit - (y - 1) * (long)t_img->x >= 0; for (left_limit = t_idx; left_limit - (y - 1) * (int64_t)t_img->x >= 0;
--left_limit) { /* fetch right limit of segment */ --left_limit) { /* fetch right limit of segment */
current_pixel = darrayGet(t_img->pixels, (size_t)left_limit); current_pixel = darrayGet(t_img->pixels, (size_t)left_limit);
if (current_pixel->visited || !sameColor(current_pixel, t_zone)) { if (current_pixel->visited || !sameColor(current_pixel, t_zone)) {
@ -80,7 +80,7 @@ void addPixelToSelectedZone(Image *t_img, long t_idx, Zone *t_zone) {
* \param[in] t_idx Index du pixel à tester * \param[in] t_idx Index du pixel à tester
* \param[out] t_zones Liste des zones de l’image * \param[out] t_zones Liste des zones de l’image
*/ */
void chooseZoneForPixel(Image *t_img, long t_idx, darray *zones) { void chooseZoneForPixel(Image *t_img, int64_t t_idx, darray *zones) {
Zone *current_zone; Zone *current_zone;
Pixel *pixel; Pixel *pixel;
size_t i; size_t i;
@ -117,11 +117,11 @@ void chooseZoneForPixel(Image *t_img, long t_idx, darray *zones) {
darray *imgToZones(Image *t_img) { darray *imgToZones(Image *t_img) {
darray *zones; darray *zones;
const size_t nb_pixels = darraySize(t_img->pixels); const size_t nb_pixels = darraySize(t_img->pixels);
long i; int64_t i;
zones = darrayNew(sizeof(Zone)); zones = darrayNew(sizeof(Zone));
/* for each pixel, try to create a new zone */ /* for each pixel, try to create a new zone */
for (i = 0; i < (long)nb_pixels; ++i) { for (i = 0; i < (int64_t)nb_pixels; ++i) {
chooseZoneForPixel(t_img, i, zones); chooseZoneForPixel(t_img, i, zones);
} }
return zones; return zones;
@ -143,7 +143,7 @@ void compress(const char *t_input_file) {
zones = imgToZones(img); zones = imgToZones(img);
deleteImage(img); deleteImage(img);
for(i = 0; i < darraySize(zones); ++i) { for (i = 0; i < darraySize(zones); ++i) {
current_zone = darrayGet(zones, i); current_zone = darrayGet(zones, i);
darrayDelete(current_zone->segments); darrayDelete(current_zone->segments);
} }

10
src/compress.h
View File

@ -3,20 +3,20 @@
* \brief Déclaration pour la (dé)compression d’images * \brief Déclaration pour la (dé)compression d’images
*/ */
#ifndef COMPRESS_H #ifndef SRC_COMPRESS_H_
#define COMPRESS_H #define SRC_COMPRESS_H_
#include "ppm.h" #include "ppm.h"
/// Teste l’éligibilité d’un pixel à une zone /// Teste l’éligibilité d’un pixel à une zone
bool sameColor(Pixel *t_pixel, Zone *t_zone); bool sameColor(Pixel *t_pixel, Zone *t_zone);
/// Ajoute un pixel et ses pixels connexes à une zone /// Ajoute un pixel et ses pixels connexes à une zone
void addPixelToSelectedZone(Image *t_img, long t_idx, Zone *t_zone); void addPixelToSelectedZone(Image *t_img, int64_t t_idx, Zone *t_zone);
/// Sélectionne la zone correspondant à la couleur d'un pixel /// Sélectionne la zone correspondant à la couleur d'un pixel
void chooseZoneForPixel(Image *t_img, long t_idx, darray *zones); void chooseZoneForPixel(Image *t_img, int64_t t_idx, darray *zones);
/// Créé les zones d'une image /// Créé les zones d'une image
darray *imgToZones(Image *t_img); darray *imgToZones(Image *t_img);
/// Compresse l'image d'entrée /// Compresse l'image d'entrée
void compress(const char *t_input_file); void compress(const char *t_input_file);
#endif /* COMPRESS_H */ #endif /* SRC_COMPRESS_H_ */

42
src/darray.c
View File

@ -13,12 +13,13 @@
* de connaître l’espace mémoire à allouer à chacun des éléments dans le * de connaître l’espace mémoire à allouer à chacun des éléments dans le
* tableau. Cela implique qu’un objet \ref darray_t ne peut contenir que des * tableau. Cela implique qu’un objet \ref darray_t ne peut contenir que des
* éléments du même type. * éléments du même type.
*
* \param[in] element_size Taille des objets stockés * \param[in] element_size Taille des objets stockés
* \return Pointeur sur le nouvel objet \ref darray_t * \return Pointeur sur le nouvel objet \ref darray_t
*/ */
darray* darrayNew(size_t t_element_size) { darray *darrayNew(size_t t_element_size) {
darray* ret; darray *ret;
ret = (darray*)malloc(sizeof(darray)); ret = (darray *)malloc(sizeof(darray));
ret->begin = NULL; ret->begin = NULL;
ret->end = ret->begin; ret->end = ret->begin;
ret->element_size = t_element_size; ret->element_size = t_element_size;
@ -32,13 +33,15 @@ darray* darrayNew(size_t t_element_size) {
* pen d’un cran vers la fin du tableau et insérera à l’endroit pointé le nouvel * pen d’un cran vers la fin du tableau et insérera à l’endroit pointé le nouvel
* élément. Cette fonction modifie les membres `begin` et `end` et * élément. Cette fonction modifie les membres `begin` et `end` et
* potentiellement `capacity` de `self`. * potentiellement `capacity` de `self`.
*
* \param[in] self Objet \ref darray dans lequel on souhaite insérer un nouvel * \param[in] self Objet \ref darray dans lequel on souhaite insérer un nouvel
* élément \param[in] pos Position à laquelle on souhaite insérer un nouvel * élément
* élément \param[in] elem Élément que l’on souhaite insérer * \param[in] pos Position à laquelle on souhaite insérer un nouvel élément
* \param[in] elem Élément que l’on souhaite insérer
*/ */
void darrayInsert(darray *t_self, void *t_pos, void *t_elem) { void darrayInsert(darray *t_self, void *t_pos, void *t_elem) {
char *itr; char *itr;
long pos_aux; int64_t pos_aux;
pos_aux = (char *)t_pos - (char *)t_self->begin; pos_aux = (char *)t_pos - (char *)t_self->begin;
if (darraySize(t_self) >= t_self->capacity) { if (darraySize(t_self) >= t_self->capacity) {
darrayExtend(t_self); darrayExtend(t_self);
@ -78,6 +81,7 @@ void darrayExtend(darray *t_self) {
* vers le début du tableau de manière à ce qu’il n’y aie pas d’élément vide * vers le début du tableau de manière à ce qu’il n’y aie pas d’élément vide
* entre les membres `begin` et `end` de `self`. Par ailleurs, le membre `end` * entre les membres `begin` et `end` de `self`. Par ailleurs, le membre `end`
* de `self` se retrouve modifié par la fonction. * de `self` se retrouve modifié par la fonction.
*
* \param[out] self Objet \ref `darray` dont on souhaite supprimer un élément * \param[out] self Objet \ref `darray` dont on souhaite supprimer un élément
* \param[in] pos Élément de `self` que l’on souhaite supprimer * \param[in] pos Élément de `self` que l’on souhaite supprimer
*/ */
@ -90,7 +94,9 @@ void darrayErase(darray *t_self, void *t_pos) {
/** /**
* `darrayPushBack` ajoute un nouvel élément `elem` à l’objet `self` à la fin du * `darrayPushBack` ajoute un nouvel élément `elem` à l’objet `self` à la fin du
* tableau de ce dernier. Cette fonction modifie le membre `end` de `self`. * tableau de ce dernier. Cette fonction modifie le membre `end` de `self`.
* \param[out] self Objet \ref darray à la fin duquel on souhaite ajouter un nouvel élément *
* \param[out] self Objet \ref darray à la fin duquel on souhaite ajouter un
* nouvel élément
* \param[in] elem Élément que l’on souhaite ajouter à la fin de `self` * \param[in] elem Élément que l’on souhaite ajouter à la fin de `self`
*/ */
void darrayPushBack(darray *t_self, void *t_elem) { void darrayPushBack(darray *t_self, void *t_elem) {
@ -101,9 +107,10 @@ void darrayPushBack(darray *t_self, void *t_elem) {
* `darrayPopBack` permet de supprimer le dernier élément de l’objet \ref * `darrayPopBack` permet de supprimer le dernier élément de l’objet \ref
* darray passé en argument. Cette fonction modifie le membre `end` de ce * darray passé en argument. Cette fonction modifie le membre `end` de ce
* dernier objet. * dernier objet.
*
* \param[out] self Objet dont on souhaite supprimer le dernier élément * \param[out] self Objet dont on souhaite supprimer le dernier élément
*/ */
void darrayPopBack(darray* t_self) { void darrayPopBack(darray *t_self) {
darrayErase(t_self, (char *)t_self->end - t_self->element_size); darrayErase(t_self, (char *)t_self->end - t_self->element_size);
} }
@ -112,9 +119,10 @@ void darrayPopBack(darray* t_self) {
* passé en argument avant de libérer la mémoire occupée par l’objet lui-même. * passé en argument avant de libérer la mémoire occupée par l’objet lui-même.
* L’objet passé en argument ne sera plus utilisable après utilisation de cette * L’objet passé en argument ne sera plus utilisable après utilisation de cette
* fonction. * fonction.
*
* \param[out] self Objet \ref darray à supprimer * \param[out] self Objet \ref darray à supprimer
*/ */
void darrayDelete(darray* t_self) { void darrayDelete(darray *t_self) {
free(t_self->begin); free(t_self->begin);
free(t_self); free(t_self);
} }
@ -123,10 +131,12 @@ void darrayDelete(darray* t_self) {
* `darraySize` renvoie le nombre d’éléments contenu dans le \ref darray * `darraySize` renvoie le nombre d’éléments contenu dans le \ref darray
* `self` passé en arguments. Cette fonction ne modifie pas l’élément passé en * `self` passé en arguments. Cette fonction ne modifie pas l’élément passé en
* argument. * argument.
* \param[out] self Objet \ref darray dont on souhaite connaître le nombre d’éléments *
* \param[out] self Objet \ref darray dont on souhaite connaître le nombre
* d’éléments
* \return Nombre d’éléments contenus dans `self` * \return Nombre d’éléments contenus dans `self`
*/ */
size_t darraySize(darray* t_self) { size_t darraySize(darray *t_self) {
return (size_t)((char *)t_self->end - (char *)t_self->begin) / return (size_t)((char *)t_self->end - (char *)t_self->begin) /
t_self->element_size; t_self->element_size;
} }
@ -137,12 +147,14 @@ size_t darraySize(darray* t_self) {
* le pointeur `NULL` sera renvoyé, sinon un pointeur de type `void*` pointant * le pointeur `NULL` sera renvoyé, sinon un pointeur de type `void*` pointant
* sur l’élément correspondant sera renvoyé. Cette fonction ne modifie pas * sur l’élément correspondant sera renvoyé. Cette fonction ne modifie pas
* l’objet `self`. * l’objet `self`.
* \param[out] self Objet \ref darray duquel on souhaite obtenir un pointeur sur l’élément à l’index `idx` * \param[out] self Objet \ref darray duquel on souhaite obtenir un pointeur sur
* l’élément à l’index `idx`
* \param[in] idx Index de l’élément que l’on souhaite récupérer * \param[in] idx Index de l’élément que l’on souhaite récupérer
* \return Pointeur de type `void*` pointant sur l’élément si l’index est valide, sur NULL sinon. * \return Pointeur de type `void*` pointant sur l’élément si l’index est
* valide, sur NULL sinon.
*/ */
void *darrayGet(darray* t_self, size_t t_idx) { void *darrayGet(darray *t_self, size_t t_idx) {
if(t_idx >= darraySize(t_self)) { if (t_idx >= darraySize(t_self)) {
fprintf(stderr, "Error in `darrayGet`, out of bound idx: %zu (max: %zu)\n", fprintf(stderr, "Error in `darrayGet`, out of bound idx: %zu (max: %zu)\n",
t_idx, darraySize(t_self)); t_idx, darraySize(t_self));
exit(PTR_ERROR); exit(PTR_ERROR);

25
src/darray.h
View File

@ -1,10 +1,11 @@
/** /**
* \file darray.h * \file darray.h
* \brief Implémentation de \ref darray_t et déclaration des fonctions pour ce type * \brief Implémentation de \ref darray_t et déclaration des fonctions pour ce
* type
*/ */
#ifndef DARRAY_H #ifndef SRC_DARRAY_H_
#define DARRAY_H #define SRC_DARRAY_H_
#include "errorcodes.h" #include "errorcodes.h"
#include <stdlib.h> #include <stdlib.h>
@ -18,9 +19,11 @@
*/ */
typedef struct darray_s { typedef struct darray_s {
void *begin; /*!< Pointeur sur le premier élément du tableau */ void *begin; /*!< Pointeur sur le premier élément du tableau */
void *end; /*!< Pointeur sur l’élément situé immédiatement après le dernier élément du tableau */ void *end; /*!< Pointeur sur l’élément situé immédiatement après le dernier
élément du tableau */
size_t element_size; /*!< Taille des éléments stockés dans le tableau */ size_t element_size; /*!< Taille des éléments stockés dans le tableau */
size_t capacity; /*!< Capacité maximale du tableau actuel (non destinée à l’utilisateur) */ size_t capacity; /*!< Capacité maximale du tableau actuel (non destinée à
l’utilisateur) */
} darray; } darray;
/// \brief Créé un nouvel objet \ref darray vide /// \brief Créé un nouvel objet \ref darray vide
@ -28,20 +31,20 @@ darray *darrayNew(size_t element_size);
/// \brief Augmente la capacité d'un \ref darray /// \brief Augmente la capacité d'un \ref darray
void darrayExtend(darray *self); void darrayExtend(darray *self);
/// \brief Insère un élément à l’endroit pointé dans un \ref darray /// \brief Insère un élément à l’endroit pointé dans un \ref darray
void darrayInsert(darray *self, void *pos, void *elem); void darrayInsert(darray *self, void *pos, void *elem);
/// \brief Supprime l’élément pointé dans l’objet \ref darray /// \brief Supprime l’élément pointé dans l’objet \ref darray
void darrayErase(darray *self, void *pos); void darrayErase(darray *self, void *pos);
/// \brief Retourne l’élément du \ref darray au idx-ème index /// \brief Retourne l’élément du \ref darray au idx-ème index
void *darrayGet(darray *self, size_t idx); void *darrayGet(darray *self, size_t idx);
/// \brief Insère un élément à la fin de l’élément \ref darray /// \brief Insère un élément à la fin de l’élément \ref darray
void darrayPushBack(darray *self, void *elem); void darrayPushBack(darray *self, void *elem);
/// \brief Supprime le dernier élément de l’élément \ref darray /// \brief Supprime le dernier élément de l’élément \ref darray
void darrayPopBack(darray *self); void darrayPopBack(darray *self);
/// \brief Détruit l’élément \ref darray /// \brief Détruit l’élément \ref darray
void darrayDelete(darray *self); void darrayDelete(darray *self);
/// \brief Renvoie la taille de l’élément \ref darray /// \brief Renvoie la taille de l’élément \ref darray
size_t darraySize(darray *self); size_t darraySize(darray *self);
/// \brief Renvoie la taille de l’élément \ref darray /// \brief Renvoie la taille de l’élément \ref darray
size_t darrayElemSize(darray *self); size_t darrayElemSize(darray *self);
#endif /* DARRAY_H */ #endif /* SRC_DARRAY_H_ */

14
src/errorcodes.h
View File

@ -1,5 +1,13 @@
#ifndef ERRORCODES_H /**
#define ERRORCODES_H * \file errorcodes.h
* \brief Definition of error codes
*
* Dans ce fichier sont définis les codes d’erreur pouvant interrompre le
* programme.
*/
#ifndef SRC_ERRORCODES_H_
#define SRC_ERRORCODES_H_
/// Pas d’erreur /// Pas d’erreur
#define NOERROR 0 #define NOERROR 0
@ -12,4 +20,4 @@
/// Constante pour les erreurs liées au format de fichiers /// Constante pour les erreurs liées au format de fichiers
#define FILE_FORMAT_ERROR 4 #define FILE_FORMAT_ERROR 4
#endif /* ERRORCODES_H */ #endif /* SRC_ERRORCODES_H_ */

14
src/main.c
View File

@ -62,7 +62,7 @@ typedef struct Argres Argres;
* \param[out] t_args Result of the arguments processing * \param[out] t_args Result of the arguments processing
* \param[in] t_c Switch or option passed * \param[in] t_c Switch or option passed
*/ */
void get_args(Argres *t_args, const int * const t_c) { void get_args(Argres *t_args, const int *const t_c) {
switch (*t_c) { switch (*t_c) {
case 0: break; case 0: break;
case 'h': help(NOERROR); break; case 'h': help(NOERROR); break;
@ -96,11 +96,15 @@ Argres process_args(const int t_argc, char *t_argv[]) {
while (1) { while (1) {
int option_index = 0; int option_index = 0;
static struct option long_options[] = { static struct option long_options[] = {
{"help", no_argument, NULL, 'h'}, {"input", required_argument, NULL, 'i'}, {"help", no_argument, NULL, 'h'},
{"output", required_argument, NULL, 'o'}, {"compress", no_argument, NULL, 'c'}, {"input", required_argument, NULL, 'i'},
{"uncompress", no_argument, NULL, 'u'}, {NULL, 0, NULL, 0}}; {"output", required_argument, NULL, 'o'},
{"compress", no_argument, NULL, 'c'},
{"uncompress", no_argument, NULL, 'u'},
{NULL, 0, NULL, 0}};
int c = getopt_long(t_argc, t_argv, "hi:o:cu", long_options, &option_index); int c = getopt_long(t_argc, t_argv, "hi:o:cu", long_options, &option_index);
if (c == -1) break; if (c == -1)
break;
get_args(&res, &c); get_args(&res, &c);
} }
return res; return res;

31
src/ppm.c
View File

@ -23,8 +23,8 @@
* \param[in] mode Mode du fichier à ouvrir * \param[in] mode Mode du fichier à ouvrir
* \return Pointeur de fichier * \return Pointeur de fichier
*/ */
FILE* get_file(const char *t_filename, const char* t_mode) { FILE *get_file(const char *t_filename, const char *t_mode) {
FILE* fp = fopen(t_filename, t_mode); FILE *fp = fopen(t_filename, t_mode);
if (!fp) { if (!fp) {
fprintf(stderr, "Unable to open file '%s'\n", t_filename); fprintf(stderr, "Unable to open file '%s'\n", t_filename);
exit(FILE_IO_ERROR); exit(FILE_IO_ERROR);
@ -39,7 +39,7 @@ FILE* get_file(const char *t_filename, const char* t_mode) {
* \param[in] fb Fichier ppm où lire les données * \param[in] fb Fichier ppm où lire les données
* \param[in] filename Nom du fichier ouvert * \param[in] filename Nom du fichier ouvert
*/ */
void read_file_format(FILE* t_fp, const char* t_filename) { void read_file_format(FILE *t_fp, const char *t_filename) {
char buff[16]; char buff[16];
if (!fgets(buff, sizeof(buff), t_fp)) { if (!fgets(buff, sizeof(buff), t_fp)) {
perror(t_filename); perror(t_filename);
@ -57,7 +57,7 @@ void read_file_format(FILE* t_fp, const char* t_filename) {
* *
* \param[in] fp Fichier ppm où lire les données * \param[in] fp Fichier ppm où lire les données
*/ */
void check_for_comments(FILE* t_fp) { void check_for_comments(FILE *t_fp) {
char c; char c;
c = (char)getc(t_fp); c = (char)getc(t_fp);
while (c == '#') { while (c == '#') {
@ -76,7 +76,7 @@ void check_for_comments(FILE* t_fp) {
* \param[out] img Conteneur d’image où écrire les résultats * \param[out] img Conteneur d’image où écrire les résultats
* \param[in] filename Nom du fichier ouvert * \param[in] filename Nom du fichier ouvert
*/ */
void read_file_size(FILE* t_fp, Image* t_img, const char* t_filename) { void read_file_size(FILE *t_fp, Image *t_img, const char *t_filename) {
if (fscanf(t_fp, "%lu %lu", &t_img->x, &t_img->y) != 2) { if (fscanf(t_fp, "%lu %lu", &t_img->x, &t_img->y) != 2) {
fprintf(stderr, "Invalid image size (error loading '%s')\n", t_filename); fprintf(stderr, "Invalid image size (error loading '%s')\n", t_filename);
exit(FILE_FORMAT_ERROR); exit(FILE_FORMAT_ERROR);
@ -90,7 +90,7 @@ void read_file_size(FILE* t_fp, Image* t_img, const char* t_filename) {
* \param[in] fp Fichier ppm où lire les données * \param[in] fp Fichier ppm où lire les données
* \param[in] filename Nom du fichier ouvert * \param[in] filename Nom du fichier ouvert
*/ */
void read_rgb(FILE* t_fp, const char* t_filename) { void read_rgb(FILE *t_fp, const char *t_filename) {
char d; char d;
int rgb_comp_color; int rgb_comp_color;
/* read rgb component */ /* read rgb component */
@ -112,7 +112,8 @@ unsigned long read_data(FILE *t_fp, Image *t_img, unsigned char **t_data,
/* allocation memoire */ /* allocation memoire */
size = t_img->x * t_img->y * 3; size = t_img->x * t_img->y * 3;
DEBUG { DEBUG {
printf("Size image %lu %lu => %lu\n", t_img->x, t_img->y, t_img->x * t_img->y); printf("Size image %lu %lu => %lu\n", t_img->x, t_img->y,
t_img->x * t_img->y);
} }
*t_data = (unsigned char *)malloc((size_t)size * sizeof(unsigned char)); *t_data = (unsigned char *)malloc((size_t)size * sizeof(unsigned char));
assert(*t_data); assert(*t_data);
@ -126,10 +127,10 @@ unsigned long read_data(FILE *t_fp, Image *t_img, unsigned char **t_data,
} }
/** /**
* Convertit vers un tableau de `unsigned char` les pixels contenus dans un conteneur * Convertit vers un tableau de `unsigned char` les pixels contenus dans un
* d’image. La taille du tableau de `unsigned char` est la taille du tableau de * conteneur d’image. La taille du tableau de `unsigned char` est la taille du
* pixels multipliée par trois du fait des trois emplacements séparés par * tableau de pixels multipliée par trois du fait des trois emplacements séparés
* couleur. * par couleur.
* *
* \param[out] img Image dont les pixels doivent être convertis * \param[out] img Image dont les pixels doivent être convertis
* \param[in] data Données à convertir en structures \ref Pixel * \param[in] data Données à convertir en structures \ref Pixel
@ -154,13 +155,13 @@ void dataToImage(Image *t_img, unsigned char *t_data, unsigned long t_size) {
* \param[in] img Conteneur d’image contenant les pixels à convertir * \param[in] img Conteneur d’image contenant les pixels à convertir
* \return Tableau de pointeurs de `GLuint` * \return Tableau de pointeurs de `GLuint`
*/ */
unsigned char *imageToData(Image* t_img) { unsigned char *imageToData(Image *t_img) {
Pixel* pixel; Pixel *pixel;
unsigned char *data, size; unsigned char *data, size;
unsigned long i; unsigned long i;
size = (unsigned char)darraySize(t_img->pixels); size = (unsigned char)darraySize(t_img->pixels);
data = (unsigned char *)malloc(3 * sizeof(unsigned char) * size); data = (unsigned char *)malloc(3 * sizeof(unsigned char) * size);
for(i = 0; i < size; i += 3) { for (i = 0; i < size; i += 3) {
pixel = darrayGet(t_img->pixels, i / 3); pixel = darrayGet(t_img->pixels, i / 3);
data[i] = pixel->r; data[i] = pixel->r;
data[i + 1] = pixel->g; data[i + 1] = pixel->g;
@ -202,7 +203,7 @@ int imageLoadPPM(const char *t_filename, Image *t_img) {
* \param[in] filename Nom du fichier image à ouvrir * \param[in] filename Nom du fichier image à ouvrir
* \param[in] img Objet \ref Image à écrire * \param[in] img Objet \ref Image à écrire
*/ */
void imageSavePPM(char *t_filename, Image* t_img) { void imageSavePPM(char *t_filename, Image *t_img) {
FILE *fp; FILE *fp;
unsigned char *data; unsigned char *data;
fp = get_file(t_filename, "wb"); /* open file for output */ fp = get_file(t_filename, "wb"); /* open file for output */

6
src/ppm.h
View File

@ -7,8 +7,8 @@
* *
*/ */
#ifndef IMGTACHES_SRC_PPM_H_ #ifndef SRC_PPM_H_
#define IMGTACHES_SRC_PPM_H_ #define SRC_PPM_H_
#include "utilities.h" #include "utilities.h"
@ -34,4 +34,4 @@ int imageLoadPPM(const char *filename, Image *img);
/// \brief Ouverture et écriture de l'image de sortie /// \brief Ouverture et écriture de l'image de sortie
void imageSavePPM(char *filename, Image *img); void imageSavePPM(char *filename, Image *img);
#endif /* IMGTACHES_SRC_PPM_H_ */ #endif /* SRC_PPM_H_ */

8
src/utilities.c
View File

@ -53,9 +53,7 @@ Image *newImage() {
* \param[in] self Conteneur d’image à détruire * \param[in] self Conteneur d’image à détruire
*/ */
void deleteImage(Image *t_self) { void deleteImage(Image *t_self) {
DEBUG { DEBUG { printf("deleted all pixels\n"); }
printf("deleted all pixels\n");
}
darrayDelete(t_self->pixels); darrayDelete(t_self->pixels);
free(t_self); free(t_self);
} }
@ -104,6 +102,4 @@ Zone *newZone(uint8_t t_r, uint8_t t_g, uint8_t t_b) {
* *
* \param[in] self Conteneur de zone à détruire * \param[in] self Conteneur de zone à détruire
*/ */
void deleteZoneContent(Zone *t_self) { void deleteZoneContent(Zone *t_self) { darrayDelete(t_self->segments); }
darrayDelete(t_self->segments);
}

29
src/utilities.h
View File

@ -7,11 +7,10 @@
* utilitaires pour la manipulation de ces structures. * utilitaires pour la manipulation de ces structures.
*/ */
#ifndef UTILITIES_H #ifndef SRC_UTILITIES_H_
#define UTILITIES_H #define SRC_UTILITIES_H_
#include "darray.h" #include "darray.h"
/* #include <GL/gl.h> */
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
@ -52,9 +51,9 @@ typedef struct Segment Segment;
* dans un tableau dynamique \ref darray. * dans un tableau dynamique \ref darray.
*/ */
struct Image { struct Image {
uint64_t x; /*!< Largeur de l’image */ uint64_t x; /*!< Largeur de l’image */
uint64_t y; /*!< Hauteur de l’image */ uint64_t y; /*!< Hauteur de l’image */
darray *pixels; /*!< Vecteur à une dimention de pixels */ darray *pixels; /*!< Vecteur à une dimention de pixels */
}; };
/** /**
@ -65,9 +64,9 @@ struct Image {
* visité précédemment par l’algorithme de compression. * visité précédemment par l’algorithme de compression.
*/ */
struct Pixel { struct Pixel {
uint8_t r; /*!< Couleur rouge du pixel */ uint8_t r; /*!< Couleur rouge du pixel */
uint8_t g; /*!< Couleur verte du pixel */ uint8_t g; /*!< Couleur verte du pixel */
uint8_t b; /*!< Couleur bleue du pixel */ uint8_t b; /*!< Couleur bleue du pixel */
unsigned char visited; /*!< Le pixel a-t-il été visité avant */ unsigned char visited; /*!< Le pixel a-t-il été visité avant */
}; };
@ -78,10 +77,10 @@ struct Pixel {
* dont on conserve uniquement les marges dans le tableau dynamique. * dont on conserve uniquement les marges dans le tableau dynamique.
*/ */
struct Zone { struct Zone {
uint8_t r; /*!< Couleur rouge de la zone */ uint8_t r; /*!< Couleur rouge de la zone */
uint8_t g; /*!< Couleur verte de la zone */ uint8_t g; /*!< Couleur verte de la zone */
uint8_t b; /*!< Couleur bleue de la zone */ uint8_t b; /*!< Couleur bleue de la zone */
darray *segments; /*!< Vecteur de segments */ darray *segments; /*!< Vecteur de segments */
}; };
/** /**
@ -109,8 +108,8 @@ void deleteImage(Image *t_self);
/// \brief Constructeur d’un segment de couleur unie /// \brief Constructeur d’un segment de couleur unie
Segment *newSegment(uint32_t t_xd, uint32_t t_xg); Segment *newSegment(uint32_t t_xd, uint32_t t_xg);
/// \brief Constructeur de conteneur de zone /// \brief Constructeur de conteneur de zone
Zone* newZone(uint8_t t_r, uint8_t t_g, uint8_t t_b); Zone *newZone(uint8_t t_r, uint8_t t_g, uint8_t t_b);
/// \brief Destructeur de conteneur de zone /// \brief Destructeur de conteneur de zone
void deleteZoneContent(Zone *t_self); void deleteZoneContent(Zone *t_self);
#endif /* UTILITIES_H */ #endif /* SRC_UTILITIES_H_ */