.gitignore

@@ -12,3 +12,5 @@ build/*
 
 !*/.gitkeep 
 !doc/doxyfile
+
+doc/html

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()
+{
+    tab = nullptr;
+    dimx = 0;
+    dimy = 0;
+}
+
+Image::Image(unsigned int x, unsigned int y)
+{
+    assert (x>0 && y>0);
+
+    dimx = x;
+    dimy = y;
+    tab = new Pixel [dimx*dimy];
+}
+
+Image::~Image()
+{
+    dimx = 0;
+    dimy = 0;
+    delete [] tab;
+    tab = NULL;
+}
+
+
+Pixel & Image::getPix(unsigned int x, unsigned int y) const
+{
+    assert (x>=0 && y>=0);
+
+    return tab[y*dimx+x];;
+}
+
+Pixel Image::getPix2(unsigned int x, unsigned int y) const
+{
+    assert (x>=0 && y>=0); 
+
+    Pixel ret = tab[y*dimx+x];
+
+    return ret;
+}
+
+void Image::setPix(unsigned int x, unsigned int y, Pixel couleur)
+{
+    tab[y*dimx+x] = couleur;
+}
+
+void Image::dessinerRectangle(unsigned Xmin, unsigned int Ymin, unsigned int Xmax, unsigned int Ymax, Pixel couleur)
+{
+    unsigned i,j;
+
+    for(i=Xmin;i<Xmax;i++)
+    {
+        for(j=Ymin;j<Ymax;j++)
+        {
+            setPix(i,j,couleur);
+
+        }
+    }
+}
+
+void Image::effacer (Pixel couleur)
+{
+    dessinerRectangle(0,0,dimx,dimy,couleur);
+}
+
+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 = getPix(x, y);
+            fichier << pix.r << " " << pix.g << " " << 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());
+    int 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 = int(r);
+            getPix(x, y).g = int(g);
+            getPix(x, y).b = int(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 dimx,dimy;
+    Pixel * tab;
+    
+
+    public:
+    Image();
+    Image(unsigned int x, unsigned int y);
+    ~Image();
+    Pixel & getPix(unsigned int x, unsigned int y) const;
+    Pixel getPix2(unsigned int x, unsigned int y) const;
+    void setPix(unsigned int x, unsigned int y, Pixel couleur);
+    void dessinerRectangle(unsigned int Xmin, unsigned int Ymin, unsigned int Xmax, unsigned int Ymax, Pixel couleur);
+    void effacer (Pixel couleur);
+    Pixel * getTab()const;
+
+    static void testRegression()
+    {
+        Pixel p;
+        Pixel p2(10,20,30);    
+
+        Image im(50,50);
+        p = im.getPix2(20,26);
+        cout<<p.r<<endl;
+        cout<<endl;
+
+        im.setPix(27,12,p2);
+        Pixel p3 = im.getPix2(27,12);
+        cout<<p3.r<<","<<p3.g<<","<<p3.b<<endl;
+        cout<<endl;
+
+        im.dessinerRectangle(10,10,30,30,Pixel(78,36,108));
+
+        Pixel p4 = im.getPix2(15,20);
+        cout<<p4.r<<","<<p4.g<<","<<p4.b<<endl;
+
+        cout<<endl;
+
+        im.effacer(Pixel(0,0,0));
+        p4 = im.getPix2(18,25);
+        cout<<p4.r<<","<<p4.g<<","<<p4.b<<endl;
+
+    };
+
+    void sauver(const string &filename) const;
+    void ouvrir(const string &filename);
+    void afficherConsole();
+};
+
+#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()
+{
+    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)
+{
+    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>
+
+
+
+class ImageViewer
+{
+    private :
+    SDL_Window * window;
+    SDL_Renderer * renderer;
+    SDL_Surface * m_surface;
+    SDL_Texture * m_texture;
+    Image * im;
+
+    public :
+    ImageViewer(); // Constructeur qui initialise tout SDL2 et crée la fenêtre et le renderer
+    ~ImageViewer(); // Détruit et ferme SDL2
+    void setSurfText();
+    void afficher(const Image & im);
+
+};
+
+
+#endif

src/Pixel.cpp

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

src/Pixel.h

+#ifndef _PIXEL_H
+#define _PIXEL_H
+
+class Pixel
+{
+    public :
+    unsigned int r;
+    unsigned int g;
+    unsigned int b;
+
+    Pixel();
+    Pixel(unsigned ro, unsigned int ve, unsigned int bl);
+    Pixel operator=(Pixel p);
+};
+
+#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();
+    imview.afficher(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();
+    
+    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