Erreur dans for

Version imprimable

Erreur dans for

Bonjour,

J'ai un problème avec tous mes 'for' !

Ce que me retourne Dev C++

http://images0.hiboox.com/vignettes/2008/4im1qmks.jpg

voici le code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL/SDL.h>
#include <windows.h>
 
void pause();
 
int main (int argc, char *argv[])
{
 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                   SDL                                                           //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    SDL_Surface *ecran = NULL; 
 
 
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE); 
    if (ecran == NULL) 
    {
        fprintf(stderr, "Impossible de charger le mode vidéo : %s\nq", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    SDL_WM_SetCaption("PROJET SDL", NULL);
 
    pause();
 
    SDL_Quit();
 
    return EXIT_SUCCESS;
}
 
 
 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                      GENERATION D'UN TABLEAU DE VALEURS POUR E                                  //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int i, j;
    float E[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
              for ( j=0 ; j<=480 ; j++ )
                  {
                        E[i][j]=(1000/(i*j+1));
                  }
        }
 
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                 NORMALISATION DU CHAMPS                                           //
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int k, l;
    float E_NORM[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
              for ( j=0 ; j<=480 ; j++ )
                  {
                        E_NORM[i][j]=E[i][j]/E[0][0];
                  }
        }
 
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                ASSOCIATION DES COULEURS                                           //
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int m, n;
    float intervalle0=0;
    float intervalle1=0.01;
    int pas=0;
    Uint32 couleur[641][481];
 
    for ( m=0 ; m <= 640 ; m++ )
		     {
                  for ( n=0 ; n <= 480 ; n++ )
		      	      {
                                   while ( intervalle1 <= 2 )
                                    	  {
                                                      if  (   ( E[m][n] >= -1 + intervalle0 )&&( E[m][n] >= -1 + intervalle1 )   )
                                                          {
                                                              couleur[m][n]= SDL_MapRGB (  ecran -> format, pas, pas, pas);
                                                          }
 
                                                    else  {  intervalle0 = intervalle0 +0.01 ; intervalle1 = intervalle +0.01 ; pas++; }
                                          }
                       }
 
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                                  AFFICHAGE DU CHAMP                                              //
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     int o, p;
     SDL_Rect position;
     SDL_Surface *pixel[641][481]=NULL;
 
     for ( o=0 ; o <= 640 ; o++ )
		     {
                 for ( p=0 ; p <= 480 ; p++ )
          		     {
                           position.x=o;
                           position.y=p;
                           SDL_FillRect   ( pixel[o][p] , NULL, Couleur[o][p]            );
				           SDL_BlitSurface( pixel[o][p] , NULL, ecran        , &position );                                                      //position à définir
			         }
 
     SDL_Flip(ecran);
 
 
 
 
 
}
 
 
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}

Cordialement

Gao,

Citation:

Envoyé par darkwall_37

Code:

1
2
3
4
5
6
7
8
9
...
/* à partir d'ici, le code n'est pas dans une fonction,
    je n'ai pas lu plus loin */
    int i, j;
    float E[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
...

Ah oui merci ! et dans la hate j'avais oublier certain truks ^^

Maintenant y'a plus d'erreur de compilation, mais j'ai du faire des sottises une fois de plus avec les pointeurs, encore un problème de mémoire je suppose.

Voici le nouveau code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL/SDL.h>
#include <windows.h>
 
void pause();
 
int main (int argc, char *argv[])
{
 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                   SDL                                                           //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    SDL_Surface *ecran = NULL; 
 
 
    SDL_Init(SDL_INIT_VIDEO);
 
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE); 
    if (ecran == NULL) 
    {
        fprintf(stderr, "Impossible de charger le mode vidéo : %s\nq", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    SDL_WM_SetCaption("PROJET SDL", NULL);
 
 
 
 
 
 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                      GENERATION D'UN TABLEAU DE VALEURS POUR E                                  //
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int i, j;
    float E[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
              for ( j=0 ; j<=480 ; j++ )
                  {
                        E[i][j]=(1000/(i*j+1));
                  }
        }
 
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                 NORMALISATION DU CHAMPS                                           //
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int k, l;
    float E_NORM[641][481];
 
    for ( i=0 ; i<=640 ; i++ )
        {
              for ( j=0 ; j<=480 ; j++ )
                  {
                        E_NORM[i][j]=E[i][j]/E[0][0]; //E[0][0] étant la valeur max du tableau 
                  }
        }
 
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //                                                ASSOCIATION DES COULEURS                                           //
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
    int m, n;
    float intervalle0=0;
    float intervalle1=0.01;
    int pas=0;
    Uint32 couleur[641][481];
 
    for ( m=0 ; m <= 640 ; m++ )
		     {
                  for ( n=0 ; n <= 480 ; n++ )
		      	      {
                                   while ( intervalle1 <= 2 )
                                    	  {
                                                      if  (   ( E_NORM[m][n] >= -1 + intervalle0 )&&( E_NORM[m][n] >= -1 + intervalle1 )   )
                                                          {
                                                              couleur[m][n]= SDL_MapRGB (  ecran -> format, pas, pas, pas);
                                                          }
 
                                                    else  {  intervalle0 = intervalle0 +0.01 ; intervalle1 = intervalle1 +0.01 ; pas++; }
                                          }
                       }
             }
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                                  AFFICHAGE DU CHAMP                                              //
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     int o, p, s, t;
     SDL_Rect position;
     SDL_Surface *pixel[641][481]={NULL};
 
 
     for ( s=0 ; s <= 640 ; s++ )
		     {
                 for ( t=0 ; t <= 480 ; t++ )
          		     {
                           pixel[s][t]=SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);                                                 //position à définir
			         }
             }
 
 
     for ( o=0 ; o <= 640 ; o++ )
		     {
                 for ( p=0 ; p <= 480 ; p++ )
          		     {
                           position.x=o;
                           position.y=p;
                           SDL_FillRect   ( pixel[o][p] , NULL, couleur[o][p]            );
				           SDL_BlitSurface( pixel[o][p] , NULL, ecran        , &position );                                                      //position à définir
			         }
             }
 
     SDL_Flip(ecran);
 
 
     pause();
 
     int q, r;
 
     for ( q=0 ; q <= 641 ; q++ )
         {
               for ( r=0 ; r <= 481 ; r++ )
                   {
                         SDL_FreeSurface(pixel[q][r]);
                   }
         }
 
     SDL_FreeSurface(ecran);
 
     SDL_Quit();
 
     return EXIT_SUCCESS;   
 
 
}
 
 
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}

Merci d'avance

17/05/2008, 17h33
droggo

Jai,

Il serait agréable pour nous que tu fasses un effort pour nous dire quel est le problème. :)
17/05/2008, 18h01
darkwall_37

Je ne peux rien ajouter de plus si cela n'est que j'e n'ai pas d'erreur à la compilation et que lorsque le programme se lance il plante et la fenêtre d'erreur de windows apparait avec 'envoyer' ou 'ne pas envoyer' !
Je suis désolé Dev C++ ne me dit rien de plus !
17/05/2008, 18h29
souviron34

je répète encore une fois, meilleure méthode de débuggage dans ce cas-là :

mettre en commentaires des blocs les uns après les autres, et voir lequel fait planter.

Puis investiger pourquoi..

Sinon se servir d'un vrai debugger, et quand ça crashe, remonter à l'origine...
18/05/2008, 17h29
diogene

Ca fait 4 tableaux locaux à main de 641x481 objets faisant (typiquement) 4 bytes, soit près de 5Mbytes. C'est beaucoup et on risque (ou on a) un débordement de pile.
19/05/2008, 12h26
darkwall_37

Merci, je sais d'où sa vient maintenant ! Que puis-je faire pour palier ce problème ?

Cordialement
19/05/2008, 14h26
diogene

Tu peux créer tes tableaux sur le tas au lieu de la pile en utilisant malloc/free.
Il y a beaucoup plus de place sur le tas (la mémoire disponible).

Comme, apparemment, plusieurs de ces tableaux sont temporaires, tu peux les détruire dès qu'ils sont devenus inutiles et récupérer la mémoire pour la suite.
19/05/2008, 16h10
darkwall_37

Ah ok merci, je ne savais pas cette différence entre la pile est le malloc concernant la mémoire !

Merci, je vais voir ça !

Bonjour,

J'ai enfin trouvé d'où venait le problème ! Il vient de la boucle qui me permet de faire les couleurs, en effet quand je l'a met en commentaire et que j'associe les couleurs au pif ça marche ! Mais je ne vois ce qui ne vas pas dans ma boucle !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
//#include "mylib.h"
 
 
 
void pause();
//void create_RPC(int X, int Y, int r, int g, int b, SDL_Surface *ecran, SDL_Surface *surface);
 
 
 
int main(int argc, char *argv[])
 
{
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//                         MISE EN MEMOIRE DES SURFACES ALLOUEES POUR DES SURFACES                      //
//////////////////////////////////////////////////////////////////////////////////////////////////////////
 
SDL_Init(SDL_INIT_VIDEO); // Chargement de la vidéo
 
SDL_Surface *ecran=SDL_SetVideoMode(300, 300, 32, SDL_HWSURFACE); // On met en mémoire dans la variable ecran la surface pour la fenêtre principale 
 
//SDL_Surface *rectangle=SDL_CreateRGBSurface(SDL_SWSURFACE, 100, 100, 32,0, 0, 0, 0);
 
SDL_Surface *pixel[300][300]={NULL}; // On met en mémoire dans le tableau à deux dimensions les (X-1)*(Y-1) pixels nécessaires pour recouvrir la surface totale de la fenêtre principale
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//                           MISE EN MEMOIRE DES SURFACES ALLOUEES POUR LES PIXELS                      //
//////////////////////////////////////////////////////////////////////////////////////////////////////////
 
int i,j;
 
     for ( i=0 ; i<=299 ; i++ )
         {
               for ( j=0 ; j<=299 ; j++ )
                   {
                        pixel[i][j]=SDL_CreateRGBSurface(SDL_SWSURFACE, 1, 1, 32,0, 0, 0, 0); // Boucle permettant de créer les (X-1)*(Y-1) pixels en tant que surface rectangulaire de 1*1
                   }
         }
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                    SIMULATION D'UN CHAMPS ELECTRIQUE                                 //
//////////////////////////////////////////////////////////////////////////////////////////////////////////
 
int m,n,o,p;
float E[300][300];
float E_NORM[300][300];
 
     for ( m=0 ; m<=299 ; m++ )
         {
               for ( n=0 ; n<=299 ; n++ )
                   {
                        E[m][n]=m*m/(n*n+1); 
 
                   }
         }
 
     for ( o=0 ; o<=299 ; o++ )
         {
               for ( p=0 ; p<=299 ; p++ )
                   {
                        E_NORM[o][p]= ( E[o][p]/(2*E[299][299]) + 0.5 ); // Normalisation de E sur un intervalle de 0 à 1
                   }
         }
 
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                          ASSOCIATION DES COULEURS                                    //
//////////////////////////////////////////////////////////////////////////////////////////////////////////
 
//int a,b;
//int c=0;
Uint32 couleur[300][300];
//float pas=1/255;
//float intervalle0=0;
//float intervalle1=pas;
//
//for ( a=0 ; a <= 299 ; a++ )
//    {
//			 for ( b=0 ; b <= 299 ; b++ )
//                 {
//				
//                 while ( intervalle1 <= 1 )
//                       {
//                                    
//					   if  (   ( E_NORM[a][b] >= intervalle0 )&&( E_NORM[a][b] <= intervalle1 ) ) // On test les valeur de E_NORM à des intervalles prédéfinis (0 à 1/255) pour lui associer une couleur 
//
//		               	   {
//						       couleur[a][b]= SDL_MapRGB (  ecran -> format, 1, 5, 65 );  // Si E_NORM appartient à l'intervalle, on lui associe un code couleur
//						       
//				    	   }
//
//			      	else   {  
//                               pas=(pas+1/255);
//                               intervalle0 = (intervalle0 + pas ); // Si E_NORM n'appartient pas à l'intervalle, on incrémente les bornes de l'intervalle et le pas
//                               intervalle1 = (intervalle1 + pas );  
//                           }
//
//		     	       }
//                  }
//     }
 
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                            AFFICHAGE DES PIXELS                                      //
//////////////////////////////////////////////////////////////////////////////////////////////////////////
 
int d,e;
SDL_Rect position;
 
for ( d=0 ; d <= 299 ; d++ )
    {
			for ( e=0 ; e <= 299 ; e++ )
                {
				    couleur[d][e]= SDL_MapRGB (  ecran -> format, (int)(E[d][e]*10), 1, 1 );
                    position.x=d;
				    position.y=e;
                    SDL_FillRect( pixel[d][e] , NULL, couleur[d][e] );
			    	SDL_BlitSurface( pixel[d][e] , NULL, ecran, &position);                                                     
			    }
    }
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
//create_RPC(50, 50 , 128, 128, 128, ecran, rectangle);
 
SDL_Flip(ecran);
 
pause(); 
 
SDL_Quit(); 
 
return EXIT_SUCCESS; 
 
}
 
void pause()
{
 
int continuer = 1;
SDL_Event event;
 
          while (continuer)
                {
                           SDL_WaitEvent(&event);
                           switch(event.type)
                           {
                                             case SDL_QUIT:
                                             continuer = 0;
                           }
                }
}

Merci d'avance

21/05/2008, 22h36
souviron34

ton pas augmente en progression geometrique

1/255 + (1/255 + ( 1/255 +...))

je crois que ce que tu veux faire est SANS incrementer pas, juste intervalle0 et intervalle1

Citation:

Envoyé par darkwall_37

Code:

1
2
3
4
         float E[641][481];
         float E_NORM[641][481];
         Uint32 couleur[641][481];
         SDL_Surface *pixel[641][481] = { {NULL} };

Trop de données en mémoire automatique.
Quick and dirty hack :

Code:

1
2
3
4
         static float E[641][481];
         static float E_NORM[641][481];
         static Uint32 couleur[641][481];
         static SDL_Surface *pixel[641][481] = { {NULL} };

Je ne sais pas où tu en es du C, mais tu devrais utiliser un tableau de structure plutôt de 4 tableaux de même dimensions et tailles...

Ensuite, les gros objets, en principe on les allouent dynamiquement mais le 'static' est OK dans un main()...

Ceci commence à fonctionner. Bien lire mon commentaire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL/SDL.h>
#include <windows.h>
 
void pause (void)
{
   int continuer = 1;
 
   while (continuer)
   {
      SDL_Event event;
      SDL_WaitEvent (&event);
      switch (event.type)
      {
      case SDL_QUIT:
         continuer = 0;
      }
   }
}
 
int main (int argc, char *argv[])
{
/* SDL */
 
 
   SDL_Init (SDL_INIT_VIDEO);
   {
      SDL_Surface *ecran = SDL_SetVideoMode (640, 480, 32, SDL_HWSURFACE);
      if (ecran == NULL)
      {
         fprintf (stderr, "Impossible de charger le mode vidéo : %s\nq",
                  SDL_GetError ());
         exit (EXIT_FAILURE);
      }
      else
      {
         static float E[641][481];
         static float E_NORM[641][481];
         static Uint32 couleur[641][481];
         static SDL_Surface *pixel[641][481] = { {NULL} };
 
         SDL_WM_SetCaption ("PROJET SDL", NULL);
 
/* GENERATION D'UN TABLEAU DE VALEURS POUR E */
         {
            int i, j;
 
            for (i = 0; i <= 640; i++)
            {
               for (j = 0; j <= 480; j++)
               {
                  E[i][j] = (1000 / (i * j + 1));
               }
            }
         }
 
/* NORMALISATION DU CHAMP */
         {
            int i;
 
            for (i = 0; i <= 640; i++)
            {
               int j;
               for (j = 0; j <= 480; j++)
               {
/* E[0][0] étant la valeur max du tableau */
                  E_NORM[i][j] = E[i][j] / E[0][0];
               }
            }
         }
 
/* ASSOCIATION DES COULEURS */
         {
            int m, n;
            float intervalle0 = 0;
            float intervalle1 = 0.01;
            int pas = 0;
 
            for (m = 0; m <= 640; m++)
            {
               for (n = 0; n <= 480; n++)
               {
#if 0
/* -ed- j'ai isolé cette boucle. On en sort jamais...
        Je ne sais pas ce que tu cherches à faire,
        mais ça ne fonctionne pas...
*/
                  while (intervalle1 <= 2)
                  {
                     if ((E_NORM[m][n] >= -1 + intervalle0)
                         && (E_NORM[m][n] >= -1 + intervalle1))
                     {
                        couleur[m][n] =
                           SDL_MapRGB (ecran->format, pas, pas, pas);
                     }
                     else
                     {
                        intervalle0 = intervalle0 + 0.01;
                        intervalle1 = intervalle1 + 0.01;
                        pas++;
                     }
                  }
#endif
               }
            }
         }
 
/* AFFICHAGE DU CHAMP */
 
         {
            int o, p, s, t;
            SDL_Rect position;
 
            for (s = 0; s <= 640; s++)
            {
               for (t = 0; t <= 480; t++)
               {
/* position à définir */
                  pixel[s][t] = SDL_CreateRGBSurface (SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
               }
            }
 
            for (o = 0; o <= 640; o++)
            {
               for (p = 0; p <= 480; p++)
               {
                  position.x = o;
                  position.y = p;
                  SDL_FillRect (pixel[o][p], NULL, couleur[o][p]);
/* position à définir */
                  SDL_BlitSurface (pixel[o][p], NULL, ecran, &position);
               }
            }
         }
         SDL_Flip (ecran);
 
         pause ();
 
         {
            int q, r;
 
            for (q = 0; q <= 641; q++)
            {
               for (r = 0; r <= 481; r++)
               {
                  SDL_FreeSurface (pixel[q][r]);
               }
            }
         }
         SDL_FreeSurface (ecran);
      }
   }
   SDL_Quit ();
 
   return EXIT_SUCCESS;
 
}

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 int a,b; int c=0; Uint32 couleur[300][300]; float pas=1/255; float intervalle0=0; float intervalle1=pas; for ( a=0 ; a <= 299 ; a++ ) { for ( b=0 ; b <= 299 ; b++ ) { while ( intervalle1 <= 1 ) { if ( ( E_NORM[a][b] >= intervalle0 )&&( E_NORM[a][b] <= intervalle1 ) ) // On test les valeur de E_NORM à des intervalles prédéfinis (0 à 1/255) pour lui associer une couleur { couleur[a][b]= SDL_MapRGB ( ecran -> format, (int)(intervalle1*255), (int)(intervalle1*255), (int)(intervalle1*255) ); // Si E_NORM appartient à l'intervalle, on lui associe un code couleur } else { intervalle0 = (intervalle0 + pas ); // Si E_NORM n'appartient pas à l'intervalle, on incrémente les bornes de l'intervalle et le pas intervalle1 = (intervalle1 + pas ); } } } }
En fait le tableau E est une simulation des valeurs que prend un champ éléctrique. E_NORM correspond en fait à la normalisation de E c'est à dire que j'ai ramené les valeurs du champs dans un intervalle de 0 à 1. J'ai besoin de faire ça car la norme du champ n'est pas toujours la même, pour le moment si mais plus tard non un utilisateur choisira le nombre de charges.... et y'aura les vrai formule. Là je cherche à voir si déjà l'affichage du champs marche !
Cette boucle me permet normalement d'assoscier une couleur au pixel en fonction de l'intensité du champ. J'ai choisi un pas de 1/255 puisque je progresse ainsi 0,0,0 1,1,1 .... 255,255,255. Et normalement je n'ai pas de débordement, je suis sur que le code couleur est correct. Si la norme est compris dans l'intervalle on lui associe un code couleur. Si ce n'est pas le cas on recommence le test en incrémentant l'intervalle !

Il y'avait encore des erreurs dans la boucle. J'avais oublié de remettre les test sur 0-1, c'était encore sur -1-1 et puis pas++; en fait ne sert pas c'est une de mes lubies ^^. Cependant ça plante toujours ! J'espère que vous avec mieux compris ce que je veux faire avec cette boucle !

Merci d'avance

29/05/2008, 13h29
Overcrash

dev cpp ...

conseil : cours chercher code blocks ("gratuit")

devcpp ça fait longtemps qu'il évolue plus !

++ over