Problème avec segmentation fault

Version imprimable

23/05/2010, 15h40
Gobelins

Problème avec segmentation fault

Bonjour,

J'ai écrit un code source en c et en Opengl afin de générer un terrain. Le programme se compile, mais lors de l'exécution, il m'affiche segmentation fault. J'ai lancer le debugger et voici le résultat du debugger: erreur au niveau de cette ligne

glVertex3f(posi,m.heightmap[i][j]*alt,posj);

et que la fonction dessine_sol (x=-1 et y=-2)

Aidez-moi
23/05/2010, 16h53
ram-0000
J'ai l'impression que tu "jardines" hors de ton jardin et que tu as explosé les valeurs de tes indices.
- quelle est la taille du tableau m.heightmap ?
- Quelle sont les valeurs de i et de j lorsque ton programme se plante ?
24/05/2010, 01h16
Gobelins

Program received signal SIGSEGV, Segmentation fault.

Quand je lance le debugger par le menu Debug-> Start, voici ce qui m'affiche:

Building to ensure sources are up-to-date
Build succeeded
Selecting target:
Debug
Adding source dir: I:\Informatique\Technique de rendu\paysage\
Adding source dir: I:\Informatique\Technique de rendu\paysage\
Adding file: bin\Debug\paysage.exe
Starting debugger:
done
Registered new type: wxString
Registered new type: STL String
Registered new type: STL Vector
Setting breakpoints
Debugger name and version: GNU gdb 6.7.50.20071127
Child process PID: 632
Program received signal SIGSEGV, Segmentation fault.
At I:/Informatique/Technique de rendu/paysage/terrain.c:233

En plus, une autre fenetre qui s'appelle Call Stack où il y a le nom des fonctions indiquant la présence des erreurs grace aux numéros de lignes.

-dessine_sol(x=-1, y=-2)
-choisir_texture()
-display()
-glutMainLoop()
-glutMainLoop()
-main(argc=1, argv=0x3e2638)

choisir_texture() et displaya() appellent dessine_sol.
glutMainLoop est appelée dans main.

Quand je lance par le menu Debuf->Debugging windows->Watches, une fenetre qui affiche ceci :

Local variables
m
name=0x47fa0000 <Adress 0x47fa0000 out of bounds>
name_texture=0x0
heightmap=0x0
texchrg=0x0

i=0
j=0
posi=-5121
posj=-10240

Function Arguments
x=-1
y=-2

Je n'ai pas affiché le code source car il est assez long, cependant si vous voulez que je l'affiche pour mieux éclaircir et m'aider à trouver les erreurs, je l'afficherai dans le prochain message.

Merci d'avance de votre aide et pour ceux qui s'intéressent à résoudre mon problème.
24/05/2010, 17h31
Invité

Bonjour, tu as une double erreur: la principale est que la structure m n'a pas été malloquée, donc quand tu essayes d'accéder à un élément le programme segfault immediatement. Ensuite, les variables i et j sont négatives, or les index d'un tableau doivent etre positifs, d'où une erreur que tu auras dès que tu auras corrigé la première!

m est déclarée dans cette fonction, n'est-ce pas:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*Charger une heightmap, remplit la matrice d'altitude, puis cree la matrice de couleurs et genere la texture correspondante */
multitexture creer_texture(multitexture m){
 
    int i,j;
    int k,l;
    Image *image = (Image *) malloc(sizeof(Image));
    ImageLoad(m.name, image);
    //remplisage de la matrice d'altitude 'mt.heightmap[][]':
    m.heightmap=(float**)malloc(SIZE*sizeof(float*));
    for (i=SIZE-1,k=0;i>0;i--,k++){
        m.heightmap[k]=(float*)malloc (SIZE*sizeof(float));
        for(j=0,l=0;j<SIZE*3;j+=3,l++){
            m.heightmap[k][l]=image->data[i*image->sizeX*3+j];
            pourcentage[k][l]=Terrain_RemplitPart(m.heightmap[k][l]);//calcul de la matrice de couleur
        }
    }
   generer_texture(m);//generation de la nouvelle texture
   free(image);
   return m;
}

26/05/2010, 13h19
Invité

En voyant ton code, je viens de comprendre que name est une variable de ta structure m. Selon gdb, name n'a pas été initialisé puisqu'il te dit que l'adresse est outofbounds, d'où certainement des erreurs ensuite. Teste la valeur de m et de ses champs à la fin de la fonction de remplissage. Et teste le retour de malloc!

J'ai dépose 3 fichiers: Loader.c, Loader.h et Terrain.c

C'est le fichier Loader.c

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
/*Charger une texture*/
GLuint Charger_Texture(char *filename, GLuint * texchrg,int n){
    Image *image;
    image = (Image *) malloc(sizeof(Image));
    ImageLoad(filename, image);
    texchrg=(GLuint*)malloc (sizeof(GLuint));
    glEnable(GL_TEXTURE_2D);
    glGenTextures(1, texchrg);
    glBindTexture(GL_TEXTURE_2D, *texchrg);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
    gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image->sizeX, image->sizeY, GL_RGB, GL_UNSIGNED_BYTE, image->data);
    free(image->data);
    free(image);
    return *texchrg;
}
 
 
/*Chargement des textures de base des heightmaps*/
void init_texture(){
    neige = (Image *) malloc(sizeof(Image));
    roche = (Image *) malloc(sizeof(Image));
    prairie = (Image *) malloc(sizeof(Image));
    eau = (Image *) malloc(sizeof(Image));
 
    ImageLoad("I:/Informatique/Technique de rendu/paysage/Images/neige.bmp", neige);
    ImageLoad("I:/Informatique/Technique de rendu/paysage/Images/roche.bmp", roche);
    ImageLoad("I:/Informatique/Technique de rendu/paysage/Images/grass.bmp", prairie);
    ImageLoad("I:/Informatique/Technique de rendu/paysage/Images/eau.bmp", eau);
}
 
 
/*Calcul des couleurs pour chaque pixel des heightmaps selon la hauteur*/
participation Terrain_RemplitPart(float haut){
    participation part;
    //p:prairie, r:roche, n:neige, e:eau,
    int add;
    add = haut + (rand()%25)-15; //un petit peu de hasard
        if(add<0) add = 0;
        if(add>255) add = 255;
        haut = add;
 
    if(haut<5.0){//les faible altitudes correspondent a la texture d'eau
            part.p=0.0;
            part.r=0.0;
            part.n=0.0;
            part.e=1.0;
 
        }
 
        else if(haut<20.0){// melange d'eau et de prairie
            part.p = (haut-5.0)/10.0;
            part.r = 0.0;
            part.n = 0.0;
            part.e = 1.0 - (haut-5.0)/10.0;
 
        }
        else if(haut<60.0){// en moyenne altitude on a de la pairie
            part.p = 1.0;
            part.r = 0.0;
            part.n = 0.0;
            part.e = 0.0;
 
        }
        else if(haut<130.0){// melange de prairie et de roche
            part.p = 1.0 - (haut-60.0)/70.0;
            part.r = (haut-60.0)/70.0;/*Charger une texture*/
            part.n = 0.0;
            part.e = 0.0;
 
        }
        else if(haut<180.0){// en haute altitude on a de la roche
            part.p = 0.0;
            part.r = 1.0;
            part.n = 0.0;
            part.e = 0.0;
 
        }
        else if(haut<220.0){// melange de roche et de neige
            part.p = 0.0;
            part.r = 1.0 - (haut-180.0)/40.0;
            part.n = (haut-180.0)/40.0;
            part.e = 0.0;
 
        }
 
        else{// et en tres haute altitude on a de la neige
            part.p = 0.0;
            part.r = 0.0;
            part.n = 1.0;
            part.e = 0.0;
 
        }
 
    return part;
}
 
 
/*Charger une heightmap, remplit la matrice d'altitude, puis cree la matrice de couleurs et genere la texture correspondante */
multitexture creer_texture(multitexture m){
 
    int i,j;
    int k,l;
    Image *image = (Image *) malloc(sizeof(Image));
    ImageLoad(m.name, image);
    //remplisage de la matrice d'altitude 'mt.heightmap[][]':
    m.heightmap=(float**)malloc(SIZE*sizeof(float*));
    for (i=SIZE-1,k=0;i>0;i--,k++){
        m.heightmap[k]=(float*)malloc (SIZE*sizeof(float));
        for(j=0,l=0;j<SIZE*3;j+=3,l++){
            m.heightmap[k][l]=image->data[i*image->sizeX*3+j];
            pourcentage[k][l]=Terrain_RemplitPart(m.heightmap[k][l]);//calcul de la matrice de couleur
        }
    }
   generer_texture(m);//generation de la nouvelle texture
   free(image);
   return m;
}
 
 
/*Genere une texture en fonction de la matrice de couleurs*/
void generer_texture(multitexture m){
    int i, j, k, l, z, I;
    Image  *image = (Image *) malloc(sizeof(Image));
    ImageLoad(m.name, image);
    for (i=SIZE-1,k=0;i>0;i--,k++){
        for(j=0,l=0;j<SIZE*3;j+=3,l++){
            z=(j%prairie->sizeY);
            I=(i%prairie->sizeX)*prairie->sizeX*3+z-z%3;
            //calcul des couleurs de chaque pixel de la heightmap grace a la matrice de couleurs precalculee
            rouge[k][l] = pourcentage[k][l].p *prairie->data[I]
                        + pourcentage[k][l].r *roche->data[I]
                        + pourcentage[k][l].n *neige->data[I]
                        + pourcentage[k][l].e *eau->data[I]
 
                        ;
            vert[k][l]  = pourcentage[k][l].p *prairie->data[I+1]
                        + pourcentage[k][l].r *roche->data[I+1]
                        + pourcentage[k][l].n *neige->data[I+1]
                        + pourcentage[k][l].e *eau->data[I+1]
 
                        ;
            bleu[k][l]  = pourcentage[k][l].p *prairie->data[I+2]
                        + pourcentage[k][l].r *roche->data[I+2]
                        + pourcentage[k][l].n *neige->data[I+2]
                        + pourcentage[k][l].e *eau->data[I+2]
 
                        ;
            //on memorise ces nouvelles couleurs dans l'image
            image->data[(SIZE-i)*image->sizeX*3+j]=(rouge[k][l]);
            image->data[(SIZE-i)*image->sizeX*3+j+1]=(vert[k][l]);
            image->data[(SIZE-i)*image->sizeX*3+j+2]=(bleu[k][l]);
        }
    }
    //enfin on enregistre la texture
    ImageSave(m.name_texture,image);
    free(image);
}

Le fichier Loader.h

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
#define SIZE 512 //taille des images de multitexture
#define N 50    //taille de la heihtmap: 50*50*SIZE
 
//FONCTIONS PERMETTANT:
//-le chargemet des images et textures bmp
//-la sauvegarde d'images bmp
//-le chargement de heightmaps bmp
//-la creation de nouvelles textures en fonction des heightmaps
 
 
//Structure stockant les données d'une image bmp
typedef struct {
    unsigned long sizeX;
    unsigned long sizeY;
    GLubyte *data;
} Image;
 
//Structure correspondant aux participations des textures de base pour un pixel d'une heightmap
struct participation {
     float p;//pourcentage de la texture 'prairie'
     float r;//pourcentage de la texture 'roche'
     float n;//pourcentage de la texture 'neige'
     float e;//pourcentage de la texture 'eau'
 
};
typedef struct participation participation;
 
/*Structure permettant de stocker les informations necessaires a l'exploitaton d'une heightmap*/
typedef struct multitexture{
    char *name;               //son nom pour le chargement de la heightmap
    char *name_texture;       //nom de la texture generee
    float **heightmap;        //la matrice contenant les altitudes correspondant aux niveaux de gris
    GLuint *texchrg;          //la texture "name_texture" chargee
} multitexture;
 
 
/*LES FONCTIONS*/
    //Les images et textures bmp
static unsigned int getint(FILE *);
static unsigned int getshort(FILE *);
int ImageLoad(char *, Image *);
int ImageSave(char *filename, Image *image);
GLuint Charger_Texture(char *, GLuint * ,int );
 
    //Exploitation des multitextures pour les heightmaps
void init_texture();
multitexture creer_texture(multitexture);
void generer_texture(multitexture);
 
    /*LES VARAIBLES*/
int HEIGHTMAP[N][N];     //La heightmap
static GLuint *CIEL;     //structure ciel
 
Image *neige,*roche,*prairie, *eau;//textures de base pour les heightmaps
multitexture mt[5];//tableau de multitexture pour les heightmaps
int nbtexture;//nombre de textures pour les heightmaps
participation pourcentage[SIZE][SIZE];
float rouge[SIZE][SIZE];//tableau contenant les valeurs de la couleur rouge pour chaque pixel de la texture generee
float vert[SIZE][SIZE];//tableau contenant les valeurs de la couleur vert pour chaque pixel de la texture generee
float bleu[SIZE][SIZE];//tableau contenant les valeurs de la couleur bleue pour chaque pixel de la texture generee

Le fichier Terrain.c

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
//dessine une multitexture correctement, en respectant les altitudes
 void dessine_sol(int x, int y){
    multitexture m;
    int i,j;
    float posi,posj;
 
    //on calcule la multitexture correpondante a HEIGHTMAP[x][y]
    m=mt[HEIGHTMAP[x][y]];
 
    glBindTexture(GL_TEXTURE_2D, m.texchrg);//on utilise la texture qui lui est associee
    glPushMatrix();
        glEnable(GL_TEXTURE_2D);
 
        //pour chaque pixel (i,j) de la multitexture:
        for(i=0 ,posi=taille*x;i<SIZE-2;i++,posi+=pas){
            for(j=0, posj=taille*y;j<SIZE-1;j++,posj+=pas){
 
                //on dessine les deux triangles formés par le carre: (i,j),(i,j+1),(i+1,j),(i+1,j+1)
                glBegin(GL_TRIANGLE_STRIP);
                    glTexCoord2f( ((float) j)/SIZE, ((float) i)/SIZE);
 
                        //l'erreur se situe sur cette ligne (glVertex3f)
                        glVertex3f(posi,m.heightmap[i][j]*alt,posj);
 
                    glTexCoord2f( ((float) j+1)/SIZE, ((float) i)/SIZE);
                        glVertex3f(posi,m.heightmap[i][j+1]*alt,posj+pas);
                    glTexCoord2f( ((float) j+1)/SIZE, ((float) i+1)/SIZE);
                        glVertex3f(posi+pas,m.heightmap[i+1][j+1]*alt,posj+pas);
 
                    glTexCoord2f( ((float) j)/SIZE, ((float) i)/SIZE);
                        glVertex3f(posi,m.heightmap[i][j]*alt,posj);
                    glTexCoord2f( ((float) j+1)/SIZE, ((float) i+1)/SIZE);
                        glVertex3f(posi+pas,m.heightmap[i+1][j+1]*alt,posj+pas);
                    glTexCoord2f( ((float) j)/SIZE, ((float) i+1)/SIZE);
                        glVertex3f(posi+pas,m.heightmap[i+1][j]*alt,posj);
                glEnd();
            }
        }
	glDisable(GL_TEXTURE_2D);
    glPopMatrix();
}
 
//Trouve une multitexture dans les environs, la selectionne pour la dessiner
void choisir_texture(){
    int i,j,x,y;
    x=(int)(xcam/taille);
    y=(int)(ycam/taille);
    for(i=x-5;i<=x+5;i++)
        for(j=y-5;j<=y+5;j++)
            if (HEIGHTMAP[i][j] != 0){
                x=i;
                y=j;
 
                 //La deuxième erreur se trouve sur dessine_sol
                dessine_sol(x,y);
                return;
            }
    dessine_sol(x,y);
    return;
}
 
 
/*fonction d'affichage*/
//dessine tous les elements du programme, repositionne la camera
void display(){
    int i,j;
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
/* Rotation du sol autour d'un axe vertical*/
        glRotatef(angleZ,0.0,0.0,1.0);
        /* Position de la camera */
          gluLookAt(xcam, ycam, zcam, xtarget, ytarget, ztarget, 0.0, 0.0, 1.0);
 
//dessin des sols plats
        for (i=-50;i<N+50;i++)
            for (j=-50;j<N+50;j++)
                if(i<0 || j<0 || i>= N || j>=N)
                dessineSolPlat(i,j,mt[HEIGHTMAP[0][0]]);
                else
                   dessineSolPlat(i,j,mt[HEIGHTMAP[i][j]]);
       //La troisème erreur se situe sur choisir_texture         
        choisir_texture();//selection d'une multitexture et dessine celle-ci en fonction de ses altitudes
        glTranslatef(xtarget,ytarget,ztarget);
        glPushMatrix();
            dessineCiel();
 
glPopMatrix();
    glPopMatrix();
    glFlush();
    FPS();
    glutSwapBuffers();
}
 
 
//Fonction Main
//l'erreur est sur le main
int main(int argc, char *argv[]){
 
    /*creation de la fenetre*/
    glutInit(&argc, argv);
    glutInitWindowSize(500,500);
    glutInitWindowPosition(100,100);
    glutCreateWindow("PAYSAGE NATUREL");
 
    /*Fonctions d'initialisation*/
    init_texture();
    initialiser();
 
    /*Fonctions de rappel*/
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
    glutDisplayFunc(display);
    glutMotionFunc(mouseMotion);
    glutKeyboardFunc(keyboard_1);
    glutSpecialFunc(keyboard_2);
    glutReshapeFunc(reshape);
 
    /*lancement de la boucle d'attente*/
// L'erreur est sur glutMainLoop
    glutMainLoop();
    return 0;
}

Dans le fichier Terrain.c, j'ai affiché que quelques fonctions concernées par les erreurs, et non pas tout le code source (le positionnement de la caméra, ses angles de rotation, la fonction initailiser, etc...)

27/05/2010, 20h08
Invité

Il faut que tu essayes ce que je t'ai conseillé dans mon précédent post, que tu testes tous les malloc, et aussi essaye d'envoyer m en tant que pointeur dans les fonctions où tu fais des malloc sur des champs de cette structure, ca vient peut-etre de là.

Comment tester tous les malloc?

Citation:

aussi essaye d'envoyer m en tant que pointeur dans les fonctions où tu as fais des malloc sur des champs de cette structure

J'ai 3 structures avec leurs champs:

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
//Structure stockant les données d'une image bmp
typedef struct {
    unsigned long sizeX;
    unsigned long sizeY;
    GLubyte *data;
} Image;
 
//Structure correspondant aux participations des textures de base pour un pixel d'une heightmap
struct participation {
     float p;//pourcentage de la texture 'prairie'
     float r;//pourcentage de la texture 'roche'
     float n;//pourcentage de la texture 'neige'
     float e;//pourcentage de la texture 'eau'
 
};
typedef struct participation participation;
 
/*Structure permettant de stocker les informations necessaires a l'exploitaton d'une heightmap*/
typedef struct multitexture{
    char *name;               //son nom pour le chargement de la heightmap
    char *name_texture;       //nom de la texture generee
    float **heightmap;        //la matrice contenant les altitudes correspondant aux niveaux de gris
    GLuint *texchrg;          //la texture "name_texture" chargee
} multitexture;

J'ajoute que *m comme paramètre dans les fonctions où j'ai fais malloc? tu fais allusion à ça je pense?

28/05/2010, 12h35
Invité

Oui, envoie m en tant que pointeurs aux fonctions où tu l'utilises pour que les changements soient répercutés. Par exemple pour créer-texture envoie multitexture *m. Pour vérifier un malloc, il suffit de faire pour voir si l'adresse donnée est égale à NULL. De facon générale, tous les appels systèmes doivent etre vérifiés.
02/06/2010, 13h20
Gobelins

C'était un problème qui est du aux paramètres de la caméra. J'ai changé les valeurs du positionnement de la caméra. Le programme s'éxécute, et génère un terrain qui s'affiche mais avec des pixels plus au moins visibles. Je pense que je dois encore règler les paramètres de gluLookAt.