refactored, pointers not obfuscated anymore

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) {
+void addPixelToSelectedZone(Image* t_img, int t_idx, Zone* t_zone) {
-  Pixel_t current_pixel;
+  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) {
+void chooseZoneForPixel(Image* t_img, int t_idx, darray *zones) {
-  Zone_t current_zone;
+  Zone* current_zone;
-  Pixel_t pixel;
+  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* imgToZones(Image* t_img) {
-  darray_t zones;
+  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;
+  Image* img;
-  darray_t zones;
+  darray *zones;
   img = newImage();
   imageLoadPPM(input_file, img);
   zones = imgToZones(img);

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 addPixelToSelectedZone(Image *t_img, int t_idx, Zone *t_zone);
-void chooseZoneForPixel(Image_t t_img, int t_idx, darray_t zones);
+void chooseZoneForPixel(Image *t_img, int t_idx, darray *zones);
-darray_t imgToZones(Image_t t_img);
+darray *imgToZones(Image *t_img);
-void compress(const char*);
+void compress(const char *);
 
 #endif /* COMMON_H */

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* darrayNew(size_t t_element_size) {
-  darray_t ret;
+  darray* ret;
-  ret = (darray_t)malloc(sizeof(darray));
+  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] self Objet \ref darray dans lequel on souhaite insérer un nouvel
- * \param[in] pos Position à laquelle on souhaite insérer un nouvel élément
+ * élément \param[in] pos Position à laquelle on souhaite insérer un nouvel
- * \param[in] elem Élément que l’on souhaite insérer
+ * é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;

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);

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) {
+unsigned char *imageToData(Image* t_img) {
-  Pixel_t pixel;
+  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 */

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_ */

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 *newPixel(uint8_t t_r, uint8_t t_g, uint8_t t_b) {
-  Pixel_t res;
+  Pixel *res;
-  res = (Pixel_t)malloc(sizeof(Pixel));
+  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) {
+void deletePixel(Pixel *t_self) { free(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 *newImage() {
-  Image_t res;
+  Image *res;
-  res = (Image_t)malloc(sizeof(Image));
+  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 *newSegment(uint16_t t_y, uint16_t t_xd, uint16_t t_xg) {
-  Segment_t res;
+  Segment *res;
-  res = (Segment_t)malloc(sizeof(Segment));
+  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) {
+void deleteSegment(Segment *t_self) { free(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 *newZone(uint8_t t_r, uint8_t t_g, uint8_t t_b) {
-  Zone_t res;
+  Zone *res;
-  res = (Zone_t)malloc(sizeof(Zone));
+  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) {
+Pixel *imgAt(Image *t_img, int t_x, int t_y) {
-  return (Pixel_t)darrayGet(t_img->pixels, t_x + t_y * t_img->x);
+  return (Pixel *)darrayGet(t_img->pixels, t_x + t_y * t_img->x);
 }

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 */