surfaces-unies/src/utilities.c

/**
 *   \file utilities.c
 *   \brief Implémentation des fonctions utilitaires
 *
 *  Dans ce fichier sont implémentées les fonctions utilitaires pour la
 *  manipulation des structures de données déclarées dans le fichier header
 *  correspondant.
 */

#include "utilities.h"

/**
 *  Créé un nouveau pixel initialisé avec les arguments `r`, `g` et `b` et
 *  renvoie un pointeur vers ce pixel créé.
 *
 *  \param[in] t_r Valeur rouge du pixel
 *  \param[in] t_g Valeur verte du pixel
 *  \param[in] t_b Valeur bleue du pixel
 *  \return Pointeur sur une structure de type \ref 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;
  res->visited = 0;
  return res;
}

/**
 *  Constructeur d’un conteneur d’image. Les dimensions sont initialisées à zéro
 *  (0) et son tableau de pixels a été créé et initialisé en tableau vide. Le
 *  constructeur renvoie un pointeur vers la nouvelle structure \ref Image.
 *
 *  \return Pointeur vers une structure \ref Image initialisée.
 */
Image *newImage() {
  Image *res;
  res = (Image *)malloc(sizeof(Image));
  res->x = 0;
  res->y = 0;
  res->pixels = darrayNew(sizeof(Pixel));
  return res;
}

/**
 *  Destructeur d’un conteneur d’image. Le destructeur appellera le destructeur
 *  du vecteur de pixels qui sera libéré de la mémoire, puis ultimement le
 *  destructeur libérera la structure \ref Image pointée par le pointeur passé
 *  en argument.
 *
 *  \param[in] t_self Conteneur d’image à détruire
 */
void deleteImage(Image *t_self) {
  DEBUG { printf("deleted all pixels\n"); }
  darrayDelete(t_self->pixels);
  free(t_self);
}

/**
 *  Constructeur d’un conteneur de segment. Le constructeur va initialiser les
 *  valeurs qu’il contiendra avec les arguments qui lui seront passés lors de
 *  l’appel de la fonction.
 *
 *  \param[in] t_right_limit Abscisse extrême droite du segment
 *  \param[in] t_left_limit Abscisse extrême gauche du segment
 *  \return Pointeur sur un conteneur de segment
 */
Segment *newSegment(uint32_t t_right_limit, uint32_t t_left_limit) {
  Segment *res = (Segment *)malloc(sizeof(Segment));
  res->right_limit = t_right_limit;
  res->left_limit = t_left_limit;
  return res;
}

/**
 *  \brief function description
 *
 *  Constructeur de conteneur de zone, initialise grâce aux arguments la couleur
 *  de la zone et initialise un tableau dynamique vide de \ref Segment. Renvoie
 *  un pointeur vers la structure nouvellement créée.
 *
 *  \param[in] t_r Valeur rouge de la couleur de la zone
 *  \param[in] t_g Valeur verte de la couleur de la zone
 *  \param[in] t_b Valeur bleue de la couleur de la zone
 *  \return Pointeur vers la structure créée
 */
Zone *newZone(uint8_t t_r, uint8_t t_g, uint8_t t_b) {
  Zone *res = (Zone *)malloc(sizeof(Zone));
  res->r = t_r;
  res->g = t_g;
  res->b = t_b;
  res->segments = darrayNew(sizeof(Segment));
  return res;
}

/**
 *  Destructeur de zone, libère la zone mémoire utilisée pour stocker les
 *  segments. Ne libère pas \p t_self lui-même mais son membre `segments`.
 *
 *  \param[in] t_self Conteneur de zone à détruire
 */
void deleteZoneContent(Zone *t_self) { darrayDelete(t_self->segments); }