code style

src/compress.c

@@ -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;
+  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;
   }
   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;

src/compress.h

@@ -3,20 +3,20 @@
  *   \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"
 
 /// 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_ */

src/darray.c

@@ -13,6 +13,7 @@
  * 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
  */
@@ -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
- * é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) {
   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,6 +107,7 @@ 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) {
@@ -112,6 +119,7 @@ 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) {
@@ -123,7 +131,9 @@ 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) {
@@ -137,9 +147,11 @@ 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)) {

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
+#ifndef SRC_DARRAY_H_
-#define DARRAY_H
+#define SRC_DARRAY_H_
 
 #include "errorcodes.h"
 #include <stdlib.h>
@@ -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
@@ -44,4 +47,4 @@ 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_ */

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

src/main.c

@@ -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'},
+        {"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);
-    if (c == -1) break;
+    if (c == -1)
+      break;
     get_args(&res, &c);
   }
   return res;

src/ppm.c

@@ -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
+ *  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[in] data Données à convertir en structures \ref Pixel

src/ppm.h

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

src/utilities.c

@@ -53,9 +53,7 @@ Image *newImage() {
  *  \param[in] self Conteneur d’image à détruire
  */
 void deleteImage(Image *t_self) {
-  DEBUG {
+  DEBUG { printf("deleted all pixels\n"); }
-    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) {
+void deleteZoneContent(Zone *t_self) { darrayDelete(t_self->segments); }
-  darrayDelete(t_self->segments);
-}

src/utilities.h

@@ -7,11 +7,10 @@
  *  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 <GL/gl.h> */
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -113,4 +112,4 @@ 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_ */