diff --git a/.gitignore b/.gitignore
index 1e8df95..a126b31 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1 @@
-compile*
-bin/*
 *.sublime-*
diff --git a/LICENCE.md b/LICENCE.md
index 68684ea..920d73c 100644
--- a/LICENCE.md
+++ b/LICENCE.md
@@ -1 +1 @@
-*Copyright 2014 Geoffrey et Lucas*
+*Copyright 2014 Lucas et Geoffrey*
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..af30eff
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,31 @@
+# Variables
+## Pour make
+.PHONY: clean, mrproper
+## Compilation
+CXX = g++
+CXXFLAGS = -lSDL -lSDLmain -DDEBUG
+## Chemins
+EXEPATH = bin/
+OBJPATH = obj/
+SRCPATH = src/
+
+# Programmes possibles
+main: main.o image.o
+	$(CXX) $(OBJPATH)main.o $(OBJPATH)image.o -o $(EXEPATH)$@ $(CXXFLAGS)
+
+test: test.o image.o
+	$(CXX) $(OBJPATH)test.o $(OBJPATH)image.o -o $(EXEPATH)$@ $(CXXFLAGS)
+
+# Dépendances
+main.o: $(SRCPATH)main.cpp $(SRCPATH)image.h
+	$(CXX) -c $< -o $(OBJPATH)$@ $(CXXFLAGS)
+
+test.o: $(SRCPATH)test.cpp $(SRCPATH)image.cpp
+	$(CXX) -c $< -o $(OBJPATH)$@ $(CXXFLAGS)
+
+image.o: $(SRCPATH)image.cpp
+	$(CXX) -c $< -o $(OBJPATH)$@
+
+# Meta
+clean:
+	rm -rf $(OBJPATH)*.o
\ No newline at end of file
diff --git a/README.md b/README.md
index 379ef1b..84707d4 100644
--- a/README.md
+++ b/README.md
@@ -1,34 +1,36 @@
 #Projet d'ISN de Lucas et Geoffrey
 
-##À propos...
+##À propos
 
-###De ce dépôt
+###Le dépôt
 Ce dépôt a été crée pour faciliter le développement du projet. Son caractère public n'est que lié aux nécessité de GitHub. Si vous ne savez pas de quel projet il s'agit, vous perdez votre temps ici. L'absence de licence (du moins jusqu'aux épreuves) vous interdit de distribuer ou de réutiliser le code, qui de toute façon ne vous aurait pas été utile. 
 
-###De ce projet
+###Le projet
 Ceci est la création de Lucas et de Geoffrey pour l'option Informatique et Sciences du Numérique qui sera présenté lors du Baccalauréat 2013/2014.
 Nos noms complets et le nom du lycée sont masqués pour des raisons d'intimité. Les personnes devant nous reconnaître nous reconnaîtront.
 
-###Du programme
+###Le programme
 Ce programme est un éditeur basique d'images [PBM/PGM/PPM](http://fr.wikipedia.org/wiki/Portable_pixmap) s’exécutant en ligne de commande.
 
 *Statut :* Prétotype
 
 ##Compilation
+Il n'existe pas de fichier binaire à télécharger pour le moment, le seul moyen d'avoir un aperçu du programme est de le compiler.
+
+Téléchargement : ```git clone https://github.com/GeoffreyFrogeye/PILG.git```
+
 ###Windows
 1. Télécharger et installer [MinGW](http://www.mingw.org/)
 2. Inclure **MinGW** dans la variable d'environnement ```%PATH%``` : ```set path=%path%;C:\MinGW\bin```
-3. Créer le dossier *bin* à la racine du dépôt : ```mkdir bin```
-4. Télécharger la [bibliothèque de développement SDL 1.2.15](http://www.libsdl.org/release/SDL-devel-1.2.15-mingw32.tar.gz), copier le contenu des dossier *lib* et *include* de l'archive téléchargée dans le dossier de **MinGW**
-5. Télécharger la [bibliothèque d’exécution de SDL 1.2.15](http://www.libsdl.org/release/SDL-1.2.15-win32.zip) et placer *SDL.dll* dans le dossier *bin*
-6. Compiler : ```g++ src/main.cpp -o bin/main.exe -lmingw32 -lSDLmain -lSDL -static-libgcc -static-libstdc++```
+3. Télécharger la [bibliothèque de développement SDL 1.2.15](http://www.libsdl.org/release/SDL-devel-1.2.15-mingw32.tar.gz), copier le contenu des dossier *lib* et *include* de l'archive téléchargée dans le dossier de **MinGW**
+4. Télécharger la [bibliothèque d’exécution de SDL 1.2.15](http://www.libsdl.org/release/SDL-1.2.15-win32.zip) et placer *SDL.dll* dans le dossier *bin*
+5. Compiler : ```mingw32-make```
 
 L’exécutable se trouvera dans le dossier *bin*
 
-###Linux
-1. Installer la **bibliothèque de développement SDL 1.2** : ```sudo apt-get install libsdl1.2-dev```
-2. Créer le dossier *bin* à la racine du dépôt : ```mkdir bin```
-3. Compiler : ```g++ src/main.cpp -o bin/main -lSDLmain -lSDL```
+###Debian / Linux
+1. Installer le nécessaire à la compilation ainsi que la **bibliothèque de développement SDL 1.2** : ```sudo apt-get install build-essential libsdl1.2-dev```
+2. Compiler : ```make```
 
 L’exécutable se trouvera dans le dossier *bin*
 
diff --git a/TODO.md b/TODO.md
index 300374d..24f85e7 100644
--- a/TODO.md
+++ b/TODO.md
@@ -1,11 +1,11 @@
 #À réaliser
 
-####Légende
+###Légende
 * **D** Définition réalisée
 * **A** Algorithme réalisé
 * **C** Code réalisé
 
-####Liste générale
+###Liste générale
 *Ordre donné à titre indicatif*
 
 * Fonction principale
@@ -13,41 +13,45 @@
     * Analyse de la commande
     * Analyse des arguments
     * Correspondance commandes ↔ fonctions
-* Objets
+* Objets **D**
     * Fenêtre **D**
         * SDL **C**
         * BGI **A**
     * Pixel **C**
-    * Image **D**
+    * Image **C**
 * Fonctions **D**
-    * Gestion de fichier
+    * Gestion de fichier **D**
         * Créer
-		* Ouvrir
-		* Enregistrer
-		* Importer
-	* Édition
-		* Copier tout
-		* Couper tout
-		* Coller tout
-		* Annuler
-		* Refaire
-	* Couleur
-		* Teinte
-		* Saturation
-		* Luminosité
-		* Contraste
-	* Dessin
-		* Trait
-		* Rectangle
-		* Cercle
-		* Disque
-	* Géométrie
-		* Zoom
-		* Pivot
-		* Redimensionner
-	* Conversion du mode
-		* Binaire
-		* Niveaux de gris
-		* Couleur
-	* Aide
+        * Ouvrir
+        * Enregistrer
+        * Importer
+    * Édition
+        * Copier tout
+        * Couper tout
+        * Coller tout
+        * Annuler
+        * Refaire
+    * Couleur **D**
+        * Teinte **D**
+        * Saturation **D**
+        * Luminosité **D**
+        * Contraste **D**
+    * Dessin **D**
+        * Trait
+        * Rectangle
+        * Cercle
+        * Disque
+    * Géométrie **D**
+        * Zoom
+        * Pivot
+        * Redimensionner
+    * Conversion du mode **D**
+        * Binaire
+        * Niveaux de gris
+        * Couleur
+    * Aide
 * Documentation
+
+
+----------
+*Copyright 2014 Lucas et Geoffrey*
\ No newline at end of file
diff --git a/bin/.gitignore b/bin/.gitignore
new file mode 100644
index 0000000..1937ecc
--- /dev/null
+++ b/bin/.gitignore
@@ -0,0 +1,3 @@
+# Pour forcer l'ajout de ce dossier dans le dépôt
+*
+!.gitignore
\ No newline at end of file
diff --git a/obj/.gitignore b/obj/.gitignore
new file mode 100644
index 0000000..1937ecc
--- /dev/null
+++ b/obj/.gitignore
@@ -0,0 +1,3 @@
+# Pour forcer l'ajout de ce dossier dans le dépôt
+*
+!.gitignore
\ No newline at end of file
diff --git a/src/affichageFenetreBGI.cpp b/src/affichageFenetreBGI.cpp
index 12894de..075eae1 100644
--- a/src/affichageFenetreBGI.cpp
+++ b/src/affichageFenetreBGI.cpp
@@ -1,27 +1,27 @@
 #include <graphics.h>
 
-int ouvrirFenetre(int dimensionX, int dimensionY, const char* nom) {  // Crée une fenêtre
+int ouvrirFenetre(int dimensionX, int dimensionY, const char *nom) {  // Crée une fenêtre
     initwindow(dimensionX, dimensionY, nom, 0, 0);
-	return 0;
+    return 0;
 }
 
-int setNomFenetre(const char* nom) { // Change le nom de la fenêtre
-	return 0;
+int setNomFenetre(const char *nom) { // Change le nom de la fenêtre
+    return 0;
 }
 
 int pointFenetre(int x, int y, int r, int v, int b) {
     putpixel(x, y, COLOR(r, v, b));
-	return 0;
+    return 0;
 }
 
 int afficherFenetre() {
 
-	return 0;
+    return 0;
 }
 
 int attendreFenetre() {
     while (kbhit()) {
-    	delay(100);
+        delay(100);
     }
 }
 
diff --git a/src/affichageFenetreSDL.cpp b/src/affichageFenetreSDL.cpp
index 57b0d8a..9728d77 100644
--- a/src/affichageFenetreSDL.cpp
+++ b/src/affichageFenetreSDL.cpp
@@ -3,12 +3,11 @@
 
 int fenetreDimensionX; // Stocke les dimensions X de la fenêtre
 int fenetreDimensionY; // Stocke les dimensions Y de la fenêtre
-SDL_Surface* fenetreEcran;
-SDL_Surface* fenetreImage;
+SDL_Surface *fenetreEcran;
+SDL_Surface *fenetreImage;
 
 
-void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
-{
+void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel) {
     /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
     En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
     de l'image : 8, 16, 24 ou 32 bits.*/
@@ -18,95 +17,86 @@ void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
     Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;
 
     /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
-    switch(nbOctetsParPixel)
-    {
-        case 1:
-            *p = pixel;
-            break;
+    switch (nbOctetsParPixel) {
+    case 1:
+        *p = pixel;
+        break;
 
-        case 2:
-            *(Uint16 *)p = pixel;
-            break;
+    case 2:
+        *(Uint16 *)p = pixel;
+        break;
 
-        case 3:
-            /*Suivant l'architecture de la machine*/
-            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
-            {
-                p[0] = (pixel >> 16) & 0xff;
-                p[1] = (pixel >> 8) & 0xff;
-                p[2] = pixel & 0xff;
-            }
-            else
-            {
-                p[0] = pixel & 0xff;
-                p[1] = (pixel >> 8) & 0xff;
-                p[2] = (pixel >> 16) & 0xff;
-            }
-            break;
+    case 3:
+        /*Suivant l'architecture de la machine*/
+        if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
+            p[0] = (pixel >> 16) & 0xff;
+            p[1] = (pixel >> 8) & 0xff;
+            p[2] = pixel & 0xff;
+        } else {
+            p[0] = pixel & 0xff;
+            p[1] = (pixel >> 8) & 0xff;
+            p[2] = (pixel >> 16) & 0xff;
+        }
+        break;
 
-        case 4:
-            *(Uint32 *)p = pixel;
-            break;
+    case 4:
+        *(Uint32 *)p = pixel;
+        break;
     }
 }
 
-int ouvrirFenetre(int dimensionX, int dimensionY, std::string nom) {  // Crée une fenêtre
-	SDL_Init(SDL_INIT_VIDEO);
-	fenetreDimensionX = dimensionX;
-	fenetreDimensionY = dimensionY;
-	fenetreEcran = SDL_SetVideoMode(fenetreDimensionX, fenetreDimensionY, 32, SDL_HWSURFACE);
-	fenetreImage = SDL_CreateRGBSurface(SDL_HWSURFACE, fenetreDimensionX, fenetreDimensionX, 32, 0, 0, 0, 0);
-	SDL_FillRect(fenetreImage, NULL, SDL_MapRGB(fenetreEcran->format, 0, 0, 0));
-	setNomFenetre(nom);
-	return 0;
+void setNomFenetre(std::string nom) { // Change le nom de la fenêtre
+    SDL_WM_SetCaption(nom.c_str(), NULL);
 }
 
-int setNomFenetre(std::string nom) { // Change le nom de la fenêtre
-	SDL_WM_SetCaption(nom.c_str(), NULL);
-	return 0;
+void pointFenetre(int x, int y, int r, int v, int b) {
+    // std::cout << "(" << x << ";" << y << ") = (" << r << ";" << v << ";" << b << ")" << std::endl; // DEBUG
+
+    Uint32 pixel;
+
+    Uint8 u_r, u_v, u_b, u_a;
+    u_r = (r > 255 ? 0xff : (Uint8) r);
+    u_v = (v > 255 ? 0xff : (Uint8) v);
+    u_b = (b > 255 ? 0xff : (Uint8) b);
+    u_a = 0xff;
+
+    pixel = SDL_MapRGBA(fenetreImage->format, u_r, u_v, u_b, u_a);
+
+    definirPixel(fenetreImage, x, y, pixel);
+    
 }
 
-int pointFenetre(int x, int y, int r, int v, int b) {
-	// TODO (erreur) Vérifications des dimensions
-
-	// std::cout << "(" << x << ";" << y << ") = (" << r << ";" << v << ";" << b << ")" << std::endl; // DEBUG
-
-	Uint32 pixel;
-
-	Uint8 u_r, u_v, u_b, u_a;
-	u_r = (Uint8) (r > 255 ? 255 : r); // TODO (performance, facultatif, erreur) Si > 255, on renvoit 0xff sinon on convertit
-	u_v = (Uint8) (v > 255 ? 255 : v);
-	u_b = (Uint8) (b > 255 ? 255 : b);
-	u_a = (Uint8) 255;
-
-	pixel = SDL_MapRGBA(fenetreImage->format, u_r, u_v, u_b, u_a);
-
-	SDL_LockSurface(fenetreImage);
-	definirPixel(fenetreImage, x, y, pixel);
-	SDL_UnlockSurface(fenetreImage);
-
-	return 0;
+void afficherFenetre() {
+    SDL_Rect position;
+    position.x = 0;
+    position.y = 0;
+    SDL_UnlockSurface(fenetreImage);
+    SDL_BlitSurface(fenetreImage, NULL, fenetreEcran, &position);
+    SDL_Flip(fenetreEcran);
+    SDL_LockSurface(fenetreImage);
 }
 
-int afficherFenetre() {
-	// TODO (performance, facultatif) fenetreImage pourrait être crée pendant afficherFenetre(), et pointFenetre() ne modifierait qu'un tableau
-	SDL_Rect position;
-	position.x = 0; position.y = 0;
-	SDL_BlitSurface(fenetreImage, NULL, fenetreEcran, &position);
-	SDL_Flip(fenetreEcran);
-	return 0;
-}
-
-int attendreFenetre() {
-	SDL_Event evenement;
+void attendreFenetre() {
+    SDL_Event evenement;
 
     while (evenement.type != SDL_QUIT) {
-    	SDL_WaitEvent(&evenement);
+        SDL_WaitEvent(&evenement);
     }
 }
 
-int fermerFenetre() {
-	SDL_FreeSurface(fenetreImage);
-	SDL_Quit();
-	return 0;
+void fermerFenetre() {
+    SDL_UnlockSurface(fenetreImage);
+    SDL_FreeSurface(fenetreImage);
+    SDL_Quit();
+}
+
+void ouvrirFenetre(int dimensionX, int dimensionY, std::string nom) {  // Crée une fenêtre
+    SDL_Init(SDL_INIT_VIDEO);
+    fenetreDimensionX = dimensionX;
+    fenetreDimensionY = dimensionY;
+    fenetreEcran = SDL_SetVideoMode(fenetreDimensionX, fenetreDimensionY, 32, SDL_HWSURFACE);
+    fenetreImage = SDL_CreateRGBSurface(SDL_HWSURFACE, fenetreDimensionX, fenetreDimensionX, 32, 0, 0, 0, 0);
+    SDL_FillRect(fenetreImage, NULL, SDL_MapRGB(fenetreEcran->format, 0, 0, 0));
+    setNomFenetre(nom);
+    SDL_LockSurface(fenetreImage);
 }
diff --git a/src/image.cpp b/src/image.cpp
index 7bff85c..b1b4704 100644
--- a/src/image.cpp
+++ b/src/image.cpp
@@ -1,55 +1,95 @@
-int Image::Image(int dimensionX, int dimensionY, int maxComposante, int typeComposantes) { // Crée l'objet Image
-	
+#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) {
+    Pixel pixelVide = g_pixelVide();
+    for (int xT = 0; xT < dimensionX; xT++) {
+        std::vector< Pixel > colonne;
+        for (int yT = 0; yT < dimensionX; yT++) {
+            colonne.push_back(pixelVide);
+        }
+        m_tab.push_back(colonne);
+    }
 }
+
 // Getters
-int Image::g_dimensionX() {
-	return m_dimensionX;
+unsigned int Image::g_dimensionX() const {
+    return m_dimensionX;
 }
-int Image::g_dimensionY() {
-	return m_dimensionY;
 
+unsigned int Image::g_dimensionY() const {
+    return m_dimensionY;
 }
-int Image::g_typeComposante() {
-	return m_typeComposante;
-}
-int Image::g_maxComposante() {
-	return m_typeComposante;
 
+PILG_Comp Image::g_typeComposantes() const {
+    return m_typeComposantes;
 }
-int g_point(int x, int y, Pixel &pixel) {
-	if (en_Limites(x, y)) {
-		pixel = m_tab[x][y];
-		return 0;
-	} else {
-		return 1;
-	}
+
+unsigned int Image::g_maxComposante() const {
+    return m_maxComposante;
 }
+
+int Image::g_point(unsigned int x, unsigned int y, Pixel &pixel) const {
+    if (enLimites(x, y)) {
+        pixel = m_tab[x][y];
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
 // Setters
+int Image::s_point(unsigned int x, unsigned int y, Pixel pixel) {
+    if (enLimites(x, y)
+            && pixel.typeComposantes == m_typeComposantes
+            && pixel.maxComposante == m_maxComposante
+            && enLimitesComposantes(pixel)) {
+        m_tab[x][y] = pixel;
+        return 0;
+    } else {
+        return 1;
+    }
+}
 
-int Image::s_point(int x, int y, Pixel pixel) {
-	if (en_Limites(x, y) && pixel.typeComposantes == Image.g_typeComposante && pixel.maxComposante == Image.g_maxComposante && enLimitesComposantes(pixel)) {
-		m_tab[x][y] = pixel;
-	}
-
+// Utilitaires
+Pixel Image::g_pixelVide() const {
+    Pixel pixel;
+    pixel.typeComposantes = m_typeComposantes;
+    pixel.maxComposante = m_maxComposante;
+    switch (pixel.typeComposantes) {
+    case PILG_BIN:
+        pixel.b = false;
+        break;
+    case PILG_NIV:
+        pixel.g = 0;
+        break;
+    case PILG_RVB:
+        pixel.r = 0;
+        pixel.b = 0;
+        pixel.v = 0;
+        break;
+    }
+    return pixel;
 }
 
 bool Image::enLimitesComposantes(Pixel pixel) {
-	switch (pixel.typeComposantes) {
-		case 0:
-			return true;
-			break;
-		case 1:
-			return pixel.m <= pixel.maxComposante;
-			break;
-		case 2:
-			return (pixel.r <= pixel.maxComposante && pixel.v <= pixel.maxComposante && pixel.b <= pixel.maxComposante);
-			break;
-		default:
-			return false;
-			break;
-	}
+    switch (pixel.typeComposantes) {
+    case PILG_BIN:
+        return true;
+        break;
+    case PILG_NIV:
+        return (pixel.g <= pixel.maxComposante);
+        break;
+    case PILG_RVB:
+        return (pixel.r <= pixel.maxComposante
+                && pixel.v <= pixel.maxComposante
+                && pixel.b <= pixel.maxComposante);
+        break;
+    default:
+        return false;
+        break;
+    }
 }
 
-bool Image::enLimites(int x, int y) {
-	return (x >= 0 && x < g_dimensionX && y >= 0 && y < g_dimensionY);
-}
\ No newline at end of file
+bool Image::enLimites(unsigned int x, unsigned int y) const {
+    return (x >= 0 && x < m_dimensionX && y >= 0 && y < m_dimensionY);
+}
diff --git a/src/image.h b/src/image.h
index 7f06b6e..bb12c9e 100644
--- a/src/image.h
+++ b/src/image.h
@@ -1,34 +1,39 @@
 #include <vector>
 
-typedef Pixel {
-	int typeComposantes;
-	int maxComposante;
-	int r;
-	int v;
-	int b;
-	int g;
-	bool n;
+typedef enum {PILG_BIN, PILG_NIV, PILG_RVB} PILG_Comp;
 
+typedef struct Pixel {
+    PILG_Comp typeComposantes;
+    unsigned int maxComposante;
+    unsigned int r;
+    unsigned int v;
+    unsigned int b;
+    unsigned int g;
+    bool n;
 } Pixel;
 
 class Image {
 public:
-	int Image(int dimensionX, int dimensionY, int maxComposante, int typeComposantes); // Crée l'objet Image
-	// Getters
-	int g_dimensionX();
-	int g_dimensionY();
-	int g_typeComposante();
-	int g_maxComposante();
-	Pixel g_point(int x, int y);
-	// Setters
-	int s_point(int x, int y, Pixel pixel);
+    Image(unsigned int dimensionX, unsigned int dimensionY, unsigned int maxComposante, PILG_Comp typeComposantes);
+    // Getters
+    unsigned int g_dimensionX() const;
+    unsigned int g_dimensionY() const;
+    PILG_Comp g_typeComposantes() const;
+    unsigned int g_maxComposante() const;
+    int g_point(unsigned int x, unsigned int y, Pixel &pixel) const;
+    // Setters
+    int s_point(unsigned int x, unsigned int y, Pixel pixel);
+    // Utilitaires
+    Pixel g_pixelVide() const;
 
 private:
-	bool enLimitesComposantes(Pixel pixel);
-	bool enLimites(int x, int y);
-	int m_dimensionX;
-	int m_dimensionY;
-	int m_typeComposantes; // 0 : N&B, 1 : Niveaux de gris, 2 : RVB
-	int m_maxComposante; // Maximum de composante (inutilisé pour binaire)
-	vector< vector< Pixel > > m_tab;
+    // Utilitaires
+    static bool enLimitesComposantes(Pixel pixel);
+    bool enLimites(unsigned int x, unsigned int y) const;
+    // Variables
+    unsigned int m_dimensionX;
+    unsigned int m_dimensionY;
+    PILG_Comp m_typeComposantes;  // 0 : N&B, 1 : Niveaux de gris, 2 : RVB
+    unsigned int m_maxComposante;  // Maximum de composante (sauf binaire)
+    std::vector< std::vector< Pixel > > m_tab;
 };
diff --git a/src/main.cpp b/src/main.cpp
index dd7caf6..90b09ac 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -3,21 +3,19 @@
 
 #include "affichageFenetreSDL.cpp"
 
-
 using namespace std;
 
 // Insertion des ensembles de fonctions massives séparés pour plus de clarté
 #include "analyserCommande.cpp"
 #include "traitementImage.cpp"
 
-int main(int argc, char* args[]) {
-
-#if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
-	freopen("CON", "w", stdout);
-	freopen("CON", "w", stderr);
+int main(int argc, char *args[]) {
+#if defined(WIN32)  // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
+    freopen("CON", "w", stdout);
+    freopen("CON", "w", stderr);
 #endif
 
-	cout << "PILG" << endl; // Message d'entrée et de test
+    cout << "PILG" << endl;  // Message d'entrée et de test
 
     return 0;
 }
diff --git a/src/test.cpp b/src/test.cpp
new file mode 100644
index 0000000..ec5f461
--- /dev/null
+++ b/src/test.cpp
@@ -0,0 +1,64 @@
+#include <iostream>
+#include <string>
+
+#include "affichageFenetreSDL.cpp"
+#include "image.h"
+
+using namespace std;
+
+
+int main(int argc, char *args[]) {
+#if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
+    freopen("CON", "w", stdout);
+    freopen("CON", "w", stderr);
+#endif
+
+    cout << "TEST AFFICHAGE FENETRE" << endl;  // Message d'entrée et de test
+
+    int dimX = 640, dimY = 480;
+    ouvrirFenetre(dimX, dimY, "Test affichage fenêtre");
+
+    Image image(dimX, dimY, 255, PILG_RVB);
+    int x, y, c;
+    Pixel point;
+    point = image.g_pixelVide();
+    // cout << "R : " << point.r << " - V : " << point.v << " - B : " << point.b << endl; // DEBUG
+
+
+    // Cycle de couleurs avec utilisation d'Image
+    for (c = 0; c < 256; c++) {  // À peu près 28 FPS avec SDL
+        for (x = 0; x < dimX; x++) {
+            for (y = 0; y < dimY; y++) {
+                point.r = c;
+                point.v = image.g_maxComposante() - c;
+                point.b = 0;
+                if (image.s_point(x, y, point) == 1) {
+                    cerr << "Erreur : s_point() a été entré avec des valeurs incorrectes" << endl;
+                    cout << "X : " << x << " - Y: " << y << " - R : " << point.r << " - V : " << point.v << " - B : " << point.b << endl; // DEBUG
+                    return 1;
+                }
+                image.g_point(x, y, point);
+                pointFenetre(x, y, point.r, point.v, point.b);
+            }
+        }
+        afficherFenetre();
+    }
+
+    // // Cycle de couleurs sans utilisation d'Image
+    // for (c = 0; c < 256; c++) {  // À peu près 75 FPS avec SDL
+    //     for (x = 0; x < dimX; x++) {
+    //         for (y = 0; y < dimY; y++) {
+    //             pointFenetre(x, y, c, 255 - c, 0);
+    //         }
+    //     }
+    //     afficherFenetre();
+    // }
+
+
+
+    cout << "Éxecution du programme terminée. Vous pouvez quitter la fenêtre." << endl;
+    attendreFenetre();
+    fermerFenetre();
+
+    return 0;
+}
diff --git a/src/test_affichageFenetre.cpp b/src/test_affichageFenetre.cpp
deleted file mode 100644
index c7366d2..0000000
--- a/src/test_affichageFenetre.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <iostream>
-#include <string>
-
-#include "affichageFenetreBGI.cpp"
-
-using namespace std;
-
-
-int main(int argc, char* args[]) {
-
-#if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
-	freopen("CON", "w", stdout);
-	freopen("CON", "w", stderr);
-#endif
-
-	cout << "TEST AFFICHAGE FENETRE" << endl; // Message d'entrée et de test
-
-	int dimX = 640, dimY = 480;
-	ouvrirFenetre(dimX, dimY, "Test affichage fenêtre");
-
-	for (int c = 0; c <= 255; c++) { // À peu près 58 FPS
-		for (int x = 0; x <= dimX; x++) {
-			for (int y = 0; y <= dimY; y++) {
-				pointFenetre(x, y, c, 255-c, 0);
-			}
-		}
-		afficherFenetre();
-	}
-
-	cout << "Éxecution du programme terminée. Vous pouvez quitter la fenêtre." << endl;
-	attendreFenetre();
-	fermerFenetre();
-
-
-    return 0;
-}
diff --git a/src/traitementImage.cpp b/src/traitementImage.cpp
index 9cc6850..bf7ee67 100644
--- a/src/traitementImage.cpp
+++ b/src/traitementImage.cpp
@@ -31,77 +31,77 @@ int refaire() { // répeter la dernière action
 
 // Couleur
 int teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l'image
-	// Si la teinte appartient à [0;1[
-		// r1 = 0
-		// r2 = 1
-		// v1 = 1
-		// v2 = 2
-		// b1 = 2
-		// b2 = 0
-		// Valeur = Teinte
-	// Sinon Si la teinte appartient à [1;2[
-		// r1 = 1
-		// r2 = 2
-		// v1 = 2
-		// v2 = 0
-		// b1 = 0
-		// b2 = 1
-		// Valeur = Teinte-1
-	// Sinon Si la teinte appartient à [2;3]
-		// r1 = 2
-		// r2 = 0
-		// v1 = 0
-		// v2 = 1
-		// b1 = 1
-		// b2 = 2
-		// Valeur = Teinte-2
-	// Fin Si
-	// Pour x=0 à x=image.getDimensionX()
-		// Pour y=0 à y=image.getDimensionY()
-			//
-			//
-			//
-			// pixel.r = r1+(r2-r1)*valeur
-			// pixel.v = v1+(v2-v1)*valeur
-			// pixel.b = b1+(b2-b1)*valeur
-		// Fin Pour
-	// Fin Pour
+    // Si la teinte appartient à [0;1[
+        // r1 = 0
+        // r2 = 1
+        // v1 = 1
+        // v2 = 2
+        // b1 = 2
+        // b2 = 0
+        // Valeur = Teinte
+    // Sinon Si la teinte appartient à [1;2[
+        // r1 = 1
+        // r2 = 2
+        // v1 = 2
+        // v2 = 0
+        // b1 = 0
+        // b2 = 1
+        // Valeur = Teinte-1
+    // Sinon Si la teinte appartient à [2;3]
+        // r1 = 2
+        // r2 = 0
+        // v1 = 0
+        // v2 = 1
+        // b1 = 1
+        // b2 = 2
+        // Valeur = Teinte-2
+    // Fin Si
+    // Pour x=0 à x=image.getDimensionX()
+        // Pour y=0 à y=image.getDimensionY()
+            //
+            //
+            //
+            // pixel.r = r1+(r2-r1)*valeur
+            // pixel.v = v1+(v2-v1)*valeur
+            // pixel.b = b1+(b2-b1)*valeur
+        // Fin Pour
+    // Fin Pour
 }
 
 int saturation(Image entree, Image &sortie, float saturation) { // Sature l'image
-	// Pour x = xMin to x = xMax
-		// Pour y = yMin to y = yMax
-			// Ajouter la variable saturation à chaque valeur de chaque pixel
-			// Ne pas dépasser le seuil limite MaxComposante !!!
-		// Fin Pour
-	// Fin Pour
+    // Pour x = xMin to x = xMax
+        // Pour y = yMin to y = yMax
+            // Ajouter la variable saturation à chaque valeur de chaque pixel
+            // Ne pas dépasser le seuil limite MaxComposante !!!
+        // Fin Pour
+    // Fin Pour
 }
 int luminosite(Image entree, Image &sortie, float luminosite) { // Augmente la luminosité de l'image
-	// Pour x=0 à x=image.g_DimensionX()
-		// Pour y=0 à y=image.g_DimensionY()
-			// si image.g_typeComposante=1
-				// pixel = image.g_point(x,y);
-				// pixel.g = luminosite*10+pixel.g;
-				// image.s_point(x, y, pixel);
-			// sinon si image.g_typeComposante=2
-				// pixel = image.g_point(x,y);
-				// pixel.r = luminosite*10+pixel.r;
-				// pixel.v = luminosite*10+pixel.v;
-				// pixel.b = luminosite*10+pixel.b;
-				// image.s_point(x, y, pixel);
-			// Fin si
-		// Fin Pour
-	// Fin Pour
+    // Pour x=0 à x=image.g_DimensionX()
+        // Pour y=0 à y=image.g_DimensionY()
+            // si image.g_typeComposante=1
+                // pixel = image.g_point(x,y);
+                // pixel.g = luminosite*10+pixel.g;
+                // image.s_point(x, y, pixel);
+            // sinon si image.g_typeComposante=2
+                // pixel = image.g_point(x,y);
+                // pixel.r = luminosite*10+pixel.r;
+                // pixel.v = luminosite*10+pixel.v;
+                // pixel.b = luminosite*10+pixel.b;
+                // image.s_point(x, y, pixel);
+            // Fin si
+        // Fin Pour
+    // Fin Pour
 }
 int contraste(Image entree, Image &sortie, float contraste) { // Accentue les contrastes de l'image
-	// pour x=0 à x=image.g_dimensionX()
-		//pour y=0 à x=image.g_DimensionY()
-			//si image.g_typeComposante=1
-				//pixel = image.g_point(x,y);
-				//pixel.g = contraste*pixel.g;
-				// if pixel.g > Image.g_maxComposante
-					// pixel.g = Image.g_maxComposante
-				// end if
+    // pour x=0 à x=image.g_dimensionX()
+        //pour y=0 à x=image.g_DimensionY()
+            //si image.g_typeComposante=1
+                //pixel = image.g_point(x,y);
+                //pixel.g = contraste*pixel.g;
+                // if pixel.g > Image.g_maxComposante
+                    // pixel.g = Image.g_maxComposante
+                // end if
 
 
 }
@@ -142,4 +142,4 @@ int convRVB(Image entree, Image &sortie) {
 //Help
 int aide() {
 
-}
+}
\ No newline at end of file