Browse Source

[v1.0.0] Teinte, Saturation, Luminosité

Passage en v1.0.0 finale (il faut bien, à un moment...).
* Traitement image & commandes
	* Ajout de la fonction teinte
	* Ajout de la fonction saturation
	* Ajout de la fonction luminosité
* Utilitaires
	* Ajout de conversions RVB→TSL & TSL→RVB pour les fonctions teinte, saturation et luminosité
	* L'image par défaut est désormais générée à partir de teinte et luminosité
* Affichage de la fenêtre
	* La taille de l'écran est récupérable
	* L'échelle est désormais variable et est calculée selon les dimensions de l'écran
tags/v1.0.0
parent
commit
82a60fccf9
9 changed files with 264 additions and 122 deletions
  1. 1
    1
      README.md
  2. 3
    4
      TODO.md
  3. 19
    9
      src/affichageFenetre.cpp
  4. 41
    24
      src/analyserCommande.cpp
  5. 2
    2
      src/image.h
  6. 1
    0
      src/main.cpp
  7. 33
    12
      src/testing.cpp
  8. 47
    12
      src/traitementImage.cpp
  9. 117
    58
      src/utilitaires.cpp

+ 1
- 1
README.md View File

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

+ 3
- 4
TODO.md View File

@@ -30,9 +30,9 @@
30 30
         * Annuler
31 31
         * Refaire
32 32
     * Couleur **D**
33
-        * Teinte **D**
34
-        * Saturation **D**
35
-        * Luminosité **D**
33
+        * Teinte **C**
34
+        * Saturation **C**
35
+        * Luminosité **C**
36 36
         * Contraste
37 37
     * Dessin **C**
38 38
         * Trait **C**
@@ -48,7 +48,6 @@
48 48
         * Binaire **C**
49 49
         * Niveaux de gris **C**
50 50
         * Couleur **C**
51
-    * Aide
52 51
 * Documentation
53 52
 
54 53
 

+ 19
- 9
src/affichageFenetre.cpp View File

@@ -3,6 +3,8 @@
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
+int ecranX = 1024;
7
+int ecranY = 1080;
6 8
 bool fenetreOuverte = false;
7 9
 SDL_Surface *fenetreEcran;
8 10
 SDL_Surface *fenetreImage;
@@ -11,16 +13,16 @@ SDL_Surface *fenetreImage;
11 13
 void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel) {
12 14
     int nbOctetsParPixel = surface->format->BytesPerPixel;
13 15
     Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;
14
-
16
+    
15 17
     switch (nbOctetsParPixel) {
16 18
     case 1:
17 19
         *p = pixel;
18 20
         break;
19
-
21
+        
20 22
     case 2:
21 23
         *(Uint16 *)p = pixel;
22 24
         break;
23
-
25
+        
24 26
     case 3:
25 27
         if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
26 28
             p[0] = (pixel >> 16) & 0xff;
@@ -31,16 +33,16 @@ void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel) {
31 33
             p[1] = (pixel >> 8) & 0xff;
32 34
             p[2] = (pixel >> 16) & 0xff;
33 35
         }
34
-
36
+        
35 37
         break;
36
-
38
+        
37 39
     case 4:
38 40
         *(Uint32 *)p = pixel;
39 41
         break;
40 42
     }
41 43
 }
42 44
 
43
-void setNomFenetre(std::string nom) { // Change le nom de la fenêtre
45
+void s_nomFenetre(std::string nom) { // Change le nom de la fenêtre
44 46
     SDL_WM_SetCaption(nom.c_str(), NULL);
45 47
 }
46 48
 
@@ -68,7 +70,7 @@ void afficherFenetre() {
68 70
 
69 71
 void attendreFenetre() {
70 72
     SDL_Event evenement;
71
-
73
+    
72 74
     do {
73 75
         SDL_WaitEvent(&evenement);
74 76
     } while (evenement.type != SDL_QUIT &&
@@ -93,7 +95,15 @@ void ouvrirFenetre(int dimensionX, int dimensionY,
93 95
     fenetreImage = SDL_CreateRGBSurface(SDL_HWSURFACE, fenetreDimensionX,
94 96
                                         fenetreDimensionY, 32, 0, 0, 0, 0);
95 97
     SDL_FillRect(fenetreImage, NULL, SDL_MapRGB(fenetreEcran->format, 0, 0, 0));
96
-    setNomFenetre(nom);
98
+    s_nomFenetre(nom);
97 99
     SDL_LockSurface(fenetreImage);
98 100
     fenetreOuverte = true;
99
-}
101
+}
102
+
103
+void actualiserDimensionsEcran() {
104
+    SDL_Init(SDL_INIT_VIDEO);
105
+    const SDL_VideoInfo *info = SDL_GetVideoInfo();
106
+    ecranX = info->current_w;
107
+    ecranY = info->current_h;
108
+    SDL_Quit();
109
+}

+ 41
- 24
src/analyserCommande.cpp View File

@@ -316,30 +316,43 @@ int executerCommande(Commande commande, Image &image) {
316 316
         //     } else {
317 317
         //         return 2;
318 318
         //     }
319
-        // } else if (commande.fonction == "teinte") {
320
-        //     if (argumentPresent(commande, "v1")) {
321
-        //         if (teinte(image, image, commande.v1)) {
322
-        //             return 3;
323
-        //         }
324
-        //     } else {
325
-        //         return 2;
326
-        //     }
327
-        // } else if (commande.fonction == "saturation") {
328
-        //     if (argumentPresent(commande, "v1")) {
329
-        //         if (saturation(image, image, commande.v1)) {
330
-        //             return 3;
331
-        //         }
332
-        //     } else {
333
-        //         return 2;
334
-        //     }
335
-        // } else if (commande.fonction == "luminosite") {
336
-        //     if (argumentPresent(commande, "v1")) {
337
-        //         if (luminosite(image, image, commande.v1)) {
338
-        //             return 3;
339
-        //         }
340
-        //     } else {
341
-        //         return 2;
342
-        //     }
319
+    } else if (commande.fonction == "teinte") {
320
+        if (image.g_typeComposantes() == PILG_RVB) {
321
+            if (argumentPresent(commande, "v1")) {
322
+                if (teinte(image, image, commande.v1)) {
323
+                    return 3;
324
+                }
325
+            } else {
326
+                return 2;
327
+            }
328
+        } else {
329
+            return 11;
330
+        }
331
+    } else if (commande.fonction == "saturation") {
332
+        if (image.g_typeComposantes() == PILG_RVB) {
333
+            if (argumentPresent(commande, "v1")) {
334
+                if (saturation(image, image, commande.v1)) {
335
+                    return 3;
336
+                }
337
+            } else {
338
+                return 2;
339
+            }
340
+        } else {
341
+            return 11;
342
+        }
343
+    } else if (commande.fonction == "luminosite") {
344
+        if (image.g_typeComposantes() == PILG_RVB) {
345
+            if (argumentPresent(commande, "v1")) {
346
+                if (luminosite(image, image, commande.v1)) {
347
+                    return 3;
348
+                }
349
+            } else {
350
+                return 2;
351
+            }
352
+        } else {
353
+            return 11;
354
+        }
355
+        
343 356
         // } else if (commande.fonction == "contraste") {
344 357
         //     if (argumentPresent(commande, "v1")) {
345 358
         //         if (contraste(image, image, commande.v1)) {
@@ -524,6 +537,10 @@ int procederCommande(vector< string > decoupe, Image &image) {
524 537
         messageErreur("La composante donnée n'est pas valide");
525 538
         break;
526 539
         
540
+    case 11:
541
+        messageErreur("Il est nécessaire d'avoir une image en mode RVB pour executer cette commande");
542
+        break;
543
+        
527 544
     default:
528 545
         messageErreur("Impossible d'analyser la commande");
529 546
         break;

+ 2
- 2
src/image.h View File

@@ -2,7 +2,7 @@
2 2
 
3 3
 typedef enum {PILG_BIN, PILG_NIV, PILG_RVB} PILG_Comp;
4 4
 
5
-typedef struct Pixel {
5
+typedef struct {
6 6
     PILG_Comp typeComposantes;
7 7
     int maxComposante;
8 8
     int r;
@@ -30,7 +30,7 @@ public:
30 30
     // Validateurs
31 31
     bool v_pixel(Pixel pixel) const;
32 32
     bool v_dimensions(int x, int y) const;
33
-
33
+    
34 34
 private:
35 35
     // Variables
36 36
     int m_dimensionX;

+ 1
- 0
src/main.cpp View File

@@ -27,6 +27,7 @@ int main(int argc, char *args[]) {
27 27
         
28 28
         code = procederCommande(decoupe, image);
29 29
     } else {
30
+        actualiserDimensionsEcran();
30 31
         afficherImage(image);
31 32
         boucleDeCommandes(image);
32 33
         code = 0;

+ 33
- 12
src/testing.cpp View File

@@ -120,6 +120,9 @@ int appliquer(Image &image, string nomFichier, bool ASCII) {
120 120
     ouvrir(image, "tests/" + nomFichier);
121 121
     Pixel pixel;
122 122
     image.g_pixel(image.g_dimensionX() / 2, image.g_dimensionY() / 2, pixel);
123
+    // teinte(image, image, 180);
124
+    // saturation(image, image, 0.3);
125
+    // luminosite(image, image, -0.5);
123 126
     // trait(image, image, image.g_dimensionX() / 4, image.g_dimensionY() / 4,
124 127
     //       image.g_dimensionX() - image.g_dimensionX() / 4,
125 128
     //       image.g_dimensionY() - image.g_dimensionY() / 4, pixel);
@@ -147,25 +150,43 @@ int main(int argc, char *args[]) {
147 150
     #endif
148 151
     presentation();
149 152
     cout << "Éxecution des instructions dans testing.cpp." << endl << endl;
150
-#define DIMENSIONS 50
151
-    Image image1 = genererRoue(DIMENSIONS * 2, DIMENSIONS, 255);
152
-    Image image2 = genererRoue(DIMENSIONS * 2, DIMENSIONS, 255);
153
-    // Image image1; // Tester si ça marche
153
+    actualiserDimensionsEcran();
154
+#define DIMENSIONS 255
155
+    // Image image1 = genererRoue(DIMENSIONS, DIMENSIONS, 255);
156
+    Image image1 = imageDefaut();
157
+    // Image image = image1.g_vide();
158
+    // ouvrir(image1, "tests/PikachuP6.ppm");
159
+    // Image image2 = genererRoue(DIMENSIONS * 2, DIMENSIONS, 255);
154 160
     // afficherImage(image1);
155 161
     // attendreFenetre();
162
+    // Ouvrir fichier
163
+    // appliquer(image1, "PikachuP1.pbm", true);
164
+    // appliquer(image1, "PikachuP2.pgm", true);
165
+    // appliquer(image1, "PikachuP3.ppm", true);
166
+    // appliquer(image1, "PikachuP4.pbm", false);
167
+    // appliquer(image1, "PikachuP5.pgm", false);
168
+    // appliquer(image1, "PikachuP6.ppm", false);
169
+    // // Chronomètre
170
+    // int tempsDepart = clock();
171
+    // journal << "Temps d'execution: " << (float)(clock() - tempsDepart) / 1000000 <<
172
+    //         "s" << endl;
173
+    // // Afficher différentes tailles de fenêtre
174
+    // for (int i = 500; i < 1200; i += 10) {
175
+    //     image1 = genererRoue(i * 2, i, 255);
176
+    //     afficherImage(image1);
177
+    //     // attendreFenetre();
178
+    // }
156 179
     // // Roue
157 180
     // Image image = image1.g_vide();
158 181
     // for (float i = 0; i < 2 * PI; i += 0.1) {
159 182
     //     pivoter(image1, image, DIMENSIONS/2, DIMENSIONS/2, i);
160 183
     //     afficherImage(image);
161 184
     // }
162
-    // Ouvrir fichier
163
-    appliquer(image1, "PikachuP1.pbm", true);
164
-    appliquer(image1, "PikachuP2.pgm", true);
165
-    appliquer(image1, "PikachuP3.ppm", true);
166
-    appliquer(image1, "PikachuP4.pbm", false);
167
-    appliquer(image1, "PikachuP5.pgm", false);
168
-    appliquer(image1, "PikachuP6.ppm", false);
185
+    // // Roue des couleurs
186
+    // for (float i = -1; i <= 1; i += 0.01) {
187
+    //     teinte(image1, image, i);
188
+    //     afficherImage(image);
189
+    // }
169 190
     // // Neige en dégradé
170 191
     // for (int i; i < 300; i++) {
171 192
     //     afficherImage(genererBruit(200, 200));
@@ -202,7 +223,7 @@ int main(int argc, char *args[]) {
202 223
     //     afficherFenetre();
203 224
     // }
204 225
     // cout << "Éxecution du programme terminée. Vous pouvez quitter la fenêtre." << endl;
205
-    fermerFenetre();
226
+    // fermerFenetre();
206 227
     journal.close();
207 228
     return 0;
208 229
 }

+ 47
- 12
src/traitementImage.cpp View File

@@ -369,28 +369,63 @@ int importer(Image entree, Image &sortie, string nomFichier, int x, int y) {
369 369
 
370 370
 // Couleur
371 371
 
372
-
373 372
 int teinte(Image entree, Image &sortie,
374 373
            float teinte) {   // Change la teinte de l'image
375
-    // for (int x = 0, x = image.g_dimensionX(), x++) {
376
-    //     for (int y = 0, y = image.g_dimensionY(), y++) {
377
-    //         rvbVersTsl();
378
-    //         g_pixel(x, y);
379
-    //     }
380
-    // }
381
-    // return 1;
374
+    sortie = entree.g_vide();
375
+    Pixel pixel;
376
+    TSL tsl;
377
+    
378
+    for (int x = 0; x < sortie.g_dimensionX(); x++) {
379
+        for (int y = 0; y < sortie.g_dimensionY(); y++) {
380
+            entree.g_pixel(x, y, pixel);
381
+            rvb2tsl(pixel, tsl);
382
+            tsl.t += teinte;
383
+            tsl2rvb(tsl, pixel);
384
+            sortie.s_pixel(x, y, pixel);
385
+        }
386
+    }
387
+    
388
+    return 0;
382 389
 }
383 390
 
384 391
 int saturation(Image entree, Image &sortie,
385 392
                float saturation) {   // Sature l'image
386
-    // Utilisation de la méthode TSL
387
-    return 1;
393
+    sortie = entree.g_vide();
394
+    Pixel pixel;
395
+    TSL tsl;
396
+    
397
+    for (int x = 0; x < sortie.g_dimensionX(); x++) {
398
+        for (int y = 0; y < sortie.g_dimensionY(); y++) {
399
+            entree.g_pixel(x, y, pixel);
400
+            rvb2tsl(pixel, tsl);
401
+            tsl.s += saturation;
402
+            tsl.s = tsl.s > 1 ? 1 : (tsl.s < 0 ? 0 : tsl.s);
403
+            tsl2rvb(tsl, pixel);
404
+            sortie.s_pixel(x, y, pixel);
405
+        }
406
+    }
407
+    
408
+    return 0;
388 409
 }
389 410
 
390 411
 int luminosite(Image entree, Image &sortie,
391 412
                float luminosite) {   // Augmente la luminosité de l'image
392
-    // Utilisation de la méthode TSL
393
-    return 1;
413
+    sortie = entree.g_vide();
414
+    Pixel pixel;
415
+    TSL tsl;
416
+    
417
+    for (int x = 0; x < sortie.g_dimensionX(); x++) {
418
+        for (int y = 0; y < sortie.g_dimensionY(); y++) {
419
+            entree.g_pixel(x, y, pixel);
420
+            rvb2tsl(pixel, tsl);
421
+            tsl.l += luminosite;
422
+            tsl.l = tsl.l > 1 ? 1 : (tsl.l < 0 ? 0 : tsl.l);
423
+            tsl2rvb(tsl, pixel);
424
+            sortie.s_pixel(x, y, pixel);
425
+        }
426
+    }
427
+    
428
+    return 0;
394 429
 }
395 430
 
396 431
 int contraste(Image entree, Image &sortie,

+ 117
- 58
src/utilitaires.cpp View File

@@ -13,64 +13,112 @@ void presentation() {
13 13
          << "|_|    |___| |_____| \\____|" << endl;
14 14
 }
15 15
 
16
+typedef struct {
17
+    double t;
18
+    double s;
19
+    double l;
20
+} TSL;
21
+
22
+int rvb2tsl(Pixel entree, TSL &sortie) {
23
+    double min, max, r = (float) entree.r / entree.maxComposante,
24
+                     v = (float) entree.v / entree.maxComposante,
25
+                     b = (float) entree.b / entree.maxComposante;
26
+    min = r < v ? r : v;
27
+    min = min  < b ? min : b;
28
+    max = r > v ? r : v;
29
+    max = max  > b ? max : b;
30
+    sortie.l = (max + min) / 2;
31
+    
32
+    if (max == min) {
33
+        sortie.s = 0;
34
+        sortie.t = NAN;
35
+    } else {
36
+        sortie.s = sortie.l < 0.5 ? (max - min) / (max + min) : (max - min) /
37
+                   (2 - max - min);
38
+    }
39
+    
40
+    if (r == max) {
41
+        sortie.t = (v - b) / (max - min);
42
+    } else if (v == max) {
43
+        sortie.t = 2 + (b - r) / (max - min);
44
+    } else if (b == max) {
45
+        sortie.t = 4 + (r - v) / (max - min);
46
+    }
47
+    
48
+    sortie.t *= 60;
49
+    
50
+    if (sortie.t < 0) {
51
+        sortie.t += 360;
52
+    }
53
+    
54
+    return 0;
55
+}
56
+
57
+int tsl2rvb(TSL entree, Pixel &sortie) {
58
+    double t3[3], c[3], t2, t1;
59
+    
60
+    while (entree.t < 0.0) {
61
+        entree.t += 360.0;
62
+    }
63
+    
64
+    while (entree.t > 360.0) {
65
+        entree.t += -360.0;
66
+    }
67
+    
68
+    if (entree.s == 0) {
69
+        fill_n(c, 3, entree.l * 255);
70
+    } else {
71
+        fill_n(t3, 3, 0);
72
+        fill_n(c, 3, 0);
73
+        t2 = entree.l < 0.5 ? entree.l * (1 + entree.s) : entree.l + entree.s - entree.l
74
+             * entree.s;
75
+        t1 = 2 * entree.l - t2;
76
+        entree.t /= 360;
77
+        t3[0] = entree.t + 1 / 3.0;
78
+        t3[1] = entree.t;
79
+        t3[2] = entree.t - 1 / 3.0;
80
+        
81
+        for (int i = 0; i <= 2; i++) {
82
+            if (t3[i] < 0) {
83
+                t3[i] += 1;
84
+            }
85
+            
86
+            if (t3[i] > 1) {
87
+                t3[i] -= 1;
88
+            }
89
+            
90
+            if (6 * t3[i] < 1) {
91
+                c[i] = t1 + (t2 - t1) * 6 * t3[i];
92
+            } else if (2 * t3[i] < 1) {
93
+                c[i] = t2;
94
+            } else if (3 * t3[i] < 2) {
95
+                c[i] = t1 + (t2 - t1) * ((2 / 3.0) - t3[i]) * 6;
96
+            } else {
97
+                c[i] = t1;
98
+            }
99
+        }
100
+        
101
+        sortie.r = c[0] * sortie.maxComposante;
102
+        sortie.v = c[1] * sortie.maxComposante;
103
+        sortie.b = c[2] * sortie.maxComposante;
104
+    }
105
+    
106
+    return 0;
107
+}
108
+
16 109
 Image imageDefaut() {
17 110
     int dimY = 256, dimX = dimY * NOMBREOR, maxComposante = 255;
18 111
     Image imageRoue(dimX, dimY, maxComposante, PILG_RVB);
112
+    int x, y;
113
+    TSL tsl;
19 114
     Pixel pointRoue = imageRoue.g_pixelVide();
20
-    int x, y, step;
21
-    float substep, lum;
115
+    tsl.s = 1;
22 116
     
23 117
     for (x = 0; x < dimX; x++) {
24 118
         for (y = 0; y < dimY; y++) {
25
-            step = (x * 6.0) / dimX;
26
-            substep = (x - step * (dimX / 6.0)) / (dimX / 6.0) * maxComposante;
27
-            lum = 1 - ((float) y) / dimY;
28
-            
29
-            switch (step) {
30
-            case 0:
31
-                pointRoue.r = maxComposante;
32
-                pointRoue.v = substep;
33
-                pointRoue.b = 0;
34
-                break;
35
-                
36
-            case 1:
37
-                pointRoue.r = maxComposante - substep;
38
-                pointRoue.v = maxComposante;
39
-                pointRoue.b = 0;
40
-                break;
41
-                
42
-            case 2:
43
-                pointRoue.r = 0;
44
-                pointRoue.v = maxComposante;
45
-                pointRoue.b = substep;
46
-                break;
47
-                
48
-            case 3:
49
-                pointRoue.r = 0;
50
-                pointRoue.v = maxComposante - substep;
51
-                pointRoue.b = maxComposante;
52
-                break;
53
-                
54
-            case 4:
55
-                pointRoue.r = substep;
56
-                pointRoue.v = 0;
57
-                pointRoue.b = maxComposante;
58
-                break;
59
-                
60
-            case 5:
61
-                pointRoue.r = maxComposante;
62
-                pointRoue.v = 0;
63
-                pointRoue.b = maxComposante - substep;
64
-                break;
65
-                
66
-            default:
67
-                pointRoue.r = pointRoue.v = pointRoue.b = 0;
68
-            }
69
-            
70
-            // Dégradé vers le noir
71
-            pointRoue.r = pointRoue.r * lum;
72
-            pointRoue.v = pointRoue.v * lum;
73
-            pointRoue.b = pointRoue.b * lum;
119
+            tsl.t = ((float) x / dimX) * 360;
120
+            tsl.l = 1 - ((float) y / dimY);
121
+            tsl2rvb(tsl, pointRoue);
74 122
             imageRoue.s_pixel(x, y, pointRoue);
75 123
         }
76 124
     }
@@ -79,12 +127,23 @@ Image imageDefaut() {
79 127
 }
80 128
 
81 129
 void afficherImage(Image image) {
82
-#define ECHELLE 1
83
-    int x, y, r, v, b, eX, eY, dimensionX = image.g_dimensionX() * ECHELLE,
84
-                               dimensionY = image.g_dimensionY() * ECHELLE,
85
-                               typeComposantes = image.g_typeComposantes();
130
+#define MARGE 100
131
+    int x, y, r, v, b, eX, eY, echelle, contenableX, contenableY,
132
+        dimensionX = image.g_dimensionX(),
133
+        dimensionY = image.g_dimensionY(),
134
+        typeComposantes = image.g_typeComposantes();
86 135
     float ratio = (255.0 / image.g_maxComposante());
87 136
     Pixel pixel;
137
+    // Calcul de l'échelle
138
+    contenableX = (ecranX - MARGE) / dimensionX;
139
+    contenableY = (ecranY - MARGE) / dimensionY;
140
+    echelle = (contenableX > contenableY ? contenableY : contenableX);
141
+    echelle = (echelle > 0 ? echelle : 1);
142
+    dimensionX = dimensionX * echelle;
143
+    dimensionY = dimensionY * echelle;
144
+    // journal << "Fenêtre: Image(" << image.g_dimensionX() << ";" <<
145
+    // image.g_dimensionY() << "), Echelle(" << echelle << "), Fenetre(" <<
146
+    // dimensionX << ";" << dimensionY << ")" << endl;
88 147
     
89 148
     if (fenetreOuverte && (dimensionX != fenetreDimensionX ||
90 149
                            dimensionY != fenetreDimensionY)) {
@@ -113,9 +172,9 @@ void afficherImage(Image image) {
113 172
                 break;
114 173
             }
115 174
             
116
-            for (eX = 0; eX < ECHELLE; eX++) {
117
-                for (eY = 0; eY < ECHELLE; eY++) {
118
-                    pointFenetre(x * ECHELLE + eX, y * ECHELLE + eY, r, v, b);
175
+            for (eX = 0; eX < echelle; eX++) {
176
+                for (eY = 0; eY < echelle; eY++) {
177
+                    pointFenetre(x * echelle + eX, y * echelle + eY, r, v, b);
119 178
                 }
120 179
             }
121 180
         }