diff --git a/src/common.c b/src/common.c index 3aefda5..caeb266 100644 --- a/src/common.c +++ b/src/common.c @@ -13,7 +13,7 @@ * \param[in] t_zone Zone à laquelle le pixel est éligible ou non * \return Valeur booléenne, `true` si le pixel est éligible, `false` sinon */ -bool sameColor(Pixel_t t_pixel, Zone_t 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,8 +31,8 @@ bool sameColor(Pixel_t t_pixel, Zone_t 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 t_img, int t_idx, Zone_t t_zone) { - Pixel_t current_pixel; +void addPixelToSelectedZone(Image* t_img, int t_idx, Zone* t_zone) { + Pixel* current_pixel; int xd, xg, y = t_idx / (int)t_img->x; current_pixel = darrayGet(t_img->pixels, t_idx); if (current_pixel->visited || t_idx >= (int)darraySize(t_img->pixels) || @@ -63,9 +63,9 @@ void addPixelToSelectedZone(Image_t t_img, int t_idx, Zone_t t_zone) { /* Selects the zone related to the pixel, skip tests if pixel has already been visited */ -void chooseZoneForPixel(Image_t t_img, int t_idx, darray_t zones) { - Zone_t current_zone; - Pixel_t pixel; +void chooseZoneForPixel(Image* t_img, int t_idx, darray *zones) { + Zone* current_zone; + Pixel* pixel; size_t i; pixel = darrayGet(t_img->pixels, t_idx); if (pixel->visited) @@ -80,8 +80,8 @@ void chooseZoneForPixel(Image_t t_img, int t_idx, darray_t zones) { } /* converts an image to zones */ -darray_t imgToZones(Image_t t_img) { - darray_t zones; +darray* imgToZones(Image* t_img) { + darray *zones; const size_t nb_pixels = darraySize(t_img->pixels); size_t i; zones = darrayNew(sizeof(Zone)); @@ -93,8 +93,8 @@ darray_t imgToZones(Image_t t_img) { } void compress(const char *input_file) { - Image_t img; - darray_t zones; + Image* img; + darray *zones; img = newImage(); imageLoadPPM(input_file, img); zones = imgToZones(img); diff --git a/src/common.h b/src/common.h index 5ddf46a..75f2cf4 100644 --- a/src/common.h +++ b/src/common.h @@ -9,11 +9,11 @@ #include "ppm.h" /// Teste l’éligibilité d’un pixel à une zone -bool sameColor(Pixel_t, Zone_t); +bool sameColor(Pixel *, Zone *); /// Ajoute un pixel et ses pixels connexes à une zone -void addPixelToSelectedZone(Image_t t_img, int t_idx, Zone_t t_zone); -void chooseZoneForPixel(Image_t t_img, int t_idx, darray_t zones); -darray_t imgToZones(Image_t t_img); -void compress(const char*); +void addPixelToSelectedZone(Image *t_img, int t_idx, Zone *t_zone); +void chooseZoneForPixel(Image *t_img, int t_idx, darray *zones); +darray *imgToZones(Image *t_img); +void compress(const char *); #endif /* COMMON_H */ diff --git a/src/darray.c b/src/darray.c index b7998a6..5cf2cc3 100644 --- a/src/darray.c +++ b/src/darray.c @@ -16,9 +16,9 @@ * \param[in] element_size Taille des objets stockés * \return Pointeur sur le nouvel objet \ref darray_t */ -darray_t darrayNew(size_t t_element_size) { - darray_t ret; - ret = (darray_t)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; @@ -28,15 +28,15 @@ darray_t darrayNew(size_t t_element_size) { /** * `darrayInsert` insère l’élément `elem` avant l'élément pointé par `pos` dans - * l’objet \ref darray_t. Cela décalera tous les éléments stockés dans \a `self` + * l’objet \ref darray. Cela décalera tous les éléments stockés dans \a `self` * 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_t 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 + * \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 */ -void darrayInsert(darray_t t_self, void *t_pos, void *t_elem) { +void darrayInsert(darray *t_self, void *t_pos, void *t_elem) { char *itr; long pos_aux; pos_aux = (char *)t_pos - (char *)t_self->begin; @@ -51,13 +51,13 @@ void darrayInsert(darray_t t_self, void *t_pos, void *t_elem) { } /** - * Étend la capacité d'un \ref darray_t en réallouant sa mémoire, multipliant + * Étend la capacité d'un \ref darray en réallouant sa mémoire, multipliant * sa capacité par deux. Si la réallocation mémoire ne réussit pas, le * programme s’arrête immédiatement, renvoyant la valeur de \ref PTR_ERROR * - * \param[in] self L'objet darray_t à étendre + * \param[in] self L'objet darray à étendre */ -void darrayExtend(darray_t t_self) { +void darrayExtend(darray *t_self) { void *new_array; size_t size; size = darraySize(t_self); @@ -74,15 +74,15 @@ void darrayExtend(darray_t t_self) { } /** - * `darrayErase` supprime l’élément de objet \ref darray_t `self` pointé par + * `darrayErase` supprime l’élément de objet \ref darray `self` pointé par * `pos`. Cela décalera tous les éléments suivants dans le tableau d’un cran * 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_t` 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 */ -void darrayErase(darray_t t_self, void *t_pos) { +void darrayErase(darray *t_self, void *t_pos) { memmove(t_pos, (char *)t_pos + t_self->element_size, (unsigned long)(((char *)t_self->end - t_self->element_size) - (char *)t_pos)); @@ -92,58 +92,58 @@ void darrayErase(darray_t 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_t à 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 t_self, void *t_elem) { +void darrayPushBack(darray *t_self, void *t_elem) { darrayInsert(t_self, t_self->end, t_elem); } /** * `darrayPopBack` permet de supprimer le dernier élément de l’objet \ref - * darray_t 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. * \param[out] self Objet dont on souhaite supprimer le dernier élément */ -void darrayPopBack(darray_t t_self) { +void darrayPopBack(darray* t_self) { darrayErase(t_self, (char *)t_self->end - t_self->element_size); } /** - * `darrayDelete` supprime tous les éléments contenus par l’objet \ref darray_t + * `darrayDelete` supprime tous les éléments contenus par l’objet \ref darray * 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_t à supprimer + * \param[out] self Objet \ref darray à supprimer */ -void darrayDelete(darray_t t_self) { +void darrayDelete(darray* t_self) { free(t_self->begin); free(t_self); } /** - * `darraySize` renvoie le nombre d’éléments contenu dans le \ref darray_t + * `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_t 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 t_self) { +size_t darraySize(darray* t_self) { return (size_t)((char *)t_self->end - (char *)t_self->begin) / t_self->element_size; } /** - * `darrayGet` permet de récupérer un élément d’un objet \ref darray_t grâce à + * `darrayGet` permet de récupérer un élément d’un objet \ref darray grâce à * son index dans le tableau de l’objet `self`. Si l’index est trop grand, alors * 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_t 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. */ -void *darrayGet(darray_t t_self, size_t t_idx) { +void *darrayGet(darray* t_self, size_t t_idx) { void *itr; itr = (char *)t_self->begin + t_idx * t_self->element_size; return itr; diff --git a/src/darray.h b/src/darray.h index 9e5f512..8effd69 100644 --- a/src/darray.h +++ b/src/darray.h @@ -22,8 +22,6 @@ typedef struct darray_s { 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) */ } darray; -/// `darray_t` est un pointeur vers une structure de type \ref darray_s -typedef darray *darray_t; /// \brief Créé un nouvel objet \ref darray vide darray *darrayNew(size_t element_size); diff --git a/src/ppm.c b/src/ppm.c index b1d55a5..0b20f0a 100644 --- a/src/ppm.c +++ b/src/ppm.c @@ -152,8 +152,8 @@ 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 t_img) { - Pixel_t pixel; +unsigned char *imageToData(Image* t_img) { + Pixel* pixel; unsigned char *data, size; unsigned long i; size = (unsigned char)darraySize(t_img->pixels); @@ -181,7 +181,6 @@ int imageLoadPPM(const char *t_filename, Image *t_img) { FILE *fp; unsigned long size; unsigned char *data = NULL; - printf("Hey auie\n"); fp = get_file(t_filename, "rb"); /* open PPM file for reading */ read_file_format(fp, t_filename); /* read image format */ check_for_comments(fp); /* check for comments */ @@ -200,7 +199,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 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 28f2891..17edf08 100644 --- a/src/ppm.h +++ b/src/ppm.h @@ -28,10 +28,10 @@ unsigned long read_data(FILE *fp, Image *img, unsigned char **data, /// \brief Convertit les données brutes de fichier vers des conteneurs de pixels void dataToImage(Image *img, unsigned char *data, unsigned long size); /// \brief Convertit les pixels d’une image en tableau natif OpenGL -unsigned char *imageToData(Image_t img); +unsigned char *imageToData(Image *img); /// \brief Ouverture et lecture de l’image d’entrée -int imageLoadPPM(const char *filename, Image_t img); +int imageLoadPPM(const char *filename, Image *img); /// \brief Ouverture et écriture de l'image de sortie -void imageSavePPM(char *filename, Image_t img); +void imageSavePPM(char *filename, Image *img); #endif /* IMGTACHES_SRC_PPM_H_ */ diff --git a/src/utilities.c b/src/utilities.c index 5dd1561..895f28d 100644 --- a/src/utilities.c +++ b/src/utilities.c @@ -18,9 +18,9 @@ * \param[in] b Valeur bleue du pixel * \return Pointeur sur une structure de type \ref Pixel */ -Pixel_t newPixel(uint8_t t_r, uint8_t t_g, uint8_t t_b) { - Pixel_t res; - res = (Pixel_t)malloc(sizeof(Pixel)); +Pixel *newPixel(uint8_t t_r, uint8_t t_g, uint8_t t_b) { + Pixel *res; + res = (Pixel *)malloc(sizeof(Pixel)); res->r = t_r; res->g = t_g; res->b = t_b; @@ -36,9 +36,7 @@ Pixel_t newPixel(uint8_t t_r, uint8_t t_g, uint8_t t_b) { * * \param[in] self Pointeur vers le pixel à détruire */ -void deletePixel(Pixel_t t_self) { - free(t_self); -} +void deletePixel(Pixel *t_self) { free(t_self); } /** * Constructeur d’un conteneur d’image. Les dimensions sont initialisées à zéro @@ -47,9 +45,9 @@ void deletePixel(Pixel_t t_self) { * * \return Pointeur vers une structure \ref Image initialisée. */ -Image_t newImage() { - Image_t res; - res = (Image_t)malloc(sizeof(Image)); +Image *newImage() { + Image *res; + res = (Image *)malloc(sizeof(Image)); res->x = 0; res->y = 0; res->pixels = darrayNew(sizeof(Pixel)); @@ -64,9 +62,9 @@ Image_t newImage() { * * \param[in] self Conteneur d’image à détruire */ -void deleteImage(Image_t t_self) { +void deleteImage(Image *t_self) { unsigned long i; - for(i = 0; i < darraySize(t_self->pixels); ++i) { + for (i = 0; i < darraySize(t_self->pixels); ++i) { deletePixel(darrayGet(t_self->pixels, i)); } darrayDelete(t_self->pixels); @@ -83,9 +81,9 @@ void deleteImage(Image_t t_self) { * \param[in] xg Abscisse extrême gauche du segment * \return Pointeur sur un conteneur de segment */ -Segment_t newSegment(uint16_t t_y, uint16_t t_xd, uint16_t t_xg) { - Segment_t res; - res = (Segment_t)malloc(sizeof(Segment)); +Segment *newSegment(uint16_t t_y, uint16_t t_xd, uint16_t t_xg) { + Segment *res; + res = (Segment *)malloc(sizeof(Segment)); res->y = t_y; res->xd = t_xd; res->xg = t_xg; @@ -99,9 +97,7 @@ Segment_t newSegment(uint16_t t_y, uint16_t t_xd, uint16_t t_xg) { * * \param[in] self Conteneur de segment à détruire */ -void deleteSegment(Segment_t t_self) { - free(t_self); -} +void deleteSegment(Segment *t_self) { free(t_self); } /** * \brief function description @@ -115,9 +111,9 @@ void deleteSegment(Segment_t t_self) { * \param[in] b Valeur bleue de la couleur de la zone * \return Pointeur vers la structure créée */ -Zone_t newZone(uint8_t t_r, uint8_t t_g, uint8_t t_b) { - Zone_t res; - res = (Zone_t)malloc(sizeof(Zone)); +Zone *newZone(uint8_t t_r, uint8_t t_g, uint8_t t_b) { + Zone *res; + res = (Zone *)malloc(sizeof(Zone)); res->r = t_r; res->g = t_g; res->b = t_b; @@ -133,15 +129,15 @@ Zone_t newZone(uint8_t t_r, uint8_t t_g, uint8_t t_b) { * * \param[in] self Conteneur de zone à détruire */ -void deleteZone(Zone_t t_self) { +void deleteZone(Zone *t_self) { unsigned long i; - for(i = 0; i < darraySize(t_self->segments); ++i) { + for (i = 0; i < darraySize(t_self->segments); ++i) { deleteSegment(darrayGet(t_self->segments, i)); } darrayDelete(t_self->segments); free(t_self); } -Pixel_t imgAt(Image_t t_img, int t_x, int t_y) { - return (Pixel_t)darrayGet(t_img->pixels, t_x + t_y * t_img->x); +Pixel *imgAt(Image *t_img, int t_x, int t_y) { + return (Pixel *)darrayGet(t_img->pixels, t_x + t_y * t_img->x); } diff --git a/src/utilities.h b/src/utilities.h index 03d795f..b66444d 100644 --- a/src/utilities.h +++ b/src/utilities.h @@ -38,16 +38,12 @@ struct Image; typedef struct Image Image; -typedef Image *Image_t; struct Pixel; typedef struct Pixel Pixel; -typedef Pixel *Pixel_t; struct Zone; typedef struct Zone Zone; -typedef Zone *Zone_t; struct Segment; typedef struct Segment Segment; -typedef Segment *Segment_t; /*****************************************************************************/ /* STRUCT IMPLEMENTATION */ @@ -59,12 +55,12 @@ typedef Segment *Segment_t; * Une image est une structure définie par ses dimensions verticales et * horizontales x et y, et contenant pour chacune des coordonnées possibles * selon ses dimensions un pixel de type \ref Pixel. Ces pixels sont stockés - * dans un tableau dynamique \ref darray_t. + * dans un tableau dynamique \ref darray. */ struct Image { uint64_t x; /*!< Largeur de l’image */ uint64_t y; /*!< Hauteur de l’image */ - darray_t pixels; /*!< Vecteur à une dimention de pixels */ + darray *pixels; /*!< Vecteur à une dimention de pixels */ }; /** @@ -91,7 +87,7 @@ 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_t segments; /*!< Vecteur de segments */ + darray *segments; /*!< Vecteur de segments */ }; /** @@ -112,22 +108,22 @@ struct Segment { /*****************************************************************************/ /// \brief Création d’un nouveau pixel -Pixel_t newPixel(uint8_t t_r, uint8_t t_g, uint8_t t_b); +Pixel *newPixel(uint8_t t_r, uint8_t t_g, uint8_t t_b); /// \brief Destruction d’un pointeur de pixel -void deletePixel(Pixel_t t_self); +void deletePixel(Pixel *t_self); /// \brief Création d’une nouvelle image -Image_t newImage(); +Image *newImage(); /// \brief Destructeur d’une image -void deleteImage(Image_t t_self); +void deleteImage(Image *t_self); /// \brief Constructeur d’un segment de couleur unie -Segment_t newSegment(uint16_t t_y, uint16_t t_xd, uint16_t t_xg); +Segment *newSegment(uint16_t t_y, uint16_t t_xd, uint16_t t_xg); /// \brief Destructeur d’un segment de couleur unie -void deleteSegment(Segment_t t_self); +void deleteSegment(Segment *t_self); /// \brief Constructeur de conteneur de zone -Zone_t 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 deleteZone(Zone_t t_self); +void deleteZone(Zone *t_self); /// \brief Renvoie un pixel aux coordonnées `(x, y)` dans une image -Pixel_t imgAt(Image_t t_img, int t_x, int t_y); +Pixel *imgAt(Image *t_img, int t_x, int t_y); #endif /* UTILITIES_H */