Finalisation de ouvrir() et sauver()

Les fonctions marchent mais ne sont pas inclues dans les commandes disponibles, on fera ça avec tout le reste.
* traitementImage.cpp
	* La fonction créer est désormais complète
	* La fonction sauver est désormais complète
* utilitaires.cpp
	* Ajout d'une fonction caraVersEntier() pour convertir manuellement un octet vers un int. Nécessaire car la conversion par type était assez difficile à maitriser
* test.cpp
	* Ajout d'une fonction appliquer afin de faire des tests en série
* image.h
	* Les unsigned int sont désormais remis en int
Cela a permis d'éviter quelques bugs lors de l'ouverture et de la fermeture de fichiers. Ils pourraient potentiellement être remis, mais ils ne servent pas à grand chose au final à par compliquer la tâche.
* Rajout de utilitaires.cpp aux dépendances du Makefile

Makefile

@@ -23,10 +23,10 @@ $(EXEPATH)testing: $(OBJPATH)testing.o $(OBJPATH)image.o
 
 # Dépendances
 ## Fichiers executables
-$(OBJPATH)main.o: $(SRCPATH)main.cpp $(SRCPATH)affichageFenetre.cpp $(SRCPATH)image.cpp $(SRCPATH)traitementImage.cpp $(SRCPATH)analyserCommande.cpp
+$(OBJPATH)main.o: $(SRCPATH)main.cpp $(SRCPATH)affichageFenetre.cpp $(SRCPATH)image.cpp $(SRCPATH)utilitaires.cpp $(SRCPATH)traitementImage.cpp $(SRCPATH)analyserCommande.cpp
 	$(CXX) -c $< -o $@ $(CXXFLAGS)
 
-$(OBJPATH)testing.o: $(SRCPATH)testing.cpp $(SRCPATH)affichageFenetre.cpp $(SRCPATH)image.cpp $(SRCPATH)traitementImage.cpp $(SRCPATH)analyserCommande.cpp
+$(OBJPATH)testing.o: $(SRCPATH)testing.cpp $(SRCPATH)affichageFenetre.cpp $(SRCPATH)image.cpp $(SRCPATH)utilitaires.cpp $(SRCPATH)traitementImage.cpp $(SRCPATH)analyserCommande.cpp
 	$(CXX) -c $< -o $@ $(CXXFLAGSDEBUG)
 ## Bibliothèques
 $(OBJPATH)image.o: $(SRCPATH)image.cpp

Makefile.win

@@ -23,10 +23,10 @@ $(EXEPATH)testing: $(OBJPATH)testing.o $(OBJPATH)image.o
 
 # Dépendances
 ## Fichiers executables
-$(OBJPATH)main.o: $(SRCPATH)main.cpp $(SRCPATH)affichageFenetre.cpp $(SRCPATH)image.cpp $(SRCPATH)traitementImage.cpp $(SRCPATH)analyserCommande.cpp
+$(OBJPATH)main.o: $(SRCPATH)main.cpp $(SRCPATH)affichageFenetre.cpp $(SRCPATH)image.cpp $(SRCPATH)utilitaires.cpp $(SRCPATH)traitementImage.cpp $(SRCPATH)analyserCommande.cpp
 	$(CXX) -c $< -o $@ $(CXXFLAGS)
 
-$(OBJPATH)testing.o: $(SRCPATH)testing.cpp $(SRCPATH)affichageFenetre.cpp $(SRCPATH)image.cpp $(SRCPATH)traitementImage.cpp $(SRCPATH)analyserCommande.cpp
+$(OBJPATH)testing.o: $(SRCPATH)testing.cpp $(SRCPATH)affichageFenetre.cpp $(SRCPATH)image.cpp $(SRCPATH)utilitaires.cpp $(SRCPATH)traitementImage.cpp $(SRCPATH)analyserCommande.cpp
 	$(CXX) -c $< -o $@ $(CXXFLAGSDEBUG)
 ## Bibliothèques
 $(OBJPATH)image.o: $(SRCPATH)image.cpp

src/image.cpp

@@ -1,6 +1,6 @@
 #include "image.h"
 
-Image::Image(unsigned int dimensionX, unsigned int dimensionY, unsigned int maxComposante, PILG_Comp typeComposantes): m_dimensionX(dimensionX), m_dimensionY(dimensionY), m_maxComposante(maxComposante), m_typeComposantes(typeComposantes) {
+Image::Image(int dimensionX, int dimensionY, int maxComposante, PILG_Comp typeComposantes): m_dimensionX(dimensionX), m_dimensionY(dimensionY), m_maxComposante(maxComposante), m_typeComposantes(typeComposantes) {
     Pixel pixelVide = g_pixelVide();
     for (int xT = 0; xT < dimensionX; xT++) {
         std::vector< Pixel > colonne;
@@ -12,11 +12,11 @@ Image::Image(unsigned int dimensionX, unsigned int dimensionY, unsigned int maxC
 }
 
 // Getters
-unsigned int Image::g_dimensionX() const {
+int Image::g_dimensionX() const {
     return m_dimensionX;
 }
 
-unsigned int Image::g_dimensionY() const {
+int Image::g_dimensionY() const {
     return m_dimensionY;
 }
 
@@ -24,11 +24,11 @@ PILG_Comp Image::g_typeComposantes() const {
     return m_typeComposantes;
 }
 
-unsigned int Image::g_maxComposante() const {
+int Image::g_maxComposante() const {
     return m_maxComposante;
 }
 
-int Image::g_pixel(unsigned int x, unsigned int y, Pixel &pixel) const {
+int Image::g_pixel(int x, int y, Pixel &pixel) const {
     if (v_dimensions(x, y)) {
         pixel = m_tab[x][y];
         return 0;
@@ -39,7 +39,7 @@ int Image::g_pixel(unsigned int x, unsigned int y, Pixel &pixel) const {
 }
 
 // Setters
-int Image::s_pixel(unsigned int x, unsigned int y, Pixel pixel) {
+int Image::s_pixel(int x, int y, Pixel pixel) {
     if (v_dimensions(x, y) && v_pixel(pixel)) {
         m_tab[x][y] = pixel;
         return 0;
@@ -96,6 +96,6 @@ bool Image::v_pixel(Pixel pixel) const {
     }
 }
 
-bool Image::v_dimensions(unsigned int x, unsigned int y) const {
+bool Image::v_dimensions(int x, int y) const {
     return (x >= 0 && x < m_dimensionX && y >= 0 && y < m_dimensionY);
 }

src/image.h

@@ -4,37 +4,37 @@ typedef enum {PILG_BIN, PILG_NIV, PILG_RVB} PILG_Comp;
 
 typedef struct Pixel {
     PILG_Comp typeComposantes;
-    unsigned int maxComposante;
+    int maxComposante;
-    unsigned int r;
+    int r;
-    unsigned int v;
+    int v;
-    unsigned int b;
+    int b;
-    unsigned int g;
+    int g;
     bool n;
 } Pixel;
 
 class Image {
 public:
-    Image(unsigned int dimensionX, unsigned int dimensionY, unsigned int maxComposante, PILG_Comp typeComposantes);
+    Image(int dimensionX, int dimensionY, int maxComposante, PILG_Comp typeComposantes);
     // Getters
-    unsigned int g_dimensionX() const;
+    int g_dimensionX() const;
-    unsigned int g_dimensionY() const;
+    int g_dimensionY() const;
     PILG_Comp g_typeComposantes() const;
-    unsigned int g_maxComposante() const;
+    int g_maxComposante() const;
-    int g_pixel(unsigned int x, unsigned int y, Pixel &pixel) const;
+    int g_pixel(int x, int y, Pixel &pixel) const;
     // Setters
-    int s_pixel(unsigned int x, unsigned int y, Pixel pixel);
+    int s_pixel(int x, int y, Pixel pixel);
     // Utilitaires
     Pixel g_pixelVide() const;
     Image g_vide() const;
     // Validateurs
     bool v_pixel(Pixel pixel) const;
-    bool v_dimensions(unsigned int x, unsigned int y) const;
+    bool v_dimensions(int x, int y) const;
 
 private:
     // Variables
-    unsigned int m_dimensionX;
+    int m_dimensionX;
-    unsigned int m_dimensionY;
+    int m_dimensionY;
     PILG_Comp m_typeComposantes;
-    unsigned int m_maxComposante;  // Maximum de composante (sauf binaire)
+    int m_maxComposante;  // Maximum de composante (sauf binaire)
     std::vector< std::vector< Pixel > > m_tab;
 };

src/testing.cpp

@@ -99,6 +99,13 @@ Image genererBruit(int dimX, int dimY) {
     return image;
 }
 
+int appliquer(Image &image, string nomFichier, string ID, bool ASCII) {
+    ouvrir(image, "tests/" + nomFichier);
+    sauver(image, "tests/" + ID, ASCII, nomFichier);
+    afficherImage(image);
+    attendreFenetre();
+}
+
 int main(int argc, char *args[]) {
 #if defined(WIN32) // Permet de refaire fonctionner cout et cerr sous Windows après démarrage de SDL
     freopen("CON", "w", stdout);
@@ -107,27 +114,29 @@ int main(int argc, char *args[]) {
 
     presentation();
 
-    #define DIMENSIONS 256
+    #define DIMENSIONS 50
-    Image imageOriginale = genererRoue(DIMENSIONS*2, DIMENSIONS, 255);
+    Image image1 = genererRoue(DIMENSIONS*2, DIMENSIONS, 255);
-    // Image imageoriginale; // Tester si ça marche
+    Image image2 = genererRoue(DIMENSIONS*2, DIMENSIONS, 255);
+    // Image image1; // Tester si ça marche
+    // afficherImage(image1);
+    // attendreFenetre();
 
     // // Roue
-    // Image image = imageOriginale.g_vide();
+    // Image image = image1.g_vide();
     // for (float i = 0; i < 2 * PI; i += 0.1) {
-    //     pivoter(imageOriginale, image, DIMENSIONS/2, DIMENSIONS/2, i);
+    //     pivoter(image1, image, DIMENSIONS/2, DIMENSIONS/2, i);
     //     afficherImage(image);
     // }
 
     // Ouvrir fichier
-    // cout << ouvrir(imageOriginale, "tests/PikachuP6.ppm") << endl;
+    appliquer(image1, "PikachuP1.pbm", "1", true);
+    appliquer(image1, "PikachuP2.pgm", "2", true);
+    appliquer(image1, "PikachuP3.ppm", "3", true);
+    appliquer(image1, "PikachuP4.pbm", "4", false);
+    appliquer(image1, "PikachuP5.pgm", "5", false);
+    appliquer(image1, "PikachuP6.ppm", "6", false);
     
-    afficherImage(imageOriginale);
-    attendreFenetre();
 
-    // pivoter(imageOriginale, imageOriginale, imageOriginale.g_dimensionX()/2, imageOriginale.g_dimensionY()/2, 0.5);
-    // attendreFenetre();
-
-    cout << sauver(imageOriginale, "tests/Sauvegardé.ppm", true, "Ceci est un commentaire") << endl;
 
     // // Neige en dégradé
     // for (int i; i < 300; i++) {

src/traitementImage.cpp

@@ -1,19 +1,22 @@
-#include <math.h>
 #include <fstream>
 
 #define PI 3.14159265359
 #define MAXCOMPOSANTEDEFAUT 255
+#define FICHIER_SEPARATEUR (char) 0x0a
 
 typedef enum {PILG_TYPE, PILG_DIMENSIONS, PILG_MAXCOMPOSANTE, PILG_IMAGE} PILG_OuvrirEtape;
 
 // Gestion de fichiers
-int creer(Image &sortie, unsigned int dimensionX, unsigned int dimensionY, unsigned int maxComposante, PILG_Comp typeComposantes) { // Créer une image de dimensions X et Y
+int creer(Image &sortie, int dimensionX, int dimensionY, int maxComposante, PILG_Comp typeComposantes) { // Créer une image de dimensions X et Y
     sortie = *new Image(dimensionX, dimensionY, maxComposante, typeComposantes);
     return 0;
 }
 
 int ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à partir du nom du fichier ***Geoffrey
     // Ouverture du fichier
+#if DEBUG
+    cout << "→ " << nomFichier << endl;
+#endif
     ifstream streamFichier(nomFichier.c_str(), ios::in);
     if (streamFichier) {
         // Calcul de la taille (en octets) du fichier
@@ -22,13 +25,12 @@ int ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à
 
         // Stockage du fichier dans une chaîne
         streamFichier.seekg(0, ios::beg);
-        char *caracteres = new char [tailleFichier];
+        char *fichier_caracteres = new char [tailleFichier];
-        streamFichier.read(caracteres, tailleFichier);
+        streamFichier.read(fichier_caracteres, tailleFichier);
-        string fichier_caracteres(caracteres);
-        delete[] caracteres;
         streamFichier.close();
 
         // Variables d'informations
+        char cara;
         PILG_OuvrirEtape ouvrirEtape(PILG_TYPE);
         bool ASCII(false);
         int dimensionX;
@@ -40,12 +42,15 @@ int ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à
         string element("");
         int x(0);
         int y(0);
-        string pixelASCII;
+        int i(0);
-        int RVBcomposante(0); // Composante actuelle pour RVB
+        Pixel pixel;
+        string tmpASCII;
+        char RVBcomposante(0); // Composante actuelle pour RVB
 
         for (int c(0); c < tailleFichier; c++) {
+            cara = fichier_caracteres[c];
             if (ouvrirEtape != PILG_IMAGE) {
-                if (fichier_caracteres[c] ==  (char) 0x0a) { // En cas de nouvel élément
+                if (cara == FICHIER_SEPARATEUR) { // En cas de nouvel élément
                     if (element[0] != '#') { // Si c'est un commentaire, on passe à l'élément suivant
                         switch (ouvrirEtape) {
                         case PILG_TYPE:
@@ -100,9 +105,9 @@ int ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à
                                 if (element[j] == ' ') {
                                     espaceDepasse = true;
                                 } else if (espaceDepasse) {
-                                    dimensionXchaine += element[j];
-                                } else {
                                     dimensionYchaine += element[j];
+                                } else {
+                                    dimensionXchaine += element[j];
                                 }
                             }
                             chaineVersEntier(dimensionXchaine, dimensionX);
@@ -132,23 +137,100 @@ int ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à
                             return 4;
                             break;
                         }
-                        element = "";
                         if (ouvrirEtape == PILG_IMAGE) {
                             sortie = *new Image(dimensionX, dimensionY, maxComposante, typeComposantes);
+                            pixel = sortie.g_pixelVide();
+                        }
+                    }
+                    element = "";
+                } else {
+                    element += cara;
+                }
+            } else {
+                if (ASCII) {
+                    if (typeComposantes == PILG_BIN) {
+                        if (cara != FICHIER_SEPARATEUR) {
+                            pixel.n = (cara == 0x31) ? false : true;
+                            sortie.s_pixel(x, y, pixel);
+                            x++;
+                        }
+                    } else {
+                        if (cara == FICHIER_SEPARATEUR) {
+                            if (typeComposantes == PILG_RVB) {
+                                switch (RVBcomposante) {
+                                case 0:
+                                    chaineVersEntier(tmpASCII, pixel.r);
+                                    RVBcomposante = 1;
+                                    break;
+                                case 1:
+                                    chaineVersEntier(tmpASCII, pixel.v);
+                                    RVBcomposante = 2;
+                                    break;
+                                case 2:
+                                    chaineVersEntier(tmpASCII, pixel.b);
+                                    RVBcomposante = 0;
+                                    sortie.s_pixel(x, y, pixel);
+                                    x++;
+                                    break;
+                                }
+                            } else {
+                                chaineVersEntier(tmpASCII, pixel.g);
+                                sortie.s_pixel(x, y, pixel);
+                                x++;
+                            }
+                            tmpASCII = "";
+                        } else {
+                            tmpASCII += cara;
+                        }
+
+                    }
+                } else {
+                    if (typeComposantes == PILG_BIN) {
+                        for (i = 7; i >= 0; i--) {
+                            pixel.n = !((cara >> i) & 0x01);
+                            sortie.s_pixel(x, y, pixel);
+                            x++;
+                            if (x >= dimensionX) {
+                                y++;
+                                x = 0;
                             }
                         }
                     } else {
-                    element += fichier_caracteres[c];
+                        if (typeComposantes == PILG_RVB) {
+                            switch (RVBcomposante) {
+                            case 0:
+                                pixel.r = caraVersEntier(cara);
+                                RVBcomposante = 1;
+                                break;
+                            case 1:
+                                pixel.v = caraVersEntier(cara);
+                                RVBcomposante = 2;
+                                break;
+                            case 2:
+                                pixel.b = caraVersEntier(cara);
+                                RVBcomposante = 0;
+                                sortie.s_pixel(x, y, pixel);
+                                x++;
+                                break;
                             }
                         } else {
-                // ...
+                            pixel.g = caraVersEntier(cara);
+                            sortie.s_pixel(x, y, pixel);
+                            x++;
+                        }
+                    }
+                }
+                if (x >= dimensionX) {
+                    y++;
+                    x += -dimensionX;
+                }
             }
         }
     } else {
         return 1;
     }
 #if DEBUG
-    cout << endl << endl;
+    cout << endl;
 #endif
 
     return 0;
@@ -156,26 +238,75 @@ int ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à
 
 int sauver(Image entree, string nomFichier, bool ASCII, string commentaire) { // Sauvegarder l'image obtenue dans un nouveau fichier
     ofstream fichier(nomFichier.c_str(), ios::out | ios::trunc);
-#define FICHIER_SEPARATEUR (char) 0x0a
+    char numero;
-    if (entree.g_typeComposantes() == PILG_RVB && ASCII) {
+    switch (entree.g_typeComposantes()) {
-        fichier << "P6";
+    case PILG_BIN:
-    } else {
+        numero = ASCII ? '1' : '4';
+        break;
+    case PILG_NIV:
+        numero = ASCII ? '2' : '5';
+        break;
+    case PILG_RVB:
+        numero = ASCII ? '3' : '6';
+        break;
+    default:
         return 1;
     }
-    fichier << FICHIER_SEPARATEUR;
+
-    // if (commentaire) {
+    fichier << "P" << numero << FICHIER_SEPARATEUR;
-    //     fichier << "#" << commentaire << FICHIER_SEPARATEUR;
+    if (commentaire != "") {
-    // }
+        fichier << "# " << commentaire << FICHIER_SEPARATEUR;
+    }
     fichier << entree.g_dimensionX() << " " << entree.g_dimensionY() << FICHIER_SEPARATEUR;
 
     if (entree.g_typeComposantes() != PILG_BIN) {
         fichier << entree.g_maxComposante() << FICHIER_SEPARATEUR;;
     }
     Pixel pixel;
-    for (int x = 0; x <= entree.g_dimensionX(); x++) {
+    char brutBINpixel;
-        for (int y = 0; y <= entree.g_dimensionY(); y++) {
+    int brutBINpixelRang = 7;
-            if (entree.g_typeComposantes() == PILG_RVB && ASCII) {
+    for (int y = 0; y < entree.g_dimensionY(); y++) {
+        for (int x = 0; x < entree.g_dimensionX(); x++) {
+            entree.g_pixel(x, y, pixel);
+            switch (entree.g_typeComposantes()) {
+            case PILG_BIN:
+                if (ASCII) {
+                    if (pixel.n) {
+                        fichier << '0';
+                    } else {
+                        fichier << '1';
+                    }
+                } else {
+                    if (pixel.n) {
+                        brutBINpixel &= ~(1 << brutBINpixelRang);
+                    } else {
+                        brutBINpixel |= 1 << brutBINpixelRang;
+                    }
+                    brutBINpixelRang--;
+                    if (brutBINpixelRang < 0) {
+                        fichier << brutBINpixel;
+                        brutBINpixelRang = 7;
+                    }
+                }
+                break;
+            case PILG_NIV:
+                if (ASCII) {
+                    fichier << pixel.g << FICHIER_SEPARATEUR;
+                } else {
+                    fichier << (char) pixel.g;
+                }
+                break;
+            case PILG_RVB:
+                if (ASCII) {
                     fichier << pixel.r << FICHIER_SEPARATEUR << pixel.v << FICHIER_SEPARATEUR << pixel.b << FICHIER_SEPARATEUR;
+                } else {
+                    fichier << (char) pixel.r
+                            << (char) pixel.v
+                            << (char) pixel.b;
+                }
+                break;
+            default:
+                return 1;
             }
         }
     }

src/utilitaires.cpp

@@ -1,3 +1,5 @@
+#include <math.h>
+
 #define NOMBREOR 1.61803398875
 
 void presentation() {
@@ -5,7 +7,8 @@ void presentation() {
          << "|  _ \\|_ _|| |    / ___|" << endl
          << "| |_) || | | |   | |  _ "  << endl
          << "|  __/ | | | |___| |_| |"  << endl
-         << "|_|   |___||_____|\\____|" << endl;
+         << "|_|   |___||_____|\\____|" << endl
+         << endl;
 }
 
 Image imageDefaut() {
@@ -80,3 +83,13 @@ int chaineVersFlottant(string chaine, float &flottant) {
     }
     return 0;
 }
+
+int caraVersEntier(char cara) {
+    // int entier = (int) (0 << 8) + cara;
+    // entier = entier > 0 ? entier : 256+entier;
+    int i, entier = 0;
+    for (i = 0; i < 8; i++) {
+        entier += ((cara >> i) & 0x01) ? pow(2, i) : 0;
+    }
+    return entier;
+}