création de textures

Version imprimable

27/02/2009, 18h49
jo the boss

création de textures

Bonsoir tout le monde voila mon soucis est simple j'ai une image stockée dans un tableau d'entiers et j'aimerais la transformer en texture pour opengl sans avoir a sauvegarder le fichier. J'ai essayer de recopier mon tableau dans un autre tableau de bytes et de donner ce dernier en parametre a la fonction glTexImage2D mais cela n'a pas marché.
Avez vous une idée de la facon dont je pourrais procéder?
28/02/2009, 00h48
LittleWhite

Bonjour,

Que contient ton tableau? ( Comment est stockée ton image dans le tableau ? )
28/02/2009, 01h24
jo the boss

Bonsoir alors mon tableau est a un tableau d'entiers a trois dimensions tab[hauteur][largeur][3] et contient la valeur de chaque composante R,G,B de chaque pixel.
J'ai essayé en remplacant GL_UNSIGNED_BYTE par GL_INT dans la fonction glTexImage2D mais ca fait completement planter mon application.
Il doit bien y avoir moyen de definir une texture a partir d'un tableau d'entier.
Mon but est en fait dafficher une video en opengl, vu que les images recuperées par ma webcam sont stockées dans un tableau d'entiers je veux directement traiter ces données et ne pas devoir sauvegarder puis charger un fichier ce qui est impensable 8O
Voila si qulqu'un a une petite astuce :D
Bonne soirée ++

je post le code de mon programme. Jutilise pour linstant une fonction charger que jai ecrit moi meme et qui charge une image au format .ppm et lenregistre dans un tableau d'entiers. A l'execution le programme fait tout planter :evilred:

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
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <opencv/highgui.h>
#include <opencv/cv.h>
#include <cstdlib>
#include "sdlglutils.cpp"
#include "image.h"
#include "charger.c"
 
void Dessiner();
 
GLuint texture1;
GLuint texture[263][400][3];
 
int main(int argc, char *argv[])
{
    int i,j;
    Image im;
    im = (Image)malloc(sizeof(struct ima));
 
 
    SDL_Event event;
 
    SDL_Init(SDL_INIT_VIDEO);
    atexit(SDL_Quit);
    SDL_WM_SetCaption("SDL GL Application", NULL);
    SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);
 
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective(70,(double)640/480,1,1000);
 
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
    charger(im,"lost.ppm");
    printf("%d %d\n",(*im).hauteur,(*im).largeur);
    for(i=0;i<(*im).hauteur;i++){
        for(j=0;j<(*im).largeur;j++){
            texture[i][j][0]=(*im).image[j][i].r;
            texture[i][j][1]=(*im).image[j][i].g;
            texture[i][j][2]=(*im).image[j][i].b;
        }
    }
    printf("Termine\n");
    glGenTextures(1,&texture1);
    glBindTexture(GL_TEXTURE_2D, texture1);
    glTexImage2D(GL_TEXTURE_2D,0,3,640,480,0,GL_RGB,GL_INT,texture);
 
    Dessiner();
 
    Uint32 last_time = SDL_GetTicks();
    Uint32 current_time,ellapsed_time;
    Uint32 start_time;
 
    for (;;)
    {
        start_time = SDL_GetTicks();
 
        while (SDL_PollEvent(&event))
        {
 
            switch(event.type)
            {
                case SDL_QUIT:
                exit(0);
                break;
            }
        }
 
        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;
 
        Dessiner();
 
        ellapsed_time = SDL_GetTicks() - start_time;
        if (ellapsed_time < 10)
        {
            SDL_Delay(10 - ellapsed_time);
        }
 
    }
 
    return 0;
}
 
void Dessiner()
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
    gluLookAt(0,5,0,0,0,0,0,0,1);
 
    glMatrixMode( GL_TEXTURE );
    glLoadIdentity( );
 
    glBindTexture(GL_TEXTURE_2D, texture1);
    glPushMatrix();
 
    glBegin(GL_QUADS);
        glTexCoord2d(0,1);
        glVertex3d(1,1,1);
        glTexCoord2d(0,0);
        glVertex3d(1,1,-1);
        glTexCoord2d(1,0);
        glVertex3d(-1,1,-1);
        glTexCoord2d(1,1);
        glVertex3d(-1,1,1);
    glEnd();
    glFlush();
    SDL_GL_SwapBuffers();
}

28/02/2009, 02h28
IrmatDen

Salut,

J'imagine que le .ppm est mal lu et que tu fais un dépassement quelconque; il faudrait que tu utilises ton debugger pour vérifier ça.

Sinon, pourquoi utiliser des GLuint et non des GLubyte pour ta texture ? Tu trouveras un exemple de texture procédural sur ce fil d'ailleurs.
28/02/2009, 21h31
jo the boss

bonsoit,
en fait je ne pense pas que cela vienne de ma fonction car je lavais ecrit bien avant et deja utilisée et il n'y avait aps eu de probleme, jai meme essayé sans la fonction en recuperant directement une image de ma webcam et cela plante de la meme facon.

Sinon dans l'esprit je voulais utiliser des bytes mais question tres bete je pense, comment je fais pour convertir mon tableau d'entiers en tableau de bytes?:oops:

merci et bonne soirée
02/03/2009, 00h03
jo the boss

personne n'a d'idée pour convertir mon tableau d'entiers en byte?
02/03/2009, 00h33
LittleWhite
Cela dépend.

Un entier ( soit un int ) peut contenir une valeur de -2^31 à 2^31 ( à peu de chose près ) ( entier de 32bits )
Un byte ne pourra que contenir 8 bits soit une valeur de -127 à 127.

Si tu fais une convertion direct tu va perdre un tas d'information.

Maintenant j'imagine que tes ints contiennent les couleurs ...
Donc il te faudra 4 bytes par int pour garder les couleurs.

Ce que tu peux faire, c'est des décalages de bits pour accéder à la couleur que tu veux.
Exemple :
un int : 0000 0000 0000 0000 0000 0000 0000 0000
1 byte : 0000 0000
4 bytes: 1 byte | 1 byte | 1 byte | 1 byte

Donc théoriquement tu pourrais y arriver avec ce code là
Code:

1 2 3 4 5 6 7 8 9 10 int i; GLbyte r, g, b, a; a = (GLbyte)i; i >> 8; // On décale de huit b = (GLbyte)i; i >> 8; // On décale de huit g = (GLbyte)i; i >> 8; // On décale de huit r = (GLbyte)i;
( Je suis pas sur que cela marche par contre :s
02/03/2009, 00h48
jo the boss

oki merci pour la reponse j'avais du mal a faire le lien entre les deux je vai essayer ce que tu me dis...
merci et bonne nuit :)
02/03/2009, 00h57
jo the boss

bon par contre jai un int pour chaque composante de couleur donc ca doit changer un petit peu le truc si jai bien suivit..

Dans ce cas il suffit de stocker la valeur de l'int dans un entier de taille 8.

Par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #include <stdlib.h> #include <stdint.h> #include <stdio.h> int main(void) { int32_t i = 100; int8_t b = i; printf("%i\n", b); return EXIT_SUCCESS; }
Si les types "int8_t" n'est pas fourni par ta plateforme il est possible d'utiliser un char :
Code:

1 2 int i = 100; char b = i;

02/03/2009, 11h02
bafman

le plantage viens surtout du fait que tu utilise un tableau sous la forme [Width][Height][3] alors que tu devrait l'envoyer sous la forme [width*height*3]. Les données envoyé à opengl doivent être contigüe et sous une forme utilisable par l'API ;)

Bonsoir tout le monde, merci beaucoup pour vos nombreuses réponses je comprends mieux beaucoup de choses désormais.
J'ai donc modifier mon code selon les conseils que vous m'avez donné de la facon suivante

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
 
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <opencv/highgui.h>
#include <opencv/cv.h>
#include <cstdlib>
#include "sdlglutils.cpp"
#include "image.h"
#include "charger.c"
 
void Dessiner();
 
GLuint texture1;
unsigned char *bgr,rgb;
 
int main(int argc, char *argv[])
{
    int i,j,indice=0;
    Image im;
    im = (Image)malloc(sizeof(struct ima));
    bgr = (unsigned char *) malloc(sizeof(unsigned char)* 263 * 400 * 3);
    memset(bgr,0,sizeof(unsigned char) * 263 * 400 * 3);
    IplImage* img;
    CvScalar scalaire;
 
 
    SDL_Event event;
 
    SDL_Init(SDL_INIT_VIDEO);
    atexit(SDL_Quit);
    SDL_WM_SetCaption("SDL GL Application", NULL);
    SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);
 
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective(70,(double)640/480,1,1000);
 
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
    charger(im,"lost.ppm");
    printf("%d %d\n",(*im).hauteur,(*im).largeur);
    indice=0;
 
    for(i=0;i<(*im).hauteur;i++){
        for(j=0;j<(*im).largeur;j++){
            rgb = (unsigned char)(*im).image[i][j].r;
            bgr[indice] = rgb;
            indice++;
            rgb = (unsigned char)(*im).image[i][j].g;
            bgr[indice] = rgb;
            indice++;
            rgb = (unsigned char)(*im).image[i][j].b;
            bgr[indice] = rgb;
            indice++;
        }
    }
    glGenTextures(1,&texture1);
    glBindTexture(GL_TEXTURE_2D, texture1);
    glTexImage2D(GL_TEXTURE_2D,0,3,640,480,0,GL_RGB,GL_UNSIGNED_BYTE,bgr);
 
    Dessiner();
 
    Uint32 last_time = SDL_GetTicks();
    Uint32 current_time,ellapsed_time;
    Uint32 start_time;
 
    for (;;)
    {
        start_time = SDL_GetTicks();
 
        while (SDL_PollEvent(&event))
        {
 
            switch(event.type)
            {
                case SDL_QUIT:
                exit(0);
                break;
            }
        }
 
        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;
 
        Dessiner();
 
        ellapsed_time = SDL_GetTicks() - start_time;
        if (ellapsed_time < 10)
        {
            SDL_Delay(10 - ellapsed_time);
        }
 
    }
 
    return 0;
}
 
void Dessiner()
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
    gluLookAt(0,3,0,0,0,0,0,0,1);
 
    glMatrixMode( GL_TEXTURE );
    glLoadIdentity( );
 
    glBindTexture(GL_TEXTURE_2D, texture1);
    glPushMatrix();
 
    glBegin(GL_QUADS);
        glTexCoord2d(0,1);
        glVertex3d(1,1,1);
        glTexCoord2d(0,0);
        glVertex3d(1,1,-1);
        glTexCoord2d(1,0);
        glVertex3d(-1,1,-1);
        glTexCoord2d(1,1);
        glVertex3d(-1,1,1);
    glEnd();
    glFlush();
    SDL_GL_SwapBuffers();
}

Alors le programme de plante plus ;) par contre j'obtient une texture completement blanche...:cry:
j'ai essayé d'utiliser la fonction de chargement d'openCV et d'utiliser la structure img->imageData pour creer ma structure mais jai eu le meme résultat.
De même avec une image differente.
sur ce lien une personne a reussit a faire exactement ce que je veux et j'ai l'impression que le code est le même en ce qui concerne la création de texture :
http://www.codeguru.com/forum/showthread.php?t=405356
Jpense que je suis pas loin mais il doit me manquer un petit truc...

re bonsoir jai trouvé un bout de code sur internet qui fait exactement ce que je veut avec la fonction charger d'opencv et ca marche bien (le code est identique a celui que j'ai ecrit pourtant:?)
Je peux donc passer a l'étape suivante de mon projet qui est de visioner un flux provenant de la webcam en utilisant opengl. Pour cela j'utilise les fonctions d'opencv mais lors de l'execution je n'ai qu'une seule image qui apparait...:cry:
A votre avis ou dois je placer les fonctions

Code:

1
2
3
 
img = cvRetrieveFrame( capture );
loadTexture_Ipl( img, &texture1 )

dans mon code pour que les textures soient actualisées a chaque nouvelle capture de la webcam? 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
 
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <opencv/highgui.h>
#include <opencv/cv.h>
#include <cstdlib>
#include "sdlglutils.cpp"
#include "image.h"
#include "charger.c"
 
void Dessiner();
 
GLuint texture1;
IplImage* img;
CvCapture* capture;
 
int loadTexture_Ipl(IplImage *image, GLuint *text) {
 
    if (image==NULL) return -1;
 
    glGenTextures(1, text);
 
	glBindTexture( GL_TEXTURE_2D, *text ); //bind the texture to it's array
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
 
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image->width, image->height,0, GL_BGR, GL_UNSIGNED_BYTE, image->imageData);
    return 0;
 
}
 
int main(int argc, char *argv[])
{
    SDL_Event event;
 
    SDL_Init(SDL_INIT_VIDEO);
    atexit(SDL_Quit);
    SDL_WM_SetCaption("SDL GL Application", NULL);
    SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);
 
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective(70,(double)640/480,1,1000);
 
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
    capture = cvCreateCameraCapture( -1 );
    if( !capture )
        return 10;
    if(!cvGrabFrame( capture ))
        return 20;
    //img=cvLoadImage("lost.ppm");
 
	//The load iplimage to opengl texture
	img = cvRetrieveFrame( capture );
	loadTexture_Ipl( img, &texture1 );
 
    Dessiner();
 
    Uint32 last_time = SDL_GetTicks();
    Uint32 current_time,ellapsed_time;
    Uint32 start_time;
 
    for (;;)
    {
        start_time = SDL_GetTicks();
 
        while (SDL_PollEvent(&event))
        {
 
            switch(event.type)
            {
                case SDL_QUIT:
                exit(0);
                break;
            }
        }
 
        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;
 
        img = cvRetrieveFrame( capture );
        loadTexture_Ipl( img, &texture1 );
        Dessiner();
 
        ellapsed_time = SDL_GetTicks() - start_time;
        if (ellapsed_time < 50)
        {
            SDL_Delay(50 - ellapsed_time);
        }
 
    }
 
    return 0;
}
 
void Dessiner()
{
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
    gluLookAt(0,3,0,0,0,0,0,0,1);
 
    glMatrixMode( GL_TEXTURE );
    glLoadIdentity( );
    img = cvRetrieveFrame( capture );
    loadTexture_Ipl( img, &texture1 );
    glBindTexture(GL_TEXTURE_2D, texture1);
    glPushMatrix();
 
    glBegin(GL_QUADS);
        glTexCoord2d(0,1);
        glVertex3d(1,1,1);
        glTexCoord2d(0,0);
        glVertex3d(1,1,-1);
        glTexCoord2d(1,0);
        glVertex3d(-1,1,-1);
        glTexCoord2d(1,1);
        glVertex3d(-1,1,1);
    glEnd();
    glFlush();
    SDL_GL_SwapBuffers();
}

Au passage si quelqu'un sait pourquoi ce code marche et pas celui d'avant je veux bien l'explication car le mystere reste entier en ce qui me concerne et j'aimerais bien comprendre.
merci a tous et bonne soirée

Bonsoir tout le monde juste pour vous signaler que jai reussi a faire exactement ce que je voulais je post le code au cas ca interesserait quelqu'un ;)

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
 
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <opencv/highgui.h>
#include <opencv/cv.h>
#include <cstdlib>
 
GLuint texture1; //the array for our texture
IplImage *img,*img2;
CvCapture* capture;
 
 
//The IplImage to OpenGl texture function
int loadTexture_Ipl(IplImage *image, GLuint *text) {
 
    if (image==NULL) return -1;
 
    glGenTextures(1, text);
 
	glBindTexture( GL_TEXTURE_2D, *text ); //bind the texture to it's array
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
 
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image->width, image->height,0, GL_BGR, GL_UNSIGNED_BYTE, image->imageData);
    return 0;
 
}
 
 
void display (void) {
 
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );
 
    gluLookAt(0,4,0,0,0,0,0,0,1);
 
    glMatrixMode( GL_TEXTURE );
    glLoadIdentity( );
    glBindTexture(GL_TEXTURE_2D, texture1);
    glPushMatrix();
 
    glBegin(GL_QUADS);
 
    glTexCoord2d(0,0);
    glVertex3d(1,1,1);
    glTexCoord2d(0,1);
    glVertex3d(1,1,-1);
    glTexCoord2d(1,1);
    glVertex3d(-1,1,-1);
    glTexCoord2d(1,0);
    glVertex3d(-1,1,1);
 
    glEnd();
 
    glFlush();
    SDL_GL_SwapBuffers();
 
}
 
void FreeTexture( GLuint texture )
{
  glDeleteTextures( 1, &texture );
}
 
 
 
int main (int argc, char **argv)
{
 
    /* création d'une fenêtre OpenGL RVBA avec en simple mémoire tampon
     avec un tampon de profondeur */
    SDL_Event event;
 
    SDL_Init(SDL_INIT_VIDEO);
    atexit(SDL_Quit);
    SDL_WM_SetCaption("SDL GL Application", NULL);
    SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);
 
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective(70,(double)640/480,1,1000);
 
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
 
    display();
 
    Uint32 last_time = SDL_GetTicks();
    Uint32 current_time,ellapsed_time;
    Uint32 start_time;
 
    CvCapture* capture = cvCreateCameraCapture( -1 );
 
    // On vérifie que la capture est bien initialisée,
    // si ce n'est pas le cas, on quitte le programme.
    if( !capture )
        return 10;
 
    cvNamedWindow("video", CV_WINDOW_AUTOSIZE);
    char key = ' ';
 
    // Tant qu'on n'a pas appuyé sur Q, on continue :
    while(key != 'q')
    {
        img2 = cvQueryFrame(capture);
        loadTexture_Ipl(img2,&texture1);
        cvShowImage( "video", img2 );
 
        // On attend 10 ms : IMPORTANT !
        key = cvWaitKey(10);
 
        start_time = SDL_GetTicks();
 
        while (SDL_PollEvent(&event))
        {
 
            switch(event.type)
            {
                case SDL_QUIT:
                exit(0);
                break;
            }
        }
 
        current_time = SDL_GetTicks();
        ellapsed_time = current_time - last_time;
        last_time = current_time;
 
        display();
 
        ellapsed_time = SDL_GetTicks() - start_time;
        if (ellapsed_time < 10)
        {
            SDL_Delay(10 - ellapsed_time);
        }
 
    }
 
    // On détruit les fenêtres créées : nouvelle fonction. ;)
    cvDestroyAllWindows();
 
    // On n'a pas besoin de détruire l'image.
    img2 = NULL;
 
    // On détruit la capture
    cvReleaseCapture( &capture );
 
    return 0;
}

Merci beaucou p pour votre aide en tout cas :D