refactored, pointers not obfuscated anymore
This commit is contained in:
Phuntsok Drak-pa
parent
e509b7402f
commit
d8c7e7d454
20
src/common.c
20
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);
|
||||
|
|
|
|||
10
src/common.h
10
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 */
|
||||
|
|
|
|||
54
src/darray.c
54
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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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_ */
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
Loading…
Reference in New Issue