Browse Source

Avancement dans l'éxecution de commandes

Le programme dispose désormais d'une image par défaut affichée à l'écran. L'analyse de commandes a été travaillé, pour la tester la fonction rectangle fonctionne, sans arguments cependant, ce sera donc un carré prédéfini qui apparaitra sur l'image de test. Diverses améliorations notables cependant.

* Modifié main.cpp
	* Ajout d'une Image par défaut (sorte de roue chromatique horizontale) aux proportions d'or
* Modifié analyserCommande.cpp
	* Ajout d'une fonction d'affichage d'une Image à l'écran
	* Ajout d'un objet Commande pour faciliter le transfert entre les fonctions
	* Ajout d'executerCommande()
		* Vérifie si les arguments requis sont présents grâce à argumentPresent()
		* Execute la fonction correspondante dans traitementImage.cpp
	* Ajout de procederCommande() qui gère l'execution d'analyserDecoupe() et d'executerCommande()
* Modifié traitementImage.cpp
	* Puisque chaque fonction n'est pas censé échouer, les types de retour sont des void
	* rectangle() codé
* Modifié affichageFenetre.cpp
	* attendreFenetre() autorise une action sur le clavier
	* Ajout de la valeur globale booléenne fenetreOuverte
	* Corrigé un éventuel bug pouvant arriver lorsque les dimensions étaient rectangulaires
* Modifié l'objet Image
	* Les validateurs sont désormais au nombre de deux, v_pixel() et v_dimensions() pour chaque Image, et sont publics
* Modifié testing.cpp
	* Ajout fonctions génératrices d'images de test pour chaque type de composante
* Mis à jour TODO.md
* Amélioration du Makefile
* Modification de .travis.yml pour placer le `make testing` en post-script
tags/v1.0.0
parent
commit
43550b265f
11 changed files with 467 additions and 264 deletions
  1. 4
    2
      .travis.yml
  2. 16
    11
      Makefile
  3. 5
    5
      TODO.md
  4. 11
    19
      src/affichageFenetre.cpp
  5. 123
    15
      src/analyserCommande.cpp
  6. 26
    23
      src/image.cpp
  7. 6
    6
      src/image.h
  8. 63
    5
      src/main.cpp
  9. 0
    140
      src/test.cpp
  10. 177
    0
      src/testing.cpp
  11. 36
    38
      src/traitementImage.cpp

+ 4
- 2
.travis.yml View File

@@ -1,6 +1,8 @@
1 1
 language: cpp
2 2
 compiler: gcc
3 3
 before_install:
4
-  - sudo apt-get update -qq
4
+  - sudo apt-get update
5 5
   - sudo apt-get install -y libsdl1.2-dev
6
-script: make && make testing
6
+script: make
7
+after_install:
8
+  - make testing

+ 16
- 11
Makefile View File

@@ -11,21 +11,26 @@ OBJPATH = obj/
11 11
 SRCPATH = src/
12 12
 
13 13
 # Programmes possibles
14
-main: main.o image.o
15
-	$(CXX) $(OBJPATH)main.o $(OBJPATH)image.o -o $(EXEPATH)$@ $(CXXFLAGS)
14
+main: $(EXEPATH)main
15
+testing: $(EXEPATH)testing
16 16
 
17
-testing: test.o image.o
18
-	$(CXX) $(OBJPATH)test.o $(OBJPATH)image.o -o $(EXEPATH)$@ $(CXXFLAGSDEBUG)
17
+# Éxecutables
18
+$(EXEPATH)main: $(OBJPATH)main.o $(OBJPATH)image.o
19
+	$(CXX) $^ -o $@ $(CXXFLAGS)
19 20
 
20
-# Dépendances
21
-main.o: $(SRCPATH)main.cpp $(SRCPATH)image.h
22
-	$(CXX) -c $< -o $(OBJPATH)$@ $(CXXFLAGS)
21
+$(EXEPATH)testing: $(OBJPATH)testing.o $(OBJPATH)image.o
22
+	$(CXX) $^ -o $@ $(CXXFLAGSDEBUG)
23 23
 
24
-test.o: $(SRCPATH)test.cpp $(SRCPATH)image.cpp
25
-	$(CXX) -c $< -o $(OBJPATH)$@ $(CXXFLAGSDEBUG)
24
+# Dépendances
25
+## Fichiers executables
26
+$(OBJPATH)main.o: $(SRCPATH)main.cpp $(SRCPATH)image.h
27
+	$(CXX) -c $< -o $@ $(CXXFLAGS)
26 28
 
27
-image.o: $(SRCPATH)image.cpp
28
-	$(CXX) -c $< -o $(OBJPATH)$@
29
+$(OBJPATH)testing.o: $(SRCPATH)testing.cpp $(SRCPATH)image.cpp
30
+	$(CXX) -c $< -o $@ $(CXXFLAGSDEBUG)
31
+## Bibliothèques
32
+$(OBJPATH)image.o: $(SRCPATH)image.cpp
33
+	$(CXX) -c $< -o $@
29 34
 
30 35
 # Meta
31 36
 clean:

+ 5
- 5
TODO.md View File

@@ -8,11 +8,11 @@
8 8
 ###Liste générale
9 9
 *Ordre donné à titre indicatif*
10 10
 
11
-* Fonction principale
12
-* Fonction d'analyse de commande
11
+* Fonction principale **C**
12
+* Fonction d'analyse de commande **D**
13 13
     * Analyse de la commande **C**
14
-    * Analyse des arguments
15
-    * Correspondance commandes ↔ fonctions **D**
14
+    * Analyse des arguments **D**
15
+    * Execution des fonctions **C**
16 16
 * Objets **C**
17 17
     * Fenêtre **C**
18 18
     * Pixel **C**
@@ -36,7 +36,7 @@
36 36
         * Contraste **A**
37 37
     * Dessin **D**
38 38
         * Trait **D**
39
-        * Rectangle **A**
39
+        * Rectangle **C**
40 40
         * Cercle **D**
41 41
         * Disque **D**
42 42
     * Géométrie **D**

+ 11
- 19
src/affichageFenetre.cpp View File

@@ -3,31 +3,22 @@
3 3
 
4 4
 int fenetreDimensionX; // Stocke les dimensions X de la fenêtre
5 5
 int fenetreDimensionY; // Stocke les dimensions Y de la fenêtre
6
+bool fenetreOuverte = false;
6 7
 SDL_Surface *fenetreEcran;
7 8
 SDL_Surface *fenetreImage;
8 9
 
9 10
 
10 11
 void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel) {
11
-    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
12
-    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
13
-    de l'image : 8, 16, 24 ou 32 bits.*/
14 12
     int nbOctetsParPixel = surface->format->BytesPerPixel;
15
-    /*Ici p est l'adresse du pixel que l'on veut modifier*/
16
-    /*surface->pixels contient l'adresse du premier pixel de l'image*/
17 13
     Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;
18
-
19
-    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
20 14
     switch (nbOctetsParPixel) {
21 15
     case 1:
22 16
         *p = pixel;
23 17
         break;
24
-
25 18
     case 2:
26 19
         *(Uint16 *)p = pixel;
27 20
         break;
28
-
29 21
     case 3:
30
-        /*Suivant l'architecture de la machine*/
31 22
         if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
32 23
             p[0] = (pixel >> 16) & 0xff;
33 24
             p[1] = (pixel >> 8) & 0xff;
@@ -38,7 +29,6 @@ void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel) {
38 29
             p[2] = (pixel >> 16) & 0xff;
39 30
         }
40 31
         break;
41
-
42 32
     case 4:
43 33
         *(Uint32 *)p = pixel;
44 34
         break;
@@ -53,17 +43,16 @@ void pointFenetre(int x, int y, int r, int v, int b) {
53 43
     // std::cout << "(" << x << ";" << y << ") = (" << r << ";" << v << ";" << b << ")" << std::endl; // DEBUG
54 44
 
55 45
     Uint32 pixel;
56
-
57 46
     Uint8 u_r, u_v, u_b, u_a;
47
+
58 48
     u_r = (r > 255 ? 0xff : (Uint8) r);
59 49
     u_v = (v > 255 ? 0xff : (Uint8) v);
60 50
     u_b = (b > 255 ? 0xff : (Uint8) b);
61 51
     u_a = 0xff;
62 52
 
63 53
     pixel = SDL_MapRGBA(fenetreImage->format, u_r, u_v, u_b, u_a);
64
-
65 54
     definirPixel(fenetreImage, x, y, pixel);
66
-    
55
+
67 56
 }
68 57
 
69 58
 void afficherFenetre() {
@@ -79,24 +68,27 @@ void afficherFenetre() {
79 68
 void attendreFenetre() {
80 69
     SDL_Event evenement;
81 70
 
82
-    while (evenement.type != SDL_QUIT) {
71
+    do {
83 72
         SDL_WaitEvent(&evenement);
84
-    }
73
+    } while (evenement.type != SDL_QUIT && evenement.type != SDL_KEYDOWN); //|| evenement.type != SDL_KEYDOWN);
85 74
 }
86 75
 
87 76
 void fermerFenetre() {
88 77
     SDL_UnlockSurface(fenetreImage);
89 78
     SDL_FreeSurface(fenetreImage);
90 79
     SDL_Quit();
80
+    fenetreOuverte = false;
91 81
 }
92 82
 
93
-void ouvrirFenetre(int dimensionX, int dimensionY, std::string nom) {  // Crée une fenêtre
83
+
84
+void ouvrirFenetre(int dimensionX, int dimensionY, std::string nom) { // Crée une fenêtre
94 85
     SDL_Init(SDL_INIT_VIDEO);
95 86
     fenetreDimensionX = dimensionX;
96 87
     fenetreDimensionY = dimensionY;
97 88
     fenetreEcran = SDL_SetVideoMode(fenetreDimensionX, fenetreDimensionY, 32, SDL_HWSURFACE);
98
-    fenetreImage = SDL_CreateRGBSurface(SDL_HWSURFACE, fenetreDimensionX, fenetreDimensionX, 32, 0, 0, 0, 0);
89
+    fenetreImage = SDL_CreateRGBSurface(SDL_HWSURFACE, fenetreDimensionX, fenetreDimensionY, 32, 0, 0, 0, 0);
99 90
     SDL_FillRect(fenetreImage, NULL, SDL_MapRGB(fenetreEcran->format, 0, 0, 0));
100 91
     setNomFenetre(nom);
101 92
     SDL_LockSurface(fenetreImage);
102
-}
93
+    fenetreOuverte = true;
94
+}

+ 123
- 15
src/analyserCommande.cpp View File

@@ -1,13 +1,51 @@
1 1
 #include <vector>
2 2
 #include <string>
3
+#include <iostream>
3 4
 
4
-using namespace std;
5
+int chaineVersEntier(string chaine) {
6
+    return (int) chaine[0];
7
+}
8
+
9
+void afficherImage(Image image) {
10
+    int x, y, r, v, b, dimensionX = image.g_dimensionX(), dimensionY = image.g_dimensionY(), typeComposantes = image.g_typeComposantes();
11
+
12
+    float ratio = (255.0 / image.g_maxComposante());
13
+    Pixel pixel;
14
+
15
+    if (fenetreOuverte && (dimensionX != fenetreDimensionX || dimensionY != fenetreDimensionY)) {
16
+        fermerFenetre();
17
+    }
5 18
 
6
-int messageErreur(string message) {
7
-    cerr << "Erreur : " << message << endl;
19
+    ouvrirFenetre(dimensionX, dimensionY, "PILG - Test");
20
+
21
+    for (x = 0; x < dimensionX; x++) {
22
+        for (y = 0; y < dimensionY; y++) {
23
+            image.g_pixel(x, y, pixel);
24
+            switch (typeComposantes) {
25
+            case PILG_BIN:
26
+                r = v = b = (pixel.n ? 255 : 0);
27
+                break;
28
+            case PILG_NIV:
29
+                r = v = b = pixel.g * ratio;
30
+                break;
31
+            case PILG_RVB:
32
+                r = pixel.r * ratio;
33
+                v = pixel.v * ratio;
34
+                b = pixel.b * ratio;
35
+                break;
36
+            }
37
+            pointFenetre(x, y, r, v, b);
38
+        }
39
+    }
40
+
41
+    afficherFenetre();
42
+}
43
+
44
+void messageErreur(string message) {
45
+    cerr << "Erreur : " << message << '.' << endl;
8 46
 }
9 47
 
10
-int decoupeCommande(string commande, vector< string > &decoupe) {
48
+void decoupeCommande(string commande, vector< string > &decoupe) {
11 49
     // Boucle de découpage
12 50
     // vector< string > decoupe;
13 51
     string elementCourrant = "";
@@ -64,26 +102,96 @@ int decoupeCommande(string commande, vector< string > &decoupe) {
64 102
     }
65 103
 }
66 104
 
67
-int analyserDecoupe(vector< string > decoupe) {
68
-    for (int i = 0; i < decoupe.size(); i++) { // DEBUG
69
-        cout << "Argument " << i << " = " << decoupe[i] << endl;
105
+typedef struct Commande {
106
+    string fonction;
107
+
108
+    int x1, x2, y1, y2;
109
+    string fichierEntree, fichierSortie;
110
+    Pixel couleur;
111
+    // ...
112
+
113
+    vector< string > argumentsPresents;
114
+} Commande;
115
+
116
+int analyserDecoupe(Commande &commande, vector< string > decoupe, Image const &image) {
117
+    // for (int i = 0; i < decoupe.size(); i++) { // DEBUG
118
+    //     cout << "Argument " << i << " = " << decoupe[i] << endl;
119
+    // }
120
+
121
+    commande.couleur = image.g_pixelVide();
122
+    commande.fonction = decoupe[0];
123
+
124
+    // Analyse des arguments
125
+    // for (int i = 1; i < decoupe.size(); i++) {
126
+    //     ...
127
+    // }
128
+
129
+    return 0;
130
+}
131
+
132
+bool argumentPresent(Commande commande, string argumentVoulu) {
133
+    for (int i = 0; i < commande.argumentsPresents.size(); i++) {
134
+        if (commande.argumentsPresents[i] == argumentVoulu) {
135
+            return true;
136
+        }
137
+    }
138
+    return false;
139
+}
140
+
141
+int executerCommande(Commande commande, Image &image) {
142
+    if (commande.fonction == "rectangle") {
143
+        commande.couleur.v = image.g_maxComposante(); // DEBUG
144
+        rectangle(image, image, 5, 5, 10, 10, commande.couleur); // DEBUG
145
+        if (argumentPresent(commande, "x1") && argumentPresent(commande, "x2")
146
+                && argumentPresent(commande, "y1") && argumentPresent(commande, "y2")
147
+                && argumentPresent(commande, "couleur")) {
148
+            // TODO
149
+        } else {
150
+            return 2;
151
+        }
152
+    } else {
153
+        return 1;
154
+    }
155
+    return 0;
156
+}
157
+
158
+void procederCommande(vector< string > decoupe, Image &image) {
159
+    Commande commande;
160
+    switch (analyserDecoupe(commande, decoupe, image)) {
161
+    case 0:
162
+        switch (executerCommande(commande, image)) {
163
+        case 0:
164
+            break;
165
+        case 1:
166
+            messageErreur("Fonction inconnue");
167
+            break;
168
+        case 2:
169
+            messageErreur("Arguments manquants");
170
+            break;
171
+        default:
172
+            messageErreur("Impossible d'éxecuter la fonction");
173
+        }
174
+        break;
175
+    default:
176
+        messageErreur("Impossible d'analyse de la commande");
177
+        break;
70 178
     }
71 179
 }
72 180
 
73
-int boucleDeCommandes() {
181
+int boucleDeCommandes(Image image) { // REPL
74 182
     bool continuer = true;
75
-    string commande;
183
+    string commandeTexte;
76 184
 
77 185
     while (continuer) {
78 186
         cout << "$ ";
79
-        getline(cin, commande);
80
-        if (commande == "exit" || commande == "quitter") {
187
+        getline(cin, commandeTexte);
188
+        if (commandeTexte == "quitter" || commandeTexte == "exit") {
81 189
             continuer = false;
82 190
         } else {
83 191
             vector< string > decoupe;
84
-            decoupeCommande(commande, decoupe);
85
-            analyserDecoupe(decoupe);
192
+            decoupeCommande(commandeTexte, decoupe);
193
+            procederCommande(decoupe, image);
194
+            afficherImage(image);
86 195
         }
87 196
     }
88
-    return 0;
89
-}
197
+}

+ 26
- 23
src/image.cpp View File

@@ -28,8 +28,8 @@ unsigned int Image::g_maxComposante() const {
28 28
     return m_maxComposante;
29 29
 }
30 30
 
31
-int Image::g_point(unsigned int x, unsigned int y, Pixel &pixel) const {
32
-    if (enLimites(x, y)) {
31
+int Image::g_pixel(unsigned int x, unsigned int y, Pixel &pixel) const {
32
+    if (v_dimensions(x, y)) {
33 33
         pixel = m_tab[x][y];
34 34
         return 0;
35 35
     } else {
@@ -38,11 +38,8 @@ int Image::g_point(unsigned int x, unsigned int y, Pixel &pixel) const {
38 38
 }
39 39
 
40 40
 // Setters
41
-int Image::s_point(unsigned int x, unsigned int y, Pixel pixel) {
42
-    if (enLimites(x, y)
43
-            && pixel.typeComposantes == m_typeComposantes
44
-            && pixel.maxComposante == m_maxComposante
45
-            && enLimitesComposantes(pixel)) {
41
+int Image::s_pixel(unsigned int x, unsigned int y, Pixel pixel) {
42
+    if (v_dimensions(x, y) && v_pixel(pixel)) {
46 43
         m_tab[x][y] = pixel;
47 44
         return 0;
48 45
     } else {
@@ -71,25 +68,31 @@ Pixel Image::g_pixelVide() const {
71 68
     return pixel;
72 69
 }
73 70
 
74
-bool Image::enLimitesComposantes(Pixel pixel) {
75
-    switch (pixel.typeComposantes) {
76
-    case PILG_BIN:
77
-        return true;
78
-        break;
79
-    case PILG_NIV:
80
-        return (pixel.g <= pixel.maxComposante);
81
-        break;
82
-    case PILG_RVB:
83
-        return (pixel.r <= pixel.maxComposante
84
-                && pixel.v <= pixel.maxComposante
85
-                && pixel.b <= pixel.maxComposante);
86
-        break;
87
-    default:
71
+// Validateurs
72
+bool Image::v_pixel(Pixel pixel) const {
73
+    if  (pixel.typeComposantes == m_typeComposantes
74
+            && pixel.maxComposante == m_maxComposante) {
75
+        switch (pixel.typeComposantes) {
76
+        case PILG_BIN:
77
+            return true;
78
+            break;
79
+        case PILG_NIV:
80
+            return (pixel.g <= pixel.maxComposante);
81
+            break;
82
+        case PILG_RVB:
83
+            return (pixel.r <= pixel.maxComposante
84
+                    && pixel.v <= pixel.maxComposante
85
+                    && pixel.b <= pixel.maxComposante);
86
+            break;
87
+        default:
88
+            return false;
89
+            break;
90
+        }
91
+    } else {
88 92
         return false;
89
-        break;
90 93
     }
91 94
 }
92 95
 
93
-bool Image::enLimites(unsigned int x, unsigned int y) const {
96
+bool Image::v_dimensions(unsigned int x, unsigned int y) const {
94 97
     return (x >= 0 && x < m_dimensionX && y >= 0 && y < m_dimensionY);
95 98
 }

+ 6
- 6
src/image.h View File

@@ -20,20 +20,20 @@ public:
20 20
     unsigned int g_dimensionY() const;
21 21
     PILG_Comp g_typeComposantes() const;
22 22
     unsigned int g_maxComposante() const;
23
-    int g_point(unsigned int x, unsigned int y, Pixel &pixel) const;
23
+    int g_pixel(unsigned int x, unsigned int y, Pixel &pixel) const;
24 24
     // Setters
25
-    int s_point(unsigned int x, unsigned int y, Pixel pixel);
25
+    int s_pixel(unsigned int x, unsigned int y, Pixel pixel);
26 26
     // Utilitaires
27 27
     Pixel g_pixelVide() const;
28
+    // Validateurs
29
+    bool v_pixel(Pixel pixel) const;
30
+    bool v_dimensions(unsigned int x, unsigned int y) const;
28 31
 
29 32
 private:
30
-    // Utilitaires
31
-    static bool enLimitesComposantes(Pixel pixel);
32
-    bool enLimites(unsigned int x, unsigned int y) const;
33 33
     // Variables
34 34
     unsigned int m_dimensionX;
35 35
     unsigned int m_dimensionY;
36
-    PILG_Comp m_typeComposantes;  // 0 : N&B, 1 : Niveaux de gris, 2 : RVB
36
+    PILG_Comp m_typeComposantes;
37 37
     unsigned int m_maxComposante;  // Maximum de composante (sauf binaire)
38 38
     std::vector< std::vector< Pixel > > m_tab;
39 39
 };

+ 63
- 5
src/main.cpp View File

@@ -1,5 +1,4 @@
1 1
 #include <iostream>
2
-#include <string>
3 2
 
4 3
 using namespace std;
5 4
 
@@ -8,23 +7,82 @@ using namespace std;
8 7
 #include "traitementImage.cpp"
9 8
 #include "analyserCommande.cpp"
10 9
 
10
+#define NOMBREOR 1.61803398875
11
+
12
+Image imageDefaut() {
13
+    int dimY = 256, dimX = dimY * NOMBREOR, maxComposante = 255;
14
+    Image imageRoue(dimX, dimY, maxComposante, PILG_RVB);
15
+    Pixel pointRoue = imageRoue.g_pixelVide();
16
+    int x, y, step;
17
+    float substep, lum;
18
+    for (x = 0; x < dimX; x++) {
19
+        for (y = 0; y < dimY; y++) {
20
+            step = (x * 6.0) / dimX;
21
+            substep = (x - step * (dimX / 6.0)) / (dimX / 6.0) * maxComposante;
22
+            lum = 1 - ((float) y) / dimY;
23
+            switch (step) {
24
+            case 0:
25
+                pointRoue.r = maxComposante;
26
+                pointRoue.v = substep;
27
+                pointRoue.b = 0;
28
+                break;
29
+            case 1:
30
+                pointRoue.r = maxComposante - substep;
31
+                pointRoue.v = maxComposante;
32
+                pointRoue.b = 0;
33
+                break;
34
+            case 2:
35
+                pointRoue.r = 0;
36
+                pointRoue.v = maxComposante;
37
+                pointRoue.b = substep;
38
+                break;
39
+            case 3:
40
+                pointRoue.r = 0;
41
+                pointRoue.v = maxComposante - substep;
42
+                pointRoue.b = maxComposante;
43
+                break;
44
+            case 4:
45
+                pointRoue.r = substep;
46
+                pointRoue.v = 0;
47
+                pointRoue.b = maxComposante;
48
+                break;
49
+            case 5:
50
+                pointRoue.r = maxComposante;
51
+                pointRoue.v = 0;
52
+                pointRoue.b = maxComposante - substep;
53
+                break;
54
+            }
55
+
56
+            // Dégradé vers le noir
57
+            pointRoue.r = pointRoue.r * lum;
58
+            pointRoue.v = pointRoue.v * lum;
59
+            pointRoue.b = pointRoue.b * lum;
60
+
61
+            imageRoue.s_pixel(x, y, pointRoue);
62
+        }
63
+    }
64
+    return imageRoue;
65
+}
11 66
 
12 67
 int main(int argc, char *args[]) {
13
-#if defined(WIN32)  // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
68
+#if defined(WIN32)  // Permet de refaire fonctionner cout et cerr sous Windows après démarrage de SDL
14 69
     freopen("CON", "w", stdout);
15 70
     freopen("CON", "w", stderr);
16 71
 #endif
17 72
 
18 73
     cout << "PILG" << endl;  // Message d'entrée et de test
19 74
 
20
-	if (argc > 1) {
75
+    Image image = imageDefaut();
76
+
77
+    if (argc > 1) { // Si la commande a été entrée avec des arguments
21 78
         vector< string > decoupe;
22 79
         for (int i = 1; i < argc; i++) {
23 80
             decoupe.push_back(args[i]);
24 81
         }
25
-        analyserDecoupe(decoupe);
82
+        procederCommande(decoupe, image);
26 83
     } else {
27
-        boucleDeCommandes();
84
+        afficherImage(image);
85
+        boucleDeCommandes(image);
28 86
     }
29 87
 
30 88
     return 0;

+ 0
- 140
src/test.cpp View File

@@ -1,140 +0,0 @@
1
-#include <iostream>
2
-#include <string>
3
-
4
-using namespace std;
5
-
6
-#include "affichageFenetre.cpp"
7
-#include "image.h"
8
-#include "traitementImage.cpp"
9
-#include "analyserCommande.cpp"
10
-
11
-
12
-int main(int argc, char *args[]) {
13
-#if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
14
-    freopen("CON", "w", stdout);
15
-    freopen("CON", "w", stderr);
16
-#endif
17
-
18
-    cout << "PILG - Debug" << endl;  // Message d'entrée et de test
19
-
20
-    // Analyse de commandes
21
-    if (argc > 1) {
22
-        vector< string > decoupe;
23
-        for (int i = 1; i < argc; i++) {
24
-            decoupe.push_back(args[i]);
25
-        }
26
-        analyserDecoupe(decoupe);
27
-    } else {
28
-        boucleDeCommandes();
29
-    }
30
-
31
-    // int dimX = 640, dimY = 128;
32
-    // ouvrirFenetre(dimX, dimY, "PILG - Fenêtre de debug");
33
-
34
-    // // Création imageRoue
35
-    // Image imageRoue(dimX, dimY, 255, PILG_RVB);
36
-    // Pixel pointRoue = imageRoue.g_pixelVide();
37
-    // int x, y, step;
38
-    // float substep, lum;
39
-    // for (x = 0; x < dimX; x++) {
40
-    //     for (y = 0; y < dimY; y++) {
41
-    //         step = (x * 6.0) / dimX;
42
-    //         substep = (x - step * (dimX / 6.0)) / (dimX / 6.0)*255;
43
-    //         lum = 1-((float) y)/dimY;
44
-    //         switch (step) {
45
-    //         case 0:
46
-    //             pointRoue.r = 255;
47
-    //             pointRoue.v = substep;
48
-    //             pointRoue.b = 0;
49
-    //             break;
50
-    //         case 1:
51
-    //             pointRoue.r = 255-substep;
52
-    //             pointRoue.v = 255;
53
-    //             pointRoue.b = 0;
54
-    //             break;
55
-    //         case 2:
56
-    //             pointRoue.r = 0;
57
-    //             pointRoue.v = 255;
58
-    //             pointRoue.b = substep;
59
-    //             break;
60
-    //         case 3:
61
-    //             pointRoue.r = 0;
62
-    //             pointRoue.v = 255-substep;
63
-    //             pointRoue.b = 255;
64
-    //             break;
65
-    //         case 4:
66
-    //             pointRoue.r = substep;
67
-    //             pointRoue.v = 0;
68
-    //             pointRoue.b = 255;
69
-    //             break;
70
-    //         case 5:
71
-    //             pointRoue.r = 255;
72
-    //             pointRoue.v = 0;
73
-    //             pointRoue.b = 255-substep;
74
-    //             break;
75
-    //         }
76
-    //         // Dégradé vers le noir
77
-    //         pointRoue.r = pointRoue.r*lum;
78
-    //         pointRoue.v = pointRoue.v*lum;
79
-    //         pointRoue.b = pointRoue.b*lum;
80
-
81
-    //         // // Ajout de luminosité
82
-    //         // pointRoue.r = pointRoue.r + 50;
83
-    //         // pointRoue.v = pointRoue.v + 50;
84
-    //         // pointRoue.b = pointRoue.b + 50;
85
-
86
-    //         // Remise dans l'intervalle
87
-    //         pointRoue.r = (pointRoue.r > 255 ? 255 : pointRoue.r);
88
-    //         pointRoue.v = (pointRoue.v > 255 ? 255 : pointRoue.v);
89
-    //         pointRoue.b = (pointRoue.b > 255 ? 255 : pointRoue.b);
90
-
91
-    //         if (imageRoue.s_point(x, y, pointRoue) == 1) {
92
-    //             cerr << "Erreur : s_point() a été entré avec des valeurs incorrectes" << endl;
93
-    //             cout << "X : " << x << " - Y: " << y << " - R : " << pointRoue.r << " - V : " << pointRoue.v << " - B : " << pointRoue.b << endl; // DEBUG
94
-    //             return 1;
95
-    //         }
96
-    //         imageRoue.g_point(x, y, pointRoue);
97
-    //         pointFenetre(x, y, pointRoue.r, pointRoue.v, pointRoue.b);
98
-    //     }
99
-    // }
100
-    // afficherFenetre();
101
-
102
-    // Cycle de couleurs avec utilisation d'Image
103
-    // Image imageRoue(dimX, dimY, 255, PILG_RVB);
104
-    // Pixel pointRoueRoue = imageRoue.g_pixelVide();
105
-    // int x, y, c;
106
-    // for (c = 0; c < 256; c++) {  // À peu près 28 FPS avec SDL
107
-    //     for (x = 0; x < dimX; x++) {
108
-    //         for (y = 0; y < dimY; y++) {
109
-    //             point.r = c;
110
-    //             point.v = image.g_maxComposante() - c;
111
-    //             point.b = 0;
112
-    //             if (image.s_point(x, y, point) == 1) {
113
-    //                 cerr << "Erreur : s_point() a été entré avec des valeurs incorrectes" << endl;
114
-    //                 cout << "X : " << x << " - Y: " << y << " - R : " << point.r << " - V : " << point.v << " - B : " << point.b << endl; // DEBUG
115
-    //                 return 1;
116
-    //             }
117
-    //             image.g_point(x, y, point);
118
-    //             pointFenetre(x, y, point.r, point.v, point.b);
119
-    //         }
120
-    //     }
121
-    //     afficherFenetre();
122
-    // }
123
-
124
-    // // Cycle de couleurs sans utilisation d'Image
125
-    // int x, y, c;
126
-    // for (c = 0; c < 256; c++) {  // À peu près 75 FPS avec SDL
127
-    //     for (x = 0; x < dimX; x++) {
128
-    //         for (y = 0; y < dimY; y++) {
129
-    //             pointFenetre(x, y, c, 255 - c, 0);
130
-    //         }
131
-    //     }
132
-    //     afficherFenetre();
133
-    // }
134
-
135
-    // cout << "Éxecution du programme terminée. Vous pouvez quitter la fenêtre." << endl;
136
-    // attendreFenetre();
137
-    // fermerFenetre();
138
-
139
-    return 0;
140
-}

+ 177
- 0
src/testing.cpp View File

@@ -0,0 +1,177 @@
1
+#include <iostream>
2
+#include <string>
3
+
4
+using namespace std;
5
+
6
+#include "affichageFenetre.cpp"
7
+#include "image.h"
8
+#include "traitementImage.cpp"
9
+#include "analyserCommande.cpp"
10
+
11
+Image genererRoue(int dimX, int dimY, int maxComposante) {
12
+    Image imageRoue(dimX, dimY, maxComposante, PILG_RVB);
13
+    Pixel pointRoue = imageRoue.g_pixelVide();
14
+    int x, y, step;
15
+    float substep, lum;
16
+    for (x = 0; x < dimX; x++) {
17
+        for (y = 0; y < dimY; y++) {
18
+            step = (x * 6.0) / dimX;
19
+            substep = (x - step * (dimX / 6.0)) / (dimX / 6.0) * maxComposante;
20
+            lum = 1 - ((float) y) / dimY;
21
+            switch (step) {
22
+            case 0:
23
+                pointRoue.r = maxComposante;
24
+                pointRoue.v = substep;
25
+                pointRoue.b = 0;
26
+                break;
27
+            case 1:
28
+                pointRoue.r = maxComposante - substep;
29
+                pointRoue.v = maxComposante;
30
+                pointRoue.b = 0;
31
+                break;
32
+            case 2:
33
+                pointRoue.r = 0;
34
+                pointRoue.v = maxComposante;
35
+                pointRoue.b = substep;
36
+                break;
37
+            case 3:
38
+                pointRoue.r = 0;
39
+                pointRoue.v = maxComposante - substep;
40
+                pointRoue.b = maxComposante;
41
+                break;
42
+            case 4:
43
+                pointRoue.r = substep;
44
+                pointRoue.v = 0;
45
+                pointRoue.b = maxComposante;
46
+                break;
47
+            case 5:
48
+                pointRoue.r = maxComposante;
49
+                pointRoue.v = 0;
50
+                pointRoue.b = maxComposante - substep;
51
+                break;
52
+            }
53
+            // Dégradé vers le noir
54
+            pointRoue.r = pointRoue.r * lum;
55
+            pointRoue.v = pointRoue.v * lum;
56
+            pointRoue.b = pointRoue.b * lum;
57
+
58
+            // // Remise dans l'intervalle
59
+            // pointRoue.r = (pointRoue.r > maxComposante ? maxComposante : pointRoue.r);
60
+            // pointRoue.v = (pointRoue.v > maxComposante ? maxComposante : pointRoue.v);
61
+            // pointRoue.b = (pointRoue.b > maxComposante ? maxComposante : pointRoue.b);
62
+
63
+            if (imageRoue.s_pixel(x, y, pointRoue) == 1) {
64
+                cerr << "Erreur : s_pixel() a été entré avec des valeurs incorrectes" << endl;
65
+                cout << "X : " << x << " - Y: " << y << " - R : " << pointRoue.r << " - V : " << pointRoue.v << " - B : " << pointRoue.b << endl; // DEBUG
66
+            }
67
+            imageRoue.g_pixel(x, y, pointRoue);
68
+        }
69
+    }
70
+    return imageRoue;
71
+}
72
+
73
+Image genererDegrade(int dimX, int dimY, int maxComposante) {
74
+    Image image(dimX, dimY, maxComposante, PILG_NIV);
75
+    Pixel pixel = image.g_pixelVide();
76
+    int x, y;
77
+    for (x = 0; x < dimX; x++) {
78
+        for (y = 0; y < dimY; y++) {
79
+            pixel.g = (float) x * maxComposante / dimX;
80
+            image.s_pixel(x, y, pixel);
81
+        }
82
+    }
83
+    return image;
84
+}
85
+
86
+Image genererBruit(int dimX, int dimY) {
87
+    Image image(dimX, dimY, 0, PILG_BIN);
88
+    Pixel pixel = image.g_pixelVide();
89
+    int x, y;
90
+    for (x = 0; x < dimX; x++) {
91
+        for (y = 0; y < dimY; y++) {
92
+            pixel.n = ((float) rand() / RAND_MAX) < ((float) x / dimX);
93
+            image.s_pixel(x, y, pixel);
94
+        }
95
+    }
96
+    return image;
97
+}
98
+
99
+int main(int argc, char *args[]) {
100
+#if defined(WIN32) // Permet de refaire fonctionner cout et cerr sous Windows après démarrage de SDL
101
+    freopen("CON", "w", stdout);
102
+    freopen("CON", "w", stderr);
103
+#endif
104
+
105
+    cout << "PILG - Debug" << endl;  // Message d'entrée et de test
106
+
107
+    // // Analyse de commandes
108
+    // if (argc > 1) {
109
+    //     vector< string > decoupe;
110
+    //     for (int i = 1; i < argc; i++) {
111
+    //         decoupe.push_back(args[i]);
112
+    //     }
113
+    //     analyserDecoupe(decoupe);
114
+    // } else {
115
+    //     boucleDeCommandes();
116
+    // }
117
+
118
+    // // Afficher image par défaut
119
+    // // Image image = genererRoue(200, 200, 255);
120
+    // // Image image = genererDegrade(200, 200, 255);
121
+    // Image image = genererBruit(200, 200);
122
+    // Pixel couleurRectangle;
123
+
124
+    // couleurRectangle = image.g_pixelVide();
125
+    // // couleurRectangle.b = 255;
126
+    // // couleurRectangle.g = 255;
127
+    // couleurRectangle.b = true;
128
+
129
+    // rectangle(image, image, 5, 5, 10, 10, couleurRectangle);
130
+
131
+    // afficherImage(image);
132
+    // attendreFenetre();
133
+
134
+    // // Neige en dégradé
135
+    // for (int i; i < 300; i++) {
136
+    //     afficherImage(genererBruit(200, 200));
137
+    // }
138
+
139
+    // Cycle de couleurs avec utilisation d'Image
140
+    // Image imageRoue(dimX, dimY, 255, PILG_RVB);
141
+    // Pixel pointRoueRoue = imageRoue.g_pixelVide();
142
+    // int x, y, c;
143
+    // for (c = 0; c < 256; c++) {  // À peu près 28 FPS avec SDL
144
+    //     for (x = 0; x < dimX; x++) {
145
+    //         for (y = 0; y < dimY; y++) {
146
+    //             pixel.r = c;
147
+    //             pixel.v = image.g_maxComposante() - c;
148
+    //             pixel.b = 0;
149
+    //             if (image.s_pixel(x, y, pixel) == 1) {
150
+    //                 cerr << "Erreur : s_pixel() a été entré avec des valeurs incorrectes" << endl;
151
+    //                 cout << "X : " << x << " - Y: " << y << " - R : " << pixel.r << " - V : " << pixel.v << " - B : " << pixel.b << endl; // DEBUG
152
+    //                 return 1;
153
+    //             }
154
+    //             image.g_pixel(x, y, pixel);
155
+    //             pointFenetre(x, y, pixel.r, pixel.v, pixel.b);
156
+    //         }
157
+    //     }
158
+    //     afficherFenetre();
159
+    // }
160
+
161
+    // // Cycle de couleurs sans utilisation d'Image
162
+    // int x, y, c;
163
+    // for (c = 0; c < 256; c++) {  // À peu près 75 FPS avec SDL
164
+    //     for (x = 0; x < dimX; x++) {
165
+    //         for (y = 0; y < dimY; y++) {
166
+    //             pointFenetre(x, y, c, 255 - c, 0);
167
+    //         }
168
+    //     }
169
+    //     afficherFenetre();
170
+    // }
171
+
172
+    // cout << "Éxecution du programme terminée. Vous pouvez quitter la fenêtre." << endl;
173
+    // attendreFenetre();
174
+    // fermerFenetre();
175
+
176
+    return 0;
177
+}

+ 36
- 38
src/traitementImage.cpp View File

@@ -1,18 +1,18 @@
1
-// Gestion de fichiers 
2
-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
1
+// Gestion de fichiers
2
+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
3 3
     Image *nouvelle = new Image(dimensionX, dimensionY, maxComposante, typeComposantes);
4 4
     sortie = *nouvelle;
5 5
 }
6 6
 
7
-int ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à partir du nom du fichier ***Geoffrey
7
+void ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à partir du nom du fichier ***Geoffrey
8 8
 
9 9
 }
10 10
 
11
-int sauver(Image entree, string nomFichier, bool ASCII, string commentaire) { // Sauvegarder l'image obtenue dans un nouveau fichier
11
+void sauver(Image entree, string nomFichier, bool ASCII, string commentaire) { // Sauvegarder l'image obtenue dans un nouveau fichier
12 12
 
13 13
 }
14 14
 
15
-int import(Image entree, Image &sortie, string nomFichier, int x, int y) {
15
+void import(Image entree, Image &sortie, string nomFichier, int x, int y) {
16 16
     // Image fichierImporte;
17 17
     // sortie = entree
18 18
     // ouvrir(fichierImporte, nomFichier)
@@ -20,14 +20,12 @@ int import(Image entree, Image &sortie, string nomFichier, int x, int y) {
20 20
     //     Pour y1 = 0 to y1 = fichierImporte.g_dimensionY
21 21
     //         sortie.s_pixel(x1 + x, y1 + y, fichierImporte.g_pixel(x1, x2));
22 22
     //     FinPour
23
-    // FinPour 
23
+    // FinPour
24 24
 
25 25
 }
26 26
 
27
-// Edition ***Geoffrey
28
-
29 27
 // Couleur
30
-int teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l'image
28
+void teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l'image
31 29
     // Si la teinte appartient à [0;1[
32 30
     //     r1 = 0
33 31
     //     r2 = 1
@@ -55,9 +53,9 @@ int teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l
55 53
     // Fin Si
56 54
     // Pour x=0 à x=image.getDimensionX()
57 55
     //     Pour y=0 à y=image.getDimensionY()
58
-    //        
59
-    //        
60
-    //        
56
+    //
57
+    //
58
+    //
61 59
     //         pixel.r = r1+(r2-r1)*valeur
62 60
     //         pixel.v = v1+(v2-v1)*valeur
63 61
     //         pixel.b = b1+(b2-b1)*valeur
@@ -65,7 +63,7 @@ int teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l
65 63
     // Fin Pour
66 64
 }
67 65
 
68
-int saturation(Image entree, Image &sortie, float saturation) { // Sature l'image
66
+void saturation(Image entree, Image &sortie, float saturation) { // Sature l'image
69 67
     // Pour x = image.g_DimensionX()
70 68
     //     Pour y = image.g_DimensionY()
71 69
     //         Ajouter la variable saturation à chaque valeur de chaque pixel
@@ -74,29 +72,29 @@ int saturation(Image entree, Image &sortie, float saturation) { // Sature l'imag
74 72
     // Fin Pour
75 73
 }
76 74
 
77
-int luminosite(Image entree, Image &sortie, float luminosite) { // Augmente la luminosité de l'image
75
+void luminosite(Image entree, Image &sortie, float luminosite) { // Augmente la luminosité de l'image
78 76
     // Pour x=0 à x=image.g_DimensionX()
79 77
     //     Pour y=0 à y=image.g_DimensionY()
80 78
     //         si image.g_typeComposante=1
81
-    //             pixel = image.g_point(x,y);
79
+    //             pixel = image.g_pixel(x,y);
82 80
     //             pixel.g = luminosite*10+pixel.g;
83
-    //             image.s_point(x, y, pixel);
81
+    //             image.s_pixel(x, y, pixel);
84 82
     //         sinon si image.g_typeComposante=2
85
-    //             pixel = image.g_point(x,y);
83
+    //             pixel = image.g_pixel(x,y);
86 84
     //             pixel.r = luminosite*10+pixel.r;
87 85
     //             pixel.v = luminosite*10+pixel.v;
88 86
     //             pixel.b = luminosite*10+pixel.b;
89
-    //             image.s_point(x, y, pixel);
87
+    //             image.s_pixel(x, y, pixel);
90 88
     //         Fin si
91 89
     //     Fin Pour
92 90
     // Fin Pour
93 91
 }
94 92
 
95
-int contraste(Image entree, Image &sortie, float contraste) { // Accentue les contrastes de l'image
93
+void contraste(Image entree, Image &sortie, float contraste) { // Accentue les contrastes de l'image
96 94
     // pour x=0 à x=image.g_dimensionX()
97 95
     //    pour y=0 à y=image.g_DimensionY()
98 96
     //        si image.g_typeComposante=1
99
-    //            pixel = image.g_point(x,y);
97
+    //            pixel = image.g_pixel(x,y);
100 98
     //            pixel.g = contraste*pixel.g;
101 99
     //             if pixel.g > Image.g_maxComposante
102 100
     //                 pixel.g = Image.g_maxComposante
@@ -106,7 +104,7 @@ int contraste(Image entree, Image &sortie, float contraste) { // Accentue les co
106 104
 }
107 105
 
108 106
 // Dessin
109
-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)
107
+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)
110 108
     //    int x, y, dx, dy ;
111 109
     //    float e, e(1,0), e(0,1) ;  // valeur d’erreur et incréments
112 110
     //    dy ← y2 - y1 ;
@@ -126,38 +124,38 @@ int trait(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel pix
126 124
 
127 125
 }
128 126
 
129
-int rectangle(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel couleur) {
130
-    // sortie = entree    
131
-    // pour x=x1 à x=x2
132
-    //    pour y=y1 à y=y2
133
-    //        sortie.s_pixel(x, y, couleur)
134
-    //     FinPour
135
-    // FinPour
127
+void rectangle(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel couleur) {
128
+    sortie = entree;
129
+    for (int x = x1; x <= x2; x++) {
130
+        for (int y = y1; y <= y2; y++) {
131
+            sortie.s_pixel(x, y, couleur);
132
+        }
133
+    }
136 134
 
137 135
 }
138 136
 
139
-int cercle(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) {
137
+void cercle(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) {
140 138
 
141 139
 }
142 140
 
143
-int disque(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) {
141
+void disque(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) {
144 142
 
145 143
 }
146 144
 
147 145
 // Geométrie
148
-int zoom(Image entree, Image &sortie) {
146
+void zoom(Image entree, Image &sortie) {
149 147
 
150 148
 }
151 149
 
152
-int pivoter(Image entree, Image &sortie) {
150
+void pivoter(Image entree, Image &sortie) {
153 151
 
154 152
 }
155 153
 
156
-int retourner(Image entree, Image &sortie, int rotation) {
154
+void retourner(Image entree, Image &sortie, int rotation) {
157 155
 
158 156
 }
159 157
 
160
-int redimensionner(Image entree, Image &sortie, int x1, int x2, int y1, int y2) {
158
+void redimensionner(Image entree, Image &sortie, int x1, int x2, int y1, int y2) {
161 159
     // Image *nouvelle = new Image(x2-x1, y2-y1, entree.g_maxComposante(), entree.g_typeComposantes());
162 160
     // sortie = *nouvelle;
163 161
     // pour x=x1 à x=x2
@@ -168,19 +166,19 @@ int redimensionner(Image entree, Image &sortie, int x1, int x2, int y1, int y2)
168 166
 }
169 167
 
170 168
 // Modification couleur
171
-int convBIN(Image entree, Image &sortie) {
169
+void convBIN(Image entree, Image &sortie) {
172 170
 
173 171
 }
174 172
 
175
-int convNIV(Image entree, Image &sortie) {
173
+void convNIV(Image entree, Image &sortie) {
176 174
 
177 175
 }
178 176
 
179
-int convRVB(Image entree, Image &sortie) {
177
+void convRVB(Image entree, Image &sortie) {
180 178
 
181 179
 }
182 180
 
183 181
 //Help
184
-int aide() {
182
+void aide() {
185 183
     //Afficher le texte suivant :
186 184
 }