[ALPHA] Fin du travail du 12/05/14

Des commandes qui fonctionnent vraiment ainsi quelques conversions entre types de composantes, cela suffit pour passer en alpha !
* Passage au stade d'alpha
Certaines commandes peuvent désormais être executées pleinement. On ne rajoutera pas de fonctionnalités (hormis les commandes) majeures.
* traitementImage.cpp
	* Mise en fonction de convBIN et convNIV
		* Correction de certaines erreurs
			* Travis devrait être content
		Note : convNIV et convRVB auront des valeurs par défaut en tant que maximum de composante, les fonctions n'étant pas très utiles à la base rien ne sert de les compliquer
	* Enième modification du type de fonctions
		* Resteront des int
		* Permet de prendre en compte les erreurs qui ne devraient normalement pas arriver
	* Passage de certaines lignes oubliées au formatteur
	* pivoter()
		* Suppression d'une stupidité mathématique (modulo 2π)
		(Semble plus rapide, sans raison apparente)
* analyseCommande.cpp
	* Les arguments sont désormais correctement analysés
	* pivoter, convBIN et convNIV peuvent désormais être appelé
	* Mise en fonction de chaineVersEntier()
	* Ajout de chaineVersFlottant()
	* Ajout de l'analyse de l'argument -angle
	* Ajout de l'analyse de l'argument -couleur
	* Ajout de messages d'erreurs correspondant à ce qui a été ennoncé précédement

README.md

@@ -12,7 +12,7 @@ Nos noms complets et le nom du lycée sont masqués pour des raisons d'intimité
 ###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.
 
-*Version :* Prétotype
+*Version :* Alpha
 
 *Status :* [![Build Status](https://travis-ci.org/GeoffreyFrogeye/PILG.svg?branch=master)](https://travis-ci.org/GeoffreyFrogeye/PILG)
 

TODO.md

@@ -9,9 +9,9 @@
 *Ordre donné à titre indicatif*
 
 * Fonction principale **C**
-* Fonction d'analyse de commande **D**
+* Fonction d'analyse de commande **C**
     * Analyse de la commande **C**
-    * Analyse des arguments **D**
+    * Analyse des arguments **C**
     * Execution des fonctions **C**
 * Objets **C**
     * Fenêtre **C**
@@ -35,18 +35,18 @@
         * Luminosité **A**
         * Contraste **A**
     * Dessin **D**
-        * Trait **D**
+        * Trait **A**
         * Rectangle **C**
-        * Cercle **D**
+        * Cercle **A**
-        * Disque **D**
+        * Disque **A**
     * Géométrie **D**
         * Zoomer
         * Pivoter **C**
         * Retourner **D**
         * Redimensionner **A**
     * Conversion du mode **D**
-        * Binaire **D**
+        * Binaire **C**
-        * Niveaux de gris **D**
+        * Niveaux de gris **C**
         * Couleur **D**
     * Aide
 * Documentation

src/analyserCommande.cpp

@@ -3,8 +3,19 @@
 #include <iostream>
 
 int chaineVersEntier(string chaine, int &entier) {
-     entier = chaine[0];
+    entier = atoi(chaine.c_str());
-     return 0;
+    if (entier == 0 && chaine != "0") {
+        return 1;
+    }
+    return 0;
+}
+
+int chaineVersFlottant(string chaine, float &flottant) {
+    flottant = atof(chaine.c_str());
+    if (flottant == 0 && chaine != "0") {
+        return 1;
+    }
+    return 0;
 }
 
 void afficherImage(Image image) {
@@ -107,6 +118,7 @@ typedef struct Commande {
     string fonction;
 
     int x1, x2, y1, y2;
+    float angle;
     string fichierEntree, fichierSortie;
     Pixel couleur;
     // ...
@@ -126,34 +138,100 @@ int analyserDecoupe(Commande &commande, vector< string > decoupe, Image const &i
         if (decoupe[i].at(0) == '-') {
             if (decoupe[i] == "-x1" || decoupe[i] == "-x0" || decoupe[i] == "-x") {
                 commande.argumentsPresents.push_back("x1");
-                if (chaineVersEntier(decoupe[i+1], commande.x1)) {
+                i++;
+                if (chaineVersEntier(decoupe[i], commande.x1)) {
                     return 3;
                 }
-                i++;
             } else if (decoupe[i] == "-y1" || decoupe[i] == "-y0" || decoupe[i] == "-y") {
                 commande.argumentsPresents.push_back("y1");
-                if (chaineVersEntier(decoupe[i+1], commande.y1)) {
+                i++;
+                if (chaineVersEntier(decoupe[i], commande.y1)) {
                     return 3;
                 }
-                i++;
             } else if (decoupe[i] == "-x2") {
                 commande.argumentsPresents.push_back("x2");
-                if (chaineVersEntier(decoupe[i+1], commande.x2)) {
+                i++;
+                if (chaineVersEntier(decoupe[i], commande.x2)) {
                     return 3;
                 }
-                i++;
             } else if (decoupe[i] == "-y2") {
                 commande.argumentsPresents.push_back("y2");
-                if (chaineVersEntier(decoupe[i+1], commande.y2)) {
+                i++;
+                if (chaineVersEntier(decoupe[i], commande.y2)) {
                     return 3;
                 }
-                i++;
             } else if (decoupe[i] == "-couleur" || decoupe[i] == "-c") {
                 commande.argumentsPresents.push_back("couleur");
-                commande.couleur = image.g_pixelVide();
-                // Analyser deuxième partie
                 i++;
+                commande.couleur = image.g_pixelVide();
+                switch (image.g_typeComposantes()) {
+                case PILG_BIN:
+                    if (decoupe[i] == "b" || decoupe[i] == "1") {
+                        commande.couleur.n = true;
+                    } else if (decoupe[i] == "n" || decoupe[i] == "0") {
+                        commande.couleur.n = false;
+                    } else {
+                        return 4;
+                    }
+                    break;
+                case PILG_NIV:
+                    int g;
+                    if (!chaineVersEntier(decoupe[i], g)) {
+                        return 3;
+                    }
+                    if (g > image.g_maxComposante()) {
+                        return 5;
+                    }
+                    commande.couleur.g = g;
+                    break;
+                case PILG_RVB:
+                    int composante = 0;
+                    string chaineCourante = "";
+                    int entierCourant = 0;
+                    for (int iS = 0; iS <= decoupe[i].length(); iS++) {
+                        if (decoupe[i][iS] == ':' || iS == decoupe[i].length()) {
+                            if (chaineVersEntier(chaineCourante, entierCourant)) {
+                                return 3;
+                            }
+                            if (entierCourant > image.g_maxComposante()) {
+                                return 5;
+                            }
+                            switch (composante) {
+                            case 0:
+                                commande.couleur.r = entierCourant;
+                                break;
+                            case 1:
+                                commande.couleur.v = entierCourant;
+                                break;
+                            case 2:
+                                commande.couleur.b = entierCourant;
+                                break;
+                            default:
+                                return 6;
+                            }
+                            chaineCourante = "";
+                            entierCourant = 0;
+                            composante++;
+                        } else {
+                            chaineCourante += decoupe[i][iS];
+                        }
+                    }
+                    if (composante != 3) {
+                        return 6;
+                    }
+                    break;
+                }
+                if (!image.v_pixel(commande.couleur)) {
+                    return 7;
+                }
+            } else if (decoupe[i] == "-angle" || decoupe[i] == "-a") {
+                commande.argumentsPresents.push_back("angle");
+                i++;
+                if (chaineVersFlottant(decoupe[i], commande.angle)) {
+                    return 8;
+                }
             } else {
+                cout << decoupe[i] << endl;
                 return 2;
             }
         } else {
@@ -161,9 +239,9 @@ int analyserDecoupe(Commande &commande, vector< string > decoupe, Image const &i
         }
     }
 
-    for (int i = 0; i < commande.argumentsPresents.size(); i++) { // DEBUG
+    // for (int i = 0; i < commande.argumentsPresents.size(); i++) { // DEBUG
-        cout << "Argument présent " << i << " = " << commande.argumentsPresents[i] << endl;
+    //     cout << "Argument présent " << i << " = " << commande.argumentsPresents[i] << endl;
-    }
+    // }
 
     return 0;
 }
@@ -182,10 +260,31 @@ int executerCommande(Commande commande, Image &image) {
         if (argumentPresent(commande, "x1") && argumentPresent(commande, "x2")
                 && argumentPresent(commande, "y1") && argumentPresent(commande, "y2")
                 && argumentPresent(commande, "couleur")) {
-                rectangle(image, image, commande.x1, commande.y1, commande.x2, commande.y2, commande.couleur);
+            if (rectangle(image, image, commande.x1, commande.y1, commande.x2, commande.y2, commande.couleur)) {
+                return 3;
+            }
         } else {
             return 2;
         }
+    } else if (commande.fonction == "pivoter") {
+        if (argumentPresent(commande, "x1") && argumentPresent(commande, "y1")
+                && argumentPresent(commande, "angle")) {
+            if (pivoter(image, image, commande.x1, commande.y1, commande.angle)) {
+                return 3;
+            }
+        } else {
+            return 2;
+        }
+    } else if (commande.fonction == "convBIN") {
+        if (convBIN(image, image)) {
+            return 3;
+        }
+    } else if (commande.fonction == "convNIV") {
+        if (convNIV(image, image)) {
+            return 3;
+        }
+        // } else if (commande.fonction == "convRVB") {
+        // convRVB(image, image);
     } else {
         return 1;
     }
@@ -205,18 +304,36 @@ void procederCommande(vector< string > decoupe, Image &image) {
         case 2:
             messageErreur("Arguments manquants");
             break;
+        case 3:
+            messageErreur("Erreur dans l'execution de la commande");
+            break;
         default:
             messageErreur("Impossible d'éxecuter la fonction");
         }
         break;
     case 1:
-        messageErreur("Argument inconnu");
+        messageErreur("Un argument a été attendu et autre chose a été donné");
         break;
     case 2:
         messageErreur("Argument inconnu");
         break;
     case 3:
-        messageErreur("Impossible de comprendre un argument");
+        messageErreur("Un entier a été attendu et n'a pas été donné");
+        break;
+    case 4:
+        messageErreur("La couleur d'une image binaire doit être blanc (1) ou noir (0)");
+        break;
+    case 5:
+        messageErreur("La valeur d'une composante de couleur donnée est superieure au maximum de composante de l'image");
+        break;
+    case 6:
+        messageErreur("La couleur d'une image RVB possède trois composantes");
+        break;
+    case 7:
+        messageErreur("La couleur donnée n'est pas valide, la raison en est inconnue");
+        break;
+    case 8:
+        messageErreur("Un nombre décimal a été attendu et n'a pas été donné (le programme n'accepte que les points)");
         break;
     default:
         messageErreur("Impossible d'analyser la commande");
@@ -224,7 +341,7 @@ void procederCommande(vector< string > decoupe, Image &image) {
     }
 }
 
-int boucleDeCommandes(Image image) { // REPL
+void boucleDeCommandes(Image image) { // REPL
     bool continuer = true;
     string commandeTexte;
 

src/main.cpp

@@ -51,6 +51,8 @@ Image imageDefaut() {
                 pointRoue.v = 0;
                 pointRoue.b = maxComposante - substep;
                 break;
+            default:
+                pointRoue.r = pointRoue.v = pointRoue.b = 0;
             }
 
             // Dégradé vers le noir

src/testing.cpp

@@ -106,18 +106,16 @@ int main(int argc, char *args[]) {
 
     cout << "PILG - Test" << endl;  // Message d'entrée et de test
 
-    Image image = genererRoue(256, 128, 255);
+    // Image image = genererRoue(256, 128, 255);
 
     #define DIMENSIONS 256
 
     Image imageOriginale = genererRoue(DIMENSIONS, DIMENSIONS, 255);
     Image image = imageOriginale.g_vide();
-    // while(1) {
     for (float i = 0; i < 2 * PI; i += 0.1) {
         pivoter(imageOriginale, image, DIMENSIONS/2, DIMENSIONS/2, i);
         afficherImage(image);
     }
-    // }
 
 
     // // Neige en dégradé

src/traitementImage.cpp

@@ -1,21 +1,25 @@
 #include <math.h>
 
 #define PI 3.14159265359
+#define MAXCOMPOSANTEDEFAUT 255
 
 // Gestion de fichiers
-void 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, unsigned int dimensionX, unsigned int dimensionY, unsigned int maxComposante, PILG_Comp typeComposantes) { // Créer une image de dimensions X et Y
     sortie = *new Image(dimensionX, dimensionY, maxComposante, typeComposantes);
+    return 0;
 }
 
-void ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à partir du nom du fichier ***Geoffrey
+int ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à partir du nom du fichier ***Geoffrey
 
+    return 1;
 }
 
-void sauver(Image entree, string nomFichier, bool ASCII, string commentaire) { // Sauvegarder l'image obtenue dans un nouveau fichier
+int sauver(Image entree, string nomFichier, bool ASCII, string commentaire) { // Sauvegarder l'image obtenue dans un nouveau fichier
 
+    return 1;
 }
 
-void import(Image entree, Image &sortie, string nomFichier, int x, int y) {
+int importer(Image entree, Image &sortie, string nomFichier, int x, int y) {
     // Image fichierImporte;
     // sortie = entree
     // ouvrir(fichierImporte, nomFichier)
@@ -25,10 +29,11 @@ void import(Image entree, Image &sortie, string nomFichier, int x, int y) {
     //     FinPour
     // FinPour
 
+    return 1;
 }
 
 // Couleur
-void teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l'image
+int teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l'image
     // Si la teinte appartient à [0;1[
     //     r1 = 0
     //     r2 = 1
@@ -64,18 +69,20 @@ void teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de
     //         pixel.b = b1+(b2-b1)*valeur
     //     Fin Pour
     // Fin Pour
+    return 1;
 }
 
-void saturation(Image entree, Image &sortie, float saturation) { // Sature l'image
+int saturation(Image entree, Image &sortie, float saturation) { // Sature l'image
     // Pour x = image.g_DimensionX()
     //     Pour y = image.g_DimensionY()
     //         Ajouter la variable saturation à chaque valeur de chaque pixel
     //         Ne pas dépasser le seuil limite MaxComposante !!!
     //     Fin Pour
     // Fin Pour
+    return 1;
 }
 
-void luminosite(Image entree, Image &sortie, float luminosite) { // Augmente la luminosité de l'image
+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
@@ -91,9 +98,10 @@ void luminosite(Image entree, Image &sortie, float luminosite) { // Augmente la
     //         Fin si
     //     Fin Pour
     // Fin Pour
+    return 1;
 }
 
-void contraste(Image entree, Image &sortie, float contraste) { // Accentue les contrastes de l'image
+int contraste(Image entree, Image &sortie, float contraste) { // Accentue les contrastes de l'image
     // pour x=0 à x=image.g_dimensionX()
     //    pour y=0 à y=image.g_DimensionY()
     //        si image.g_typeComposante=1
@@ -107,10 +115,11 @@ void contraste(Image entree, Image &sortie, float contraste) { // Accentue les c
     // Fin Pour
 
 
+    return 1;
 }
 
 // Dessin
-void trait(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel pixel) { // Dessine un trait d'un point (x1,y1) à un point (x2,y2)
+int trait(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel pixel) { // Dessine un trait d'un point (x1,y1) à un point (x2,y2)
     //    int x, y, dx, dy ;
     //    float e, e(1,0), e(0,1) ;  // valeur d’erreur et incréments
     //    dy ← y2 - y1 ;
@@ -127,9 +136,10 @@ void trait(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel pi
     //                  fin si ;
     //          fin pour ;
 
+    return 1;
 }
 
-void rectangle(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel couleur) {
+int rectangle(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel couleur) {
     sortie = entree;
     for (int x = x1; x <= x2; x++) {
         for (int y = y1; y <= y2; y++) {
@@ -137,9 +147,10 @@ void rectangle(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixe
         }
     }
 
+    return 0;
 }
 
-void cercle(Image entree, Image &sortie, int x0, int y0, int r, Pixel couleur) {
+int cercle(Image entree, Image &sortie, int x0, int y0, int r, Pixel couleur) {
     // sortie=entree;
     // pour x=0 à x=image.g_dimensionX()
     //     pour y=0 à y=image.g_dimensionY()
@@ -148,9 +159,10 @@ void cercle(Image entree, Image &sortie, int x0, int y0, int r, Pixel couleur) {
     //         Fin si
     //     fin pour
     // fin pour
+    return 1;
 }
 
-void disque(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) {
+int disque(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) {
     // sortie=entree;
     // pour x=0 à x=image.g_dimensionX()
     //     pour y=0 à y=image.g_dimensionY()
@@ -159,14 +171,16 @@ void disque(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) {
     //         Fin si
     //     fin pour
     // fin pour
+    return 1;
 }
 
 // Geométrie
-void zoom(Image entree, Image &sortie) {
+int zoom(Image entree, Image &sortie) {
 
+    return 1;
 }
 
-void pivoter(Image entree, Image &sortie, int x0, int y0, float angle) {
+int pivoter(Image entree, Image &sortie, int x0, int y0, float angle) {
     sortie = entree.g_vide();
     float xF, yF, angleF, xI, yI, angleI, h;
     Pixel pixel = entree.g_pixelVide();
@@ -176,109 +190,97 @@ void pivoter(Image entree, Image &sortie, int x0, int y0, float angle) {
                 xI = x0;
                 yI = y0;
             } else {
-                angleF = atan((yF-y0)/(xF-x0));
+                angleF = atan((yF - y0) / (xF - x0));
-                angleF = (xF-x0<0 ? angleF + PI : (yF-y0 ? angleF + 2*PI: angleF));
+                angleF = (xF - x0 < 0 ? angleF + PI : angleF);
                 angleI = angleF - angle;
-                h = sqrt(pow(xF-x0, 2)+pow(yF-y0, 2));
+                h = sqrt(pow(xF - x0, 2) + pow(yF - y0, 2));
-                xI = cos(angleI)*h+x0;
+                xI = cos(angleI) * h + x0;
-                yI = sin(angleI)*h+y0;
+                yI = sin(angleI) * h + y0;
             }
             entree.g_pixel((int) xI, (int) yI, pixel);
             sortie.s_pixel((int) xF, (int) yF, pixel);
         }
     }
+    return 0;
 }
 
-void retourner(Image entree, Image &sortie, int rotation) {
+int retourner(Image entree, Image &sortie, int rotation) {
 
+    return 1;
 }
 
-void redimensionner(Image entree, Image &sortie, int x1, int x2, int y1, int y2) {
+int redimensionner(Image entree, Image &sortie, int x1, int x2, int y1, int y2) {
-    // Image *nouvelle = new Image(x2-x1, y2-y1, entree.g_maxComposante(), entree.g_typeComposantes());
+    // sortie = *new Image(x2-x1, y2-y1, entree.g_maxComposante(), entree.g_typeComposantes());
-    // sortie = *nouvelle;
     // pour x=x1 à x=x2
     //    pour y=y1 à y=y2
     //         sortie.s_pixel(x, y, entree.g_pixel(x+x1, y+y1));
     //     FinPour
     // FinPour
+    return 1;
 }
 
 // Modification couleur
-void convBIN(Image entree, Image &sortie) {
+int convBIN(Image entree, Image &sortie) {
-    Pixel pixel;
+    if (entree.g_typeComposantes() == PILG_BIN) {
-    switch(entrée.g_typeComposantes) {
+        sortie = entree;
-        case PILG_BIN:
+    } else {
-            sortie=entree;
+        sortie = *new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_BIN);
-             break;
+        Pixel pixelI, pixelF;
-        case PILG_NIV:
+        pixelF = sortie.g_pixelVide();
-            sortie = new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_BIN);
+        for (int x = 0; x <= entree.g_dimensionX(); x++) {
-            pixelI = entree.g_pixelVide();
+            for (int y = 0; y <= entree.g_dimensionY(); y++) {
-            pixelF = sortie.g_pixelVide();
+                entree.g_pixel(x, y, pixelI);
-            for (int x = 0; x <= entree.g_dimensionX(); x++) {
+                switch (entree.g_typeComposantes()) {
-                for (int y = 0; y <= entree.g_dimensionY(); y++) {
+                case PILG_NIV:
-                    entree.g_pixel(x, y, pixelI);
+                    pixelF.n = (pixelI.g > entree.g_maxComposante() / 2);
-                    pixelF.n = (pixelI.g > entree.g_maxComposante/2);
+                    break;
-                    sortie.s_pixel(x, y, pixelF);
+                case PILG_RVB:
-                
+                    pixelF.n = ((pixelI.r + pixelI.v + pixelI.b) / 3 > entree.g_maxComposante() / 2);
+                    break;
+                default:
+                    return 2;
                 }
+                sortie.s_pixel(x, y, pixelF);
             }
-            break;
+        }
-        case PILG_RVB:
-            sortie = new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_BIN);
-            pixelI = entree.g_pixelVide();
-            pixelF = sortie.g_pixelVide();
-            for (int x = 0; x <= entree.g_dimensionX(); x++) {
-                for (int y = 0; y <= entree.g_dimensionY(); y++) {
-                    entree.g_pixel(x, y, pixelI);
-                    pixelF.n = ((pixelI.r + pixelI.v + pixelI.b)/3 > entree._maxComposante/2);
-                    sortie.s_pixel(x, y, pixelF);
-                
-                }
-            }
-            break;
-
     }
+    return 0;
 }
 
-void convNIV(Image entree, Image &sortie) {
+int convNIV(Image entree, Image &sortie) {
-        Pixel pixel;
+    if (entree.g_typeComposantes() == PILG_NIV) {
-    switch(entrée.g_typeComposantes) {
+        sortie = entree;
-        case PILG_BIN:
+    } else {
-            sortie = new Image(entree.n_dimensionX(), entree.n_dimensionY(), 0, PILG_BIN);
+        sortie = *new Image(entree.g_dimensionX(), entree.g_dimensionY(), MAXCOMPOSANTEDEFAUT, PILG_NIV);
-            pixelI = entree.g_pixelVide();
+        Pixel pixelI, pixelF;
-            pixelF = sortie.g_pixelVide();
+        pixelF = sortie.g_pixelVide();
-            for (int x = 0; x <= entree.g_dimensionX(); x++) {
+        for (int x = 0; x <= entree.g_dimensionX(); x++) {
-                for (int y = 0; y <= entree.g_dimensionY(); y++) {
+            for (int y = 0; y <= entree.g_dimensionY(); y++) {
-                    entree.g_pixel(x, y, pixelI);
+                entree.g_pixel(x, y, pixelI);
+                switch (entree.g_typeComposantes()) {
+                case PILG_BIN:
                     pixelF.g = (pixelI.n ? sortie.g_maxComposante() : 0);
-                    sortie.s_pixel(x, y, pixelF);
+                    break;
-                
+                case PILG_RVB:
+                    pixelF.g = (pixelI.r + pixelI.v + pixelI.b) / 3.0 / entree.g_maxComposante() * sortie.g_maxComposante();
+                    break;
+                default:
+                    return 1;
                 }
+                sortie.s_pixel(x, y, pixelF);
             }
-             break;
+        }
-        case PILG_NIV:
+    }
-            sortie = entree;
+    return 0;
-            break;
-        case PILG_RVB:
-            sortie = new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_NIV);
-            pixelI = entree.g_pixelVide();
-            pixelF = sortie.g_pixelVide();
-            for (int x = 0; x <= entree.g_dimensionX(); x++) {
-                for (int y = 0; y <= entree.g_dimensionY(); y++) {
-                    entree.g_pixel(x, y, pixelI);
-                    pixelF.n = (pixelI.r + pixelI.v + pixelI.b)/3;
-                    sortie.s_pixel(x, y, pixelF);
-                
-                }
-            }
-            break;
 }
 
-void convRVB(Image entree, Image &sortie) {
+int convRVB(Image entree, Image &sortie) {
 
+    return 1;
 }
 
 //Help
-void aide() {
+int aide() {
     //Afficher le texte suivant :
+    return 1;
 }