From a289cfbf2d89358f6299e8ad494ba83f8cfd86c0 Mon Sep 17 00:00:00 2001 From: Phuntsok Drak-pa Date: Sat, 24 Nov 2018 21:58:55 +0100 Subject: [PATCH] code style --- src/compress.c | 20 ++++++++++---------- src/compress.h | 10 +++++----- src/darray.c | 42 +++++++++++++++++++++++++++--------------- src/darray.h | 25 ++++++++++++++----------- src/errorcodes.h | 14 +++++++++++--- src/main.c | 14 +++++++++----- src/ppm.c | 31 ++++++++++++++++--------------- src/ppm.h | 6 +++--- src/utilities.c | 8 ++------ src/utilities.h | 29 ++++++++++++++--------------- 10 files changed, 111 insertions(+), 88 deletions(-) diff --git a/src/compress.c b/src/compress.c index fc4d111..cf856ea 100644 --- a/src/compress.c +++ b/src/compress.c @@ -13,7 +13,7 @@ * \param[in] t_zone Zone à laquelle le pixel est éligible ou non * \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 && 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[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); Pixel *current_pixel; const uint32_t y = (uint32_t)(t_idx / t_img->x); - long left_limit, right_limit; - const long xd_limit = (long)t_img->x * (y + 1); + int64_t left_limit, right_limit; + 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; } 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; } - 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 */ current_pixel = darrayGet(t_img->pixels, (size_t)left_limit); 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[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; Pixel *pixel; size_t i; @@ -117,11 +117,11 @@ void chooseZoneForPixel(Image *t_img, long t_idx, darray *zones) { darray *imgToZones(Image *t_img) { darray *zones; const size_t nb_pixels = darraySize(t_img->pixels); - long i; + int64_t i; zones = darrayNew(sizeof(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); } return zones; @@ -143,7 +143,7 @@ void compress(const char *t_input_file) { zones = imgToZones(img); deleteImage(img); - for(i = 0; i < darraySize(zones); ++i) { + for (i = 0; i < darraySize(zones); ++i) { current_zone = darrayGet(zones, i); darrayDelete(current_zone->segments); } diff --git a/src/compress.h b/src/compress.h index b6113e8..719434f 100644 --- a/src/compress.h +++ b/src/compress.h @@ -3,20 +3,20 @@ * \brief Déclaration pour la (dé)compression d’images */ -#ifndef COMPRESS_H -#define COMPRESS_H +#ifndef SRC_COMPRESS_H_ +#define SRC_COMPRESS_H_ #include "ppm.h" /// Teste l’éligibilité d’un pixel à une zone bool sameColor(Pixel *t_pixel, Zone *t_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 -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 darray *imgToZones(Image *t_img); /// Compresse l'image d'entrée void compress(const char *t_input_file); -#endif /* COMPRESS_H */ +#endif /* SRC_COMPRESS_H_ */ diff --git a/src/darray.c b/src/darray.c index cd8b77a..03fb8c8 100644 --- a/src/darray.c +++ b/src/darray.c @@ -13,12 +13,13 @@ * 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 * éléments du même type. + * * \param[in] element_size Taille des objets stockés * \return Pointeur sur le nouvel objet \ref darray_t */ -darray* darrayNew(size_t t_element_size) { - darray* ret; - ret = (darray*)malloc(sizeof(darray)); +darray *darrayNew(size_t t_element_size) { + darray *ret; + ret = (darray *)malloc(sizeof(darray)); ret->begin = NULL; ret->end = ret->begin; 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 * élément. Cette fonction modifie les membres `begin` et `end` et * potentiellement `capacity` de `self`. + * * \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 \param[in] elem Élément que l’on souhaite insérer + * élément + * \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) { char *itr; - long pos_aux; + int64_t pos_aux; pos_aux = (char *)t_pos - (char *)t_self->begin; if (darraySize(t_self) >= t_self->capacity) { 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 * entre les membres `begin` et `end` de `self`. Par ailleurs, le membre `end` * de `self` se retrouve modifié par la fonction. + * * \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 */ @@ -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 * 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` */ 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 * darray passé en argument. Cette fonction modifie le membre `end` de ce * dernier objet. + * * \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); } @@ -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. * L’objet passé en argument ne sera plus utilisable après utilisation de cette * fonction. + * * \param[out] self Objet \ref darray à supprimer */ -void darrayDelete(darray* t_self) { +void darrayDelete(darray *t_self) { free(t_self->begin); free(t_self); } @@ -123,10 +131,12 @@ void darrayDelete(darray* t_self) { * `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 * 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` */ -size_t darraySize(darray* t_self) { +size_t darraySize(darray *t_self) { return (size_t)((char *)t_self->end - (char *)t_self->begin) / 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 * sur l’élément correspondant sera renvoyé. Cette fonction ne modifie pas * 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 - * \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) { - if(t_idx >= darraySize(t_self)) { +void *darrayGet(darray *t_self, size_t t_idx) { + if (t_idx >= darraySize(t_self)) { fprintf(stderr, "Error in `darrayGet`, out of bound idx: %zu (max: %zu)\n", t_idx, darraySize(t_self)); exit(PTR_ERROR); diff --git a/src/darray.h b/src/darray.h index 8effd69..8343dd6 100644 --- a/src/darray.h +++ b/src/darray.h @@ -1,10 +1,11 @@ /** * \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 -#define DARRAY_H +#ifndef SRC_DARRAY_H_ +#define SRC_DARRAY_H_ #include "errorcodes.h" #include @@ -18,9 +19,11 @@ */ typedef struct darray_s { 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 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; /// \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 void darrayExtend(darray *self); /// \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 -void darrayErase(darray *self, void *pos); +void darrayErase(darray *self, void *pos); /// \brief Retourne l’élément du \ref darray au idx-ème index void *darrayGet(darray *self, size_t idx); /// \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 -void darrayPopBack(darray *self); +void darrayPopBack(darray *self); /// \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 size_t darraySize(darray *self); /// \brief Renvoie la taille de l’élément \ref darray size_t darrayElemSize(darray *self); -#endif /* DARRAY_H */ +#endif /* SRC_DARRAY_H_ */ diff --git a/src/errorcodes.h b/src/errorcodes.h index 1c8c575..c2c3284 100644 --- a/src/errorcodes.h +++ b/src/errorcodes.h @@ -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 #define NOERROR 0 @@ -12,4 +20,4 @@ /// Constante pour les erreurs liées au format de fichiers #define FILE_FORMAT_ERROR 4 -#endif /* ERRORCODES_H */ +#endif /* SRC_ERRORCODES_H_ */ diff --git a/src/main.c b/src/main.c index 3da6ffc..4664615 100644 --- a/src/main.c +++ b/src/main.c @@ -62,7 +62,7 @@ typedef struct Argres Argres; * \param[out] t_args Result of the arguments processing * \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) { case 0: break; case 'h': help(NOERROR); break; @@ -96,11 +96,15 @@ Argres process_args(const int t_argc, char *t_argv[]) { while (1) { int option_index = 0; static struct option long_options[] = { - {"help", no_argument, NULL, 'h'}, {"input", required_argument, NULL, 'i'}, - {"output", required_argument, NULL, 'o'}, {"compress", no_argument, NULL, 'c'}, - {"uncompress", no_argument, NULL, 'u'}, {NULL, 0, NULL, 0}}; + {"help", no_argument, NULL, 'h'}, + {"input", required_argument, NULL, 'i'}, + {"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); - if (c == -1) break; + if (c == -1) + break; get_args(&res, &c); } return res; diff --git a/src/ppm.c b/src/ppm.c index 57937fa..e322893 100644 --- a/src/ppm.c +++ b/src/ppm.c @@ -23,8 +23,8 @@ * \param[in] mode Mode du fichier à ouvrir * \return Pointeur de fichier */ -FILE* get_file(const char *t_filename, const char* t_mode) { - FILE* fp = fopen(t_filename, t_mode); +FILE *get_file(const char *t_filename, const char *t_mode) { + FILE *fp = fopen(t_filename, t_mode); if (!fp) { fprintf(stderr, "Unable to open file '%s'\n", t_filename); 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] 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]; if (!fgets(buff, sizeof(buff), t_fp)) { 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 */ -void check_for_comments(FILE* t_fp) { +void check_for_comments(FILE *t_fp) { char c; c = (char)getc(t_fp); 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[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) { fprintf(stderr, "Invalid image size (error loading '%s')\n", t_filename); 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] 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; int rgb_comp_color; /* read rgb component */ @@ -112,7 +112,8 @@ unsigned long read_data(FILE *t_fp, Image *t_img, unsigned char **t_data, /* allocation memoire */ size = t_img->x * t_img->y * 3; 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)); 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 - * d’image. La taille du tableau de `unsigned char` est la taille du tableau de - * pixels multipliée par trois du fait des trois emplacements séparés par - * couleur. + * Convertit vers un tableau de `unsigned char` les pixels contenus dans un + * conteneur d’image. La taille du tableau de `unsigned char` est la taille du + * tableau de pixels multipliée par trois du fait des trois emplacements séparés + * par couleur. * * \param[out] img Image dont les pixels doivent être convertis * \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 * \return Tableau de pointeurs de `GLuint` */ -unsigned char *imageToData(Image* t_img) { - Pixel* pixel; +unsigned char *imageToData(Image *t_img) { + Pixel *pixel; unsigned char *data, size; unsigned long i; size = (unsigned char)darraySize(t_img->pixels); 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); data[i] = pixel->r; 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] img Objet \ref Image à écrire */ -void imageSavePPM(char *t_filename, Image* t_img) { +void imageSavePPM(char *t_filename, Image *t_img) { FILE *fp; unsigned char *data; fp = get_file(t_filename, "wb"); /* open file for output */ diff --git a/src/ppm.h b/src/ppm.h index 17edf08..2f0ca7f 100644 --- a/src/ppm.h +++ b/src/ppm.h @@ -7,8 +7,8 @@ * */ -#ifndef IMGTACHES_SRC_PPM_H_ -#define IMGTACHES_SRC_PPM_H_ +#ifndef SRC_PPM_H_ +#define SRC_PPM_H_ #include "utilities.h" @@ -34,4 +34,4 @@ int imageLoadPPM(const char *filename, Image *img); /// \brief Ouverture et écriture de l'image de sortie void imageSavePPM(char *filename, Image *img); -#endif /* IMGTACHES_SRC_PPM_H_ */ +#endif /* SRC_PPM_H_ */ diff --git a/src/utilities.c b/src/utilities.c index 0d48603..4d66533 100644 --- a/src/utilities.c +++ b/src/utilities.c @@ -53,9 +53,7 @@ Image *newImage() { * \param[in] self Conteneur d’image à détruire */ void deleteImage(Image *t_self) { - DEBUG { - printf("deleted all pixels\n"); - } + DEBUG { printf("deleted all pixels\n"); } darrayDelete(t_self->pixels); 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 */ -void deleteZoneContent(Zone *t_self) { - darrayDelete(t_self->segments); -} \ No newline at end of file +void deleteZoneContent(Zone *t_self) { darrayDelete(t_self->segments); } diff --git a/src/utilities.h b/src/utilities.h index fdc7381..18c463a 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -7,11 +7,10 @@ * utilitaires pour la manipulation de ces structures. */ -#ifndef UTILITIES_H -#define UTILITIES_H +#ifndef SRC_UTILITIES_H_ +#define SRC_UTILITIES_H_ #include "darray.h" -/* #include */ #include #include #include @@ -52,9 +51,9 @@ typedef struct Segment Segment; * dans un tableau dynamique \ref darray. */ struct Image { - uint64_t x; /*!< Largeur de l’image */ - uint64_t y; /*!< Hauteur de l’image */ - darray *pixels; /*!< Vecteur à une dimention de pixels */ + uint64_t x; /*!< Largeur de l’image */ + uint64_t y; /*!< Hauteur de l’image */ + darray *pixels; /*!< Vecteur à une dimention de pixels */ }; /** @@ -65,9 +64,9 @@ struct Image { * visité précédemment par l’algorithme de compression. */ struct Pixel { - uint8_t r; /*!< Couleur rouge du pixel */ - uint8_t g; /*!< Couleur verte du pixel */ - uint8_t b; /*!< Couleur bleue du pixel */ + uint8_t r; /*!< Couleur rouge du pixel */ + uint8_t g; /*!< Couleur verte du pixel */ + uint8_t b; /*!< Couleur bleue du pixel */ 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. */ struct Zone { - uint8_t r; /*!< Couleur rouge de la zone */ - uint8_t g; /*!< Couleur verte de la zone */ - uint8_t b; /*!< Couleur bleue de la zone */ - darray *segments; /*!< Vecteur de segments */ + uint8_t r; /*!< Couleur rouge de la zone */ + uint8_t g; /*!< Couleur verte de la zone */ + uint8_t b; /*!< Couleur bleue de la zone */ + darray *segments; /*!< Vecteur de segments */ }; /** @@ -109,8 +108,8 @@ void deleteImage(Image *t_self); /// \brief Constructeur d’un segment de couleur unie Segment *newSegment(uint32_t t_xd, uint32_t t_xg); /// \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 void deleteZoneContent(Zone *t_self); -#endif /* UTILITIES_H */ +#endif /* SRC_UTILITIES_H_ */