.gitignore

@@ -12,3 +12,7 @@ build/*
 
 !*/.gitkeep 
 !doc/doxyfile
+
+doc/html
+bin/*
+obj/*

Makefile

+all: bin/test bin/exemple bin/affichage
+
+
+bin/test: obj/mainTest.o obj/Pixel.o obj/Image.o
+	g++ -g obj/mainTest.o obj/Pixel.o obj/Image.o -o bin/test
+	
+	
+bin/exemple: obj/mainExemple.o obj/Pixel.o obj/Image.o
+	g++ -g obj/mainExemple.o obj/Pixel.o obj/Image.o -o bin/exemple
+	
+
+bin/affichage: obj/mainAffichage.o obj/ImageViewer.o obj/Image.o obj/Pixel.o
+	g++ -g obj/mainAffichage.o obj/ImageViewer.o obj/Image.o obj/Pixel.o -o bin/affichage -lSDL2 -lSDL2_ttf -lSDL2_image
+	
+	
+obj/mainTest.o: src/mainTest.cpp src/Pixel.h src/Image.h
+	g++ -g -Wall -c src/mainTest.cpp -o obj/mainTest.o
+            
+obj/Pixel.o: src/Pixel.cpp src/Pixel.h
+	g++ -g -Wall -c src/Pixel.cpp -o obj/Pixel.o
+	
+obj/Image.o: src/Image.cpp src/Image.h src/Pixel.h
+	g++ -g -Wall -c src/Image.cpp -o obj/Image.o
+	
+obj/mainExemple.o: src/mainExemple.cpp src/Image.h src/Pixel.h
+	g++ -g -Wall -c src/mainExemple.cpp -o obj/mainExemple.o
+
+	
+obj/ImageViewer.o: src/ImageViewer.cpp src/ImageViewer.h src/Image.h
+	g++ -g -Wall -c src/ImageViewer.cpp -o obj/ImageViewer.o -lSDL2 -lSDL2_ttf -lSDL2_image
+	
+obj/mainAffichage.o: src/mainAffichage.cpp src/ImageViewer.h src/Image.h
+	g++ -g -Wall -c src/mainAffichage.cpp -o obj/mainAffichage.o
+	
+doc: doc/doxyfile
+	cd doc ; doxygen doxyfile
+ 	
+clean:	
+	rm -rf obj/* bin/* doc/html
+
+veryclean: clean
+	rm bin/* obj/*

README.md

@@ -4,3 +4,13 @@ Ce dépôt est le dépôt de départ du module Image à rendre. Son seul avantag
 
 Pour commencer à travailler, il faut faire un `fork` de ce projet. Ajouter les membres du groupe.
 Pour voir le résultat de l'exécution du script, il faut aller sur la forge dans le menu `Build/Jobs` et cliquer sur le dernier run.
+
+# Module Image, UE LIFAPCD
+## Contributeurs et License
+## Pour compiler
+## Les fichiers
+## Bugs
+- Lors du premier test des fonctions "sauver" et "ouvrir" le repertoire "data" n'existait pas.
+- Les coordonnées des pixels de l'image sauvé ne sont pas corrects, ils sont divisés par deux.
+- Dans la fontion "sauver" les variables r,g,b ne sont pas des entiers (char) et ne correspondent donc pas à des couleurs pour les pixels de l'image à sauver.
+- Dans la fonciton "sauver" les couleurs du fichier sources ne sont pas récupérés dans le bon ordre 

src/Image.cpp

+#include "Image.h"
+#include <iostream>
+#include <cassert>
+#include <fstream>
+
+using namespace std;
+
+Image::Image()
+{
+    cout<<"tab alloué : "<<tab<<endl;
+    tab = nullptr;
+    dimx = 0;
+    dimy = 0;
+
+}
+
+Image::Image(unsigned int dimensionX, unsigned int dimensionY)
+{
+    assert (dimensionX>0 && dimensionY>0);
+
+    dimx = dimensionX;
+    dimy = dimensionY;
+    tab = new Pixel [dimx*dimy];
+    for(unsigned int i = 0; i<dimx*dimy; i++)
+    {
+        tab[i] = Pixel(0,0,0);
+    }
+
+}
+
+Image::~Image()
+{
+    dimx = 0;
+    dimy = 0;
+    if (tab != nullptr)
+    {
+        delete [] tab;
+        tab = nullptr;
+    }
+    
+    
+    cout<<"tab détruit : "<<tab<<endl;
+}
+
+
+Pixel & Image::getPix(unsigned int x, unsigned int y)
+{
+    assert (x>=0 && y>=0);
+    assert (x<dimx && y<dimy);
+
+    return tab[y*dimx+x];
+}
+
+Pixel Image::getPix2(unsigned int x, unsigned int y) const
+{
+    assert (x>=0 && y>=0); 
+    assert (x<dimx && y<dimy);
+
+    Pixel ret = tab[y*dimx+x];
+
+    return ret;
+}
+
+void Image::setPix(const unsigned int &x, const unsigned int &y, const Pixel &couleur)
+{
+    tab[y*dimx+x] = couleur;
+}
+
+void Image::dessinerRectangle(unsigned int Xmin, unsigned int Ymin, unsigned int Xmax, unsigned int Ymax, const Pixel & couleur)
+{
+    unsigned int i,j;
+
+    for(i=Xmin;i<Xmax;i++)
+    {
+        for(j=Ymin;j<Ymax;j++)
+        {
+            setPix(i,j,couleur);
+
+        }
+    }
+}
+
+void Image::effacer (const Pixel & couleur)
+{
+    dessinerRectangle(0,0,dimx,dimy,couleur);
+}
+
+void Image::testRegression()
+{
+    cout<<"test de regression : "<<endl;
+    Image im1;
+    assert (im1.dimx == 0);
+    assert (im1.dimy == 0);
+
+    Image im2(50,50);
+    assert (im2.dimx == 50);
+    assert (im2.dimy == 50);
+
+    Pixel p1 = im2.getPix(14,26);
+    assert(p1.r == 0);
+    assert(p1.g == 0);
+    assert(p1.b == 0);
+
+    Pixel p2(145,78,153);
+    im2.dessinerRectangle(10,10,30,30,p2);
+    p1 = im2.getPix(18,22);
+    cout<<int(p1.r)<<" "<<int(p1.g)<<" "<<int(p1.b)<<endl;
+
+    im2.effacer(Pixel(0,0,0));
+    p2 = im2.getPix(18,22);
+    cout<<int(p2.r)<<" "<<int(p2.g)<<" "<<int(p2.b)<<endl;
+
+
+
+    
+
+    cout<<"fin test"<<endl;
+}
+
+void Image::sauver(const string &filename) const
+{
+    ofstream fichier(filename.c_str());
+    assert(fichier.is_open());
+    fichier << "P3" << endl;
+    fichier << dimx << " " << dimy << endl;
+    fichier << "255" << endl;
+    for (unsigned int y = 0; y < dimy; y++)
+        for (unsigned int x = 0; x < dimx; x++)
+        {
+            Pixel pix = getPix2(x, y);
+            fichier << int(pix.r) << " " << int(pix.g) << " " << int(pix.b) << " ";
+            //cout<<x<<" , "<<y<<endl;
+        }
+    cout << "Sauvegarde de l'image " << filename << " ... OK\n";
+    fichier.close();
+}
+
+void Image::ouvrir(const string &filename)
+{
+    ifstream fichier(filename.c_str());
+    assert(fichier.is_open());
+    unsigned char r, g, b;
+    string mot;
+    dimx = dimy = 0;
+    fichier >> mot >> dimx >> dimy >> mot;
+    cout<<dimx<<","<<dimy<<endl;
+    assert(dimx > 0 && dimy > 0);
+    if (tab != nullptr)
+        delete[] tab;
+    tab = new Pixel[dimx * dimy];
+    for (unsigned int y = 0; y < dimy; y++)
+        for (unsigned int x = 0; x < dimx; x++)
+        {
+            fichier >> r >> g >> b;
+            //cout<<r<<" , "<<g<<" , "<<b<<endl;
+            getPix(x, y).r = char(r);
+            getPix(x, y).g = char(g);
+            getPix(x, y).b = char(b);
+        }
+    fichier.close();
+    cout << "Lecture de l'image " << filename << " ... OK\n";
+}
+
+void Image::afficherConsole()
+{
+    cout << dimx << " " << dimy << endl;
+    for (unsigned int y = 0; y < dimy; ++y)
+    {
+        for (unsigned int x = 0; x < dimx; ++x)
+        {
+            Pixel &pix = getPix(x, y);
+            cout << pix.r << " " << pix.g << " " << pix.b << " ";
+        }
+        cout << endl;
+    }
+}
+
+
+Pixel * Image::getTab()const
+{
+    return tab;
+}
+

src/Image.h

+#ifndef _IMAGE_H
+#define _IMAGE_H
+#include "Pixel.h"
+#include <iostream>
+
+using namespace std;
+
+class Image
+{
+    private:
+        unsigned int dimx;///< Entiers non-signés représentant la dimensions X de l'image.
+        unsigned int dimy;///< Entiers non-signés représentant la dimensions Y de l'image.
+        Pixel* tab;
+    
+
+    public:
+        Image();
+        Image(unsigned int dimensionX, unsigned int dimensionY);
+        ~Image();
+        static void testRegression();
+        Pixel & getPix(unsigned int x, unsigned int y);
+        Pixel getPix2(unsigned int x, unsigned int y)const;
+        void setPix(const unsigned int &x, const unsigned int &y, const Pixel &couleur);
+        void dessinerRectangle(unsigned int Xmin, unsigned int Ymin, unsigned int Xmax, unsigned int Ymax, const Pixel & couleur);
+        void effacer (const Pixel & couleur);
+        Pixel * getTab()const;
+        void sauver(const string &filename) const;
+        void ouvrir(const string &filename);
+        void afficherConsole();
+
+    
+    
+};
+
+/**
+ * @class Image
+ *
+ * @brief La classe Image contient deux entier dimx et dimy (dimensions de l'image), un tableau de Pixel ainsi que des fonctions et procédure permettant la manipulation de l'image et des pixels qui la composent.
+ *
+ */
+
+/**
+* \fn  Image::Image()
+ * @brief Constructeur par défaut de la classe Image: initialise dimx et dimy à 0. 
+ * N’alloue aucune mémoire pour le tableau de pixel.
+ * 
+ * @return Renvoi une Image dont les dimensions dimx et dimy sont égales à 0.
+ */
+
+/**
+* \fn  Image::Image(const unsigned int &x, const unsigned int &y)
+ * @brief Constructeur de la classe Image: initialise dimx et dimy avec les paramètres x et y. 
+ * Alloue le tableau de pixel dans le tas (image noire).
+ * 
+ * @return Renvoi l'instance de l'Image crée avec les dimensions dimx et dimy étant égales à x et y et le tableau de pixel initialisé selon les dimensions.
+ */
+
+/**
+* \fn  Image::~Image()
+ * @brief Destructeur de la classe : déallocation de la mémoire du tableau de pixels et mise à jour des champs dimx et dimy à 0. 
+ * 
+ * 
+ * @return Renvoi l'instance de l'Image vide avec les dimensions à 0.
+ */
+
+/**
+* \fn Pixel & Image::getPix(const unsigned int &x, const unsigned int &y) const;
+ * @brief Récupère le pixel original de coordonnées (x,y) en vérifiant sa validité. 
+ * 
+ * @return Renvoi le Pixel de coordonnée (x,y).
+ */
+
+/**
+* \fn Pixel Image::getPix2(const unsigned int &x, const unsigned int &y) const
+ * @brief Récupère la copie du pixel de coordonnées (x,y) en vérifiant sa validité. 
+ * 
+ * @return Renvoi une copie du Pixel de coordonnée (x,y).
+ */
+
+/**
+* \fn void Image::setPix(int x,int y,Pixel p)
+ * @brief Modifie le pixel de coordonnées (x,y). 
+ * 
+ */
+
+/**
+* \fn void Image::dessinerRectangle(unsigned Xmin, unsigned int Ymin, unsigned int Xmax, unsigned int Ymax, const Pixel & couleur)
+ * @brief Dessine un rectangle plein de la couleur dans l'image (en utilisant setPix, indices en paramètre compris).
+ * @param p Pixel contenant la couleur qui sera remplie dans le rectangle.
+ * @param Xmin, Ymin, Xmax, Ymax Dimension du rectangle à remplir.
+ */
+
+/**
+* \fn void Image::effacer (const Pixel & couleur)
+ * @brief Efface l'image en la remplissant de la couleur en paramètre (en appelant dessinerRectangle avec le bon rectangle). 
+ * 
+ */
+
+/**
+* \fn void Image::testRegression()
+ * @brief Effectue une série de tests vérifiant que toutes les fonctions fonctionnent et font bien ce qu’elles sont censées faire, ainsi que les données membres de l'objet sont conformes.
+ * 
+ */
+
+/**
+* \fn void Image::sauver(const std::string &filename)const
+ * @brief Permet de sauver les pixels de l'image dans un fichier.
+ * @param filename Chemin vers le fichier dans lequel l'image sera sauver.
+ */
+
+/**
+* \fn void Image::ouvrir(const std::string &filename)
+ * @brief Permet de récupérer les pixels de l'image dans un fichier.
+ * @param filename Chemin vers le fichier depuis lequel l'image sera récuperer.
+ */
+
+/**
+* \fn void Image::afficherConsole()
+ * @brief Permet d'afficher les valeurs des pixels de l'image sur la console
+ *
+ */
+
+#endif
+
+

src/ImageViewer.cpp

+#include <cassert>
+#include <time.h>
+#include <stdlib.h>
+#include <iostream>
+#include <filesystem>
+#include<fstream>
+
+#include "ImageViewer.h"
+
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_image.h>
+#include <SDL2/SDL_ttf.h>
+
+#include <iostream>
+using namespace std;
+
+
+ImageViewer::ImageViewer()
+{
+   m_surface = nullptr; 
+   m_texture = nullptr; 
+   //m_hasChanged = false;
+
+   // Initialisation de la SDL
+   cout << "SDL: init" << endl;
+   if (SDL_Init(SDL_INIT_VIDEO) < 0)
+   {
+       cout << "Erreur lors de l'initialisation de la SDL : " << SDL_GetError() << endl;
+       SDL_Quit();
+       exit(1);
+   }
+
+   cout << "SDL_ttf: init" << endl;
+   if (TTF_Init() != 0)
+   {
+       cout << "Erreur lors de l'initialisation de la SDL_ttf : " << TTF_GetError() << endl;
+       SDL_Quit();
+       exit(1);
+   }
+
+   int imgFlags = IMG_INIT_PNG | IMG_INIT_JPG;
+   cout << "SDL_image: init" << endl;
+   if (!(IMG_Init(imgFlags) & imgFlags))
+   {
+       cout << "SDL_m_image could not initialize! SDL_m_image Error: " << IMG_GetError() << endl;
+       SDL_Quit();
+       exit(1);
+   }
+
+   int dimx, dimy;
+   dimx = 200;
+   dimy = 200;
+
+   // Creation de la fenetre
+   window = SDL_CreateWindow("Module Image", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, dimx, dimy, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
+   if (window == NULL)
+   {
+       cout << "Erreur lors de la creation de la fenetre : " << SDL_GetError() << endl;
+       SDL_Quit();
+       exit(1);
+   }
+
+   renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+   if (renderer == nullptr)
+   {
+       cout << "Erreur lors de la creation du renderer : " << SDL_GetError() << endl;
+       SDL_Quit();
+       exit(1);
+   }
+
+}
+
+ImageViewer::~ImageViewer()
+{
+    m_surface = nullptr;
+    m_texture = nullptr;
+   // m_hasChanged = false;
+
+    TTF_Quit();
+    SDL_FreeSurface(m_surface);
+    SDL_DestroyTexture(m_texture);
+    SDL_DestroyRenderer(renderer);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+}
+
+void ImageViewer::setSurfText(const Image & im)
+{
+    /*
+    Uint32 rmask, gmask, bmask, amask;
+    rmask = 0xff000000;
+    gmask = 0x00ff0000;
+    bmask = 0x0000ff00;
+    amask = 0x00000000;
+    */
+  
+
+    //im.ouvrir("./data/image1.ppm");
+
+    //m_surface = SDL_CreateRGBSurfaceFrom(im.getTab(),200,200,24,3*200,rmask,gmask,bmask,amask);
+    m_surface = IMG_Load("./data/pacman.png");
+    if (m_surface == nullptr)
+    {
+        cout << "Erreur lors de la création de la surface : " << SDL_GetError() << endl;
+       SDL_Quit();
+       exit(1);
+    }
+
+    m_texture = SDL_CreateTextureFromSurface(renderer,m_surface);
+}
+
+void ImageViewer::afficher(const Image & im)const
+{
+    SDL_Event events;
+    bool quit = false;
+
+    while (!quit)
+    {
+
+        // tant qu'il y a des evenements à traiter (cette boucle n'est pas bloquante)
+        while (SDL_PollEvent(&events))
+        {
+            if (events.type == SDL_QUIT)
+                quit = true; // Si l'utilisateur a clique sur la croix de fermeture
+            else if (events.type == SDL_KEYDOWN)
+            {
+                switch (events.key.keysym.scancode)
+                {
+                case SDL_SCANCODE_ESCAPE:
+                case SDL_SCANCODE_Q:
+                    quit = true;
+                    break;
+                default:
+                    break;
+                }
+            }
+        }
+
+        // on affiche le jeu sur le buffer caché
+        SDL_SetRenderDrawColor(renderer, 169, 169, 169, 255);
+        SDL_RenderClear(renderer);
+        // on permute les deux buffers (cette fonction ne doit se faire qu'une seule fois dans la boucle)
+        SDL_RenderPresent(renderer);
+    }
+
+ }

src/ImageViewer.h

+#ifndef _IMAGEVIEWER_H
+#define _IMAGEVIEWER_H
+
+#include "Image.h"
+#include <SDL2/SDL.h>
+
+/**
+* \fn  ImageViewer::ImageViewer()
+ * @brief Constructeur qui initialise tout SDL2 et crée la fenêtre et le rendere.
+ * 
+ */
+
+
+
+class ImageViewer
+{
+    private :
+    SDL_Window * window;
+    SDL_Renderer * renderer;
+    SDL_Surface * m_surface;
+    SDL_Texture * m_texture;
+    
+
+    public :
+    ImageViewer(); // Constructeur qui initialise tout SDL2 et crée la fenêtre et le renderer
+    ~ImageViewer(); // Détruit et ferme SDL2
+    void setSurfText(const Image & im);
+    void afficher(const Image & im)const;
+
+};
+
+
+#endif

src/Pixel.cpp

+#include "Pixel.h"
+#include <cassert>
+#include <iostream>
+
+Pixel::Pixel()
+{
+    r = 0;
+    g = 0;
+    b = 0;
+}
+
+Pixel::Pixel(const unsigned int & x,const unsigned int & y, const unsigned int &z)
+{
+    assert(x>=0 && x<=255);
+    assert(y>=0 && y<=255);
+    assert(z>=0 && z<=255);
+    r = char(x);
+    g = char(y);
+    b = char(z);
+}
+
+

src/Pixel.h

+#ifndef _PIXEL_H
+#define _PIXEL_H
+
+/**
+ * @class Pixel
+ *
+ * @brief La classe Pixel contient trois données membres qui sont des entiers non-signés. Ces trois entiers représentent la couleur du pixel sous la forme RGB.
+ *
+ */
+
+/**
+ * \fn  Pixel::Pixel(int x,int y, int z)
+ * @brief Constructeur de la classe pixel : initialise r,g,b avec les paramètres.
+ * 
+ * @param x Le niveau de rouge.
+ * @param y Le niveau de vert.
+  * @param y Le niveau de bleu.
+ * @return Renvoi un pixel dont les données membres r,g,b sont initialisé avec les paramètres.
+ */
+
+/**
+* \fn  Pixel::Pixel()
+ * @brief Constructeur par défaut de la classe pixel: initialise le pixel à la couleur noire.
+ * 
+ * @return Renvoi un pixel dont les données membres r,g,b sont égales à 0.
+ */
+
+
+struct Pixel
+{
+    unsigned char r; ///< caractère non-signés représentant le niveau de rouge dans la couleur du Pixel.
+    unsigned char g; ///< caractère non-signés représentant le niveau de vert dans la couleur du Pixel.
+    unsigned char b; ///< caractère non-signés représentant le niveau de bleu dans la couleur du Pixel.
+
+    Pixel();
+    Pixel(const unsigned int &ro, const unsigned int &ve, const unsigned int &bl);   
+};
+
+#endif
\ No newline at end of file

src/mainAffichage.cpp

+#include "Image.h"
+#include "ImageViewer.h"
+
+int main (int argc, char** argv) 
+{
+    Image image (12,12);
+    Pixel blanc (255, 255, 255);
+    Pixel noir (0, 0, 0);
+    Pixel rouge (232, 37, 37);
+    Pixel beige (247, 208, 153);
+    Pixel vert (166,222,135);
+    image.effacer(vert);
+    image.dessinerRectangle(1,1,10,6,rouge);
+    image.dessinerRectangle(1,2,2,5,blanc); 
+    image.dessinerRectangle(4,2,7,5,blanc);
+    image.dessinerRectangle(9,2,10,5,blanc);
+    image.dessinerRectangle(2,7,9,10,beige);
+    image.setPix(4,8,noir);
+    image.setPix(4,9,noir);
+    image.setPix(7,8,noir);
+    image.setPix(7,9,noir);
+    ImageViewer imview;
+    imview.setSurfText(image);
+    imview.afficher(image);
+    //image.~Image();
+
+    return 0;
+}
\ No newline at end of file

src/mainExemple.cpp

+#include <iostream>
+#include "Image.h"
+using namespace std ;
+
+
+int main() {
+
+    Pixel vert (24,207,50);
+    Pixel orange (232,172,42);
+    Pixel rose (230,119,182);
+    Image image1 (128,64);
+    image1.effacer(rose);
+    image1.dessinerRectangle(10, 10, 31, 52, vert);
+    image1.setPix(20,22,orange);
+    image1.setPix(100,50,orange);
+    image1.sauver("./data/image1.ppm");
+    
+    Image image2;
+    image2.ouvrir("./data/image1.ppm");
+    image2.dessinerRectangle(80, 40, 110, 57, vert);
+    image2.dessinerRectangle(21, 26, 39, 36, orange);
+    image2.sauver("./data/image2.ppm");
+    //image1.afficherConsole();
+
+    image1.~Image();
+    image2.~Image();
+    
+    return 0;
+}
\ No newline at end of file

src/mainTest.cpp

+#include "Image.h"
+#include <iostream>
+
+using namespace std;
+
+int main (void)
+{
+    Image::testRegression();
+    return 0;
+}
\ No newline at end of file