Discussion :

[bartmanb]

Bonjour à tous,

suite à un projet que je développe pour l'université, je dois afficher dans mon programme (à l'aide d'un tableau bi-dimensionnel stockant toutes les valeurs) plus de 77millions de pixels... Et c'est là que le bas blesse, l'affichage marche, certes c'est un peu long pour s'afficher, mais dès lors qu'il s'agit de déplacer la caméra et donc réaliser de nouveau un glutPostRedisplay pour refaire appel à la fonction d'affichage, j'ai droit encore au même temps d'attente... ainsi utiliser le programme devient vite frustrant (même les ventilos du pc ont chauds lool)

Alors ma question est assez simple : comment puis-je faire pour que l'affichage soit plus rapide afin que l'utilisation du programme devienne plus fluide.

Voici ma fonction d'affichage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void Draw_()
{
	Vec3 p;
 
	int pas_color ;
	float ind_color ;
 
	pas_color = floor((float)((abs(t->Elev_Min)+t->Elev_Max)/256));
        glPointSize(1);
	glBegin(GL_POINTS);
	for(int i=0; i< t->m_NL ; i=i++)
	{
		for(int j=0;j< t->m_NG; j=j++)
		{
			p.x = i ; p.y = 0 ; p.z = j;
			if ((frustum.pointInFrustum(p) != FrustumG::OUTSIDE))
			{
				if((t->ppTE[i][j]!=Zmin)&&(t->ppTE[i][j]!=Znc))
				{
					ind_color = ((float)(t->ppTE[i][j])/(float)(256*pas_color))*2;
					if(ind_color <= 1)glColor3f(ind_color,ind_color,ind_color);
					else glColor3f(1.,1.,1.);
					glVertex3f(i,0,j);
				}
			}
		}
	}
	glEnd();
}

Pour précision ici m_NL vaut 10801 et m_NG vaut 7201 d'où cette boucle sur plus de 77 millions de pixels. Comme vous pouvez le constater j'ai mis en place un frustrum culling pour optimiser l'affichage mais celà ne reste toujours pas satisfaisant,

Votre aide est donc comme toujours la bienvenue

Merci d'avance,

[TanEk]

Le probleme ici est que tu sollicites trop ton CPU et pas assez ton GPU. Je doute fort que ce que tu entendes soit le ventilo de ta carte graphique...

Pour eviter cela il faut que tu minimises les appels de fonction OpenGL (un appel OpenGL = une communication entre ton CPU et le GPU = tu passes a travers plusieurs couches systemes et tu passes a travers le bus pci express qui est pas un rapide, etc.).

De plus tu affiches ici les pixels les uns a la suite des autres ! Ton GPU peut afficher plusieurs milliers de pixels en meme temps et la tu lui dis : affiches moi ce pixel, puis celui-la, etc. bref tu utilises 1% de ton GPU la...

Pour eviter cela il faut que tu minimises le nombre d'appel OpenGL... Je te conseille donc de stocker ces 77 millions de pixels dans une texture OpenGL ca te fera une dizaine d'appels pour la copie et ensuite 1 ou 2 appels lors de l'affichage (tu ne fais la copie qu'une fois...).

Ensuite pour afficher ton image rien ne vaut un bon vieux carre qui sera texture par cette texture et tu verras ton tableau bi-dimensionnel s'afficher sur l'ecran (qui te prendra encore une vingtaine d'appels).

Donc en gros tu peux arriver a environ 20 appels OpenGL pour afficher ton image au lieu de quelques dizaines de millions, ton CPU sera plus content.

Regardes donc les tutoriels qui parlent de l'application de texture en OpenGL.

[bartmanb]

Ok je te remercie pour cette idée, si quelqu'un en connaît plus sur les textures en opengl je suis preneur, sinon j'essaierais de me débrouiller d'ici demain, et si je suis perdu de nouveau je reviendrais

En tout cas TanEK je te remercies encore, le ventilo que j'entends est bien celui du CPU je confirme lool je connais pas grand chose niveau texture, mais je vais me pencher sur le sujet, car ta piste m'a l'air forte intéressante, merci encore et je vous tiendrai au courant de l'évolution de mon problème

EDIT : Enfin la question que je me pose plutôt est : comment utiliser mon tableau bi-mensionnel pour créer la texture, parce que la plupart des sites expliquant l'application de textures se bsent sur des images à charger....

Merci encore d'avance

[bafman]

il faut que tu transforme ton tableau bidimensionnel en tableau unidimensionnel pour pouvoir l'envoyer à la carte graphique.

par contre, tu a sans doute interet à découper ta matrice en plusieurs sous matrices et donc faire plusieurs textures, ça sera plus souple pour l'affichage

[ShevchenKik]

Bonjour,

bafman, Tanek, est ce que vous pensez qu'utiliser un vertex array avec glDrawArrays(GL_POINTS,...), ou un VBO est aussi jouable? Plus ou moins rapide que l'utilisation d'une texture?

C'est juste une idée, mais c toujours bon d'etudier les différentes possibilités

[bafman]

c'est infiniment plus pourri que l'utilisation de texture

[bartmanb]

ok et merci encore pour vos réponses

il faut que tu transforme ton tableau bidimensionnel en tableau unidimensionnel pour pouvoir l'envoyer à la carte graphique.

par contre, tu a sans doute interet à découper ta matrice en plusieurs sous matrices et donc faire plusieurs textures, ça sera plus souple pour l'affichage

Pourrai-je avoir plus d'infos sur la manière de procéder pour créer une texture ensuite à partir du tableau unidimensionnel ??? merki encore pour vos idées et vos pistes

[ShevchenKik]

c'est infiniment plus pourri que l'utilisation de texture

hehehe merci, ca a le mérite d'être clair

[bafman]

http://tfcduke.developpez.com/tutoriel/format/tga/
si tu met de coté la partie lecture du fichier TGA, tu a toutes les info pour créer ta texture

[bartmanb]

merci pour les renseignements encore, voici donc les étapes à effectuer si je comprends bien :

- 1° : Créer une structure stockant les infos pour la structure:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
typedef struct
{
    GLuint  width;           /* largeur */
    GLuint  height;          /* hauteur */
 
    GLenum  format;          /* RVB, RVBA, Luminance, Luminance Alpha */
    GLint   internalFormat;  /* composantes d'un texel */
 
    GLubyte *texels;         /* données de l'image */
 
} gl_texture_t;

- 2° : Remplir le tableau texels avec mon tableau à deux dimensions contenant les élévations

- 3° : Création de la texture :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/* génère la texture */
glGenTextures( 1, &texid );
glBindTexture( GL_TEXTURE_2D, texid );
 
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
 
glTexImage2D( GL_TEXTURE_2D, 0, gltex.internalFormat, gltex.width, gltex.height,
                0, gltex.format, GL_UNSIGNED_BYTE, gltex.texels );
 
/* OpenGL possède sa propre copie de l'image */
free( gltex.texels );

- 4° : Attacher ma texture à un quad dans mon display de la façon suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
void
display (void)
{
  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glLoadIdentity ();
 
  glEnable (GL_TEXTURE_2D);
  glBindTexture (GL_TEXTURE_2D, texId);
 
  /* draw quad */
  glTranslatef (0.0, 0.0, -5.0);
  glBegin (GL_QUADS);
    glTexCoord2f (0.0f, 0.0f);
    glVertex3f (-1.0f, -1.0f, 0.0f);
 
    glTexCoord2f (1.0f, 0.0f);
    glVertex3f (1.0f, -1.0f, 0.0f);
 
    glTexCoord2f (1.0f, 1.0f);
    glVertex3f (1.0f, 1.0f, 0.0f);
 
    glTexCoord2f (0.0f, 1.0f);
    glVertex3f (-1.0f, 1.0f, 0.0f);
  glEnd  ();
 
  glDisable (GL_TEXTURE_2D);
 
  glutSwapBuffers ();
}

c'est bien ça ??? J'ai rien oublié dans la démarche à suivre ??? En tout cas je vous remercie pour votre aide, je ne pourrai tester tout celà que lundi, donc c'est pour ça que je demande avant toute chose la bonne démarche à suivre

Merci encore en tout cas à vous tous

[bartmanb]

Alors re à tout le monde, voici des nouvelles des tests que j'ai pu faire aujourd'hui avec la création de texture :

Tout d'abord j'ai réussi à stocker une partie de mon tableau à deux dimensions dans un tableau à 3 dimensions que j'ai utilisé pour ma texture, je dis une partie parce que justement mon problème est le suivant : j'arrive à appliquer ma texture à un quad que j'ai crée mais seulement si mon tableau stockant les données de la texture ne dépasse pas [2048][2048][3]. Or le tableau que je veux stocker a pour dimensions [10801][7201] donc là échec complet mon quad reste blanc (tout comme moi )

Alors d'après ce que j'ai pu lire la longueur et la largeur doivent être ^2 alors j'ai essayer pour dimensions 4096 et 4096 mais là aussi échec total et mon beau quad reste tout blanc... D'où peut venir ce problème ???

J'aurai pu créer plusieurs tableaux pour stocker ma texture mais le problème c'est que les tailles des dimensions de mes données à stocker dans les textures sont variables selon un fichier de lecture, ainsi je ne sais pas à l'avance combien de tableaux vont me suffire.

Je mets à disposition le code source des fonctions que j'utilise pour les textures et attends vos commentaires et conseils avec impatience parce que ça m'a bien fait cogiter pendant toute l'après-midi ce problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
GLfloat texture[2048][2048][3]; // Variable globale
 
void Stocke_DTED()
{
	int pas_color ;
	float ind_color ;
 
	pas_color = floor((float)((abs(t->Elev_Min)+t->Elev_Max)/256));
 
	for(int i=0; i< 2048 ; i++)
	{
		for(int j=0;j< 2048; j++)
		{
			if((t->ppTE[i][j]!=Zmin)&&(t->ppTE[i][j]!=Znc))
			{
				ind_color = ((float)(t->ppTE[i][j])/(float)(256*pas_color))*2;
			        if(ind_color <= 1)
				{
					texture[i][j][0] = (GLfloat)ind_color ;
					texture[i][j][1] = (GLfloat)ind_color ;
					texture[i][j][2] = (GLfloat)ind_color ;
				}
				else
				{
					texture[i][j][0] = (GLfloat)1. ;
					texture[i][j][1] = (GLfloat)1. ;
					texture[i][j][2] = (GLfloat)1. ;
				}
			}
		}
	}
}

Voici ma fonction d'initGL :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
void visu_DTED_init()
{
	glutInitWindowPosition(700,250);
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
	glutInitWindowSize(500,500);
	main_window = glutCreateWindow("SDTOWS");
	glClearColor(0.3,0.3,0.3,1.);
 
	// TEST
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_TEXTURE_2D);
	glGenTextures(1,&nom_text);
	glBindTexture(GL_TEXTURE_2D,nom_text);
	glPixelStorei(GL_UNPACK_ALIGNMENT,1); 
	glTexImage2D(GL_TEXTURE_2D,0,3,2048,2048,0,GL_RGB,GL_FLOAT,&texture[0][0][0]);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}

Voilà dans ce cas là avec les tailles de 2048 2048 ça passe nickel mais pour le multiple de 2 suivant c'est-à-dire 2048*2=4096 ma texture n'est plus visible et mon quad est tout blanc...

Tout vos commentaires sont la bienvenue, si vous voulez d'autres renseignements sur le code n'hésitez pas, je vous remercie par avance et j'espère que certains d'entre vous pourront m'éclairer un petit peu dans cette obscurité profonde

[LittleWhite]

Peux tu montrer le code qui affiche la texture ( glVertex3f ... quelque chose comme ça ) car je ne le voix pas...

[bartmanb]

Voilà le code qui permet d'afficher la texture

void draw(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(cam.x,cam.y,cam.z, l.x,l.y,l.z,u.x,u.y,u.z);

glPushMatrix();
glBindTexture(GL_TEXTURE_2D,&nom_text);
glBegin(GL_QUADS);
glTexCoord2i(0,1);glVertex3i(0,0,0);
glTexCoord2i(1,1);glVertex3i(1000,0,0);
glTexCoord2i(1,0);glVertex3i(1000,0,1000);
glTexCoord2i(0,0);glVertex3i(0,0,1000);
glEnd();
glPopMatrix();
glFlush();
glutSwapBuffers();
}

Aujourd'hui j'ai essayé une autre solution qui est de diviser ma texture en plusieurs de 64x64pixels pour celà j'ai utilisé une dimension supplémentaire au tableau stockant les données de la texture.
Voici le code utilisé, malheureusement je n'ai pas eu le temps de tester, mais pensez-vous qu'une "segmentation" en texture de 64x64 est mieux qu'une de 2048x2048 ??? En fait je me dis que mes données étant de dimensions 10801x7201 si je parcelle en 2048x2048 je vais avoir besoin au total de 24parcelles tandis que si je parcelle en 64x64 je vais avoir 19097 parcelles.
Voici le code que j'ai utilisé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
GLfloat texture[19097][64][64][3];  // Variable globale
 
         // ceci est un text que je veux utilisé pour voir le temps de calcul avant l'affichage
        for(int k=0; k<19097 ;k++)
	{
		for(int i=0; i< 64 ; i++)
		{
			for(int j=0;j< 64; j++)
			{
				if(k==0)
				{
					texture[k][i][j][0] = 0. ;
					texture[k][i][j][1] = 1. ;
					texture[k][i][j][2] = 0. ;
				}
				else
				{
					texture[k][i][j][0] = 1. ;
					texture[k][i][j][1] = 0. ;
					texture[k][i][j][2] = 0. ;
				}
			}
		}
	}

Voici la fonction d'init pour Opengl

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
// Fct d'init. de la visu de la fenêtre contenant la carte
void visu_DTED_init()
{
	glutInitWindowPosition(700,250);
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
	glutInitWindowSize(500,500);
	main_window = glutCreateWindow("SDTOWS");
	glClearColor(0.3,0.3,0.3,1.);
 
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_TEXTURE_2D);
 
	glGenTextures(19097,nom_text);
 
	for(int k=0; k<19097 ;k++)
	{
		glBindTexture(GL_TEXTURE_2D,nom_text[k]);
		glPixelStorei(GL_UNPACK_ALIGNMENT,1); 
		glTexImage2D(GL_TEXTURE_2D,0,3,64,64,0,GL_RGB,GL_FLOAT,&texture[k][0][0][0]);
		glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	}
}

Et ma fonction d'affichage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
// Fct d'affichage
void draw(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(cam.x,cam.y,cam.z, l.x,l.y,l.z,u.x,u.y,u.z);
	glPushMatrix();
		for(int k=0;k<19097;k++)
	        {
		glBindTexture(GL_TEXTURE_2D,nom_text[k]);
		glBegin(GL_QUADS);
			glTexCoord2i(0,1);glVertex3i(k*100,0,k*100);
			glTexCoord2i(1,1);glVertex3i(k*100+100,0,k*100);
			glTexCoord2i(1,0);glVertex3i(k*100+100,0,k*100+100);
			glTexCoord2i(0,0);glVertex3i(k*100,0,k*100+100);
		glEnd();
	        }
	glPopMatrix();
	glFlush();
	glutSwapBuffers();
}

Voilà vos commentaires sont la bienvenue, n'ayant pu tester vraiment, j'ai juste lancer l'application une fois et remarqué que la phase de remplissage du tableau stockant des données est très long (à peu près 3 à 4 min sur un pc n'ayant que 512 de ram aussi... vive les pc du boulot...)

Pensez-vous que cela peut être optimiser ??? Si oui comment ?
Ou alors pensez-vous qu'il serait mieux à la limite de stocker mes données dans un bitmap ou autre ... ????

[bartmanb]

Bonsoir,

Je vous donne un peu de nouvelles concernant le problème sur lequel je bloquais. J'ai finalement réussi à utiliser un tableau de GLubyte contenant toutes mes parcelles, je n'ai pu finaliser le tout mais je pense que demain tout sera bon.

J'aurai maintenant besoin de vos conseils sur autre soucis. Je m'explique : la texture que j'ai réalisé et que j'ai plaqué sur un quad représente un terrain d'élévation sur une fenêtre 2D. Maintenant je souhaite réaliser une fenêtre 3D vue d'avion (perspective) et me balader sur le terrain, seulement je ne peux utiliser la même texture car je suis et me balade dans un espace en 3 dimensions. Comment puis-je procéder à la représentation de mon terrain en 3D sachant que le problème majeur reste le même qu'en 2D c'est-à-dire que j'ai plus de 77millions de valeurs d'élévations sur mon terrain...

Une idée par exemple que j'aimerais appliquer est d'afficher seulement que la partie du terrain qui est devant l'hélicoptère. C'est pas tout à fait un frustum culling car je veux éviter le test de toutes les valeurs pour voir s'ils appartiennent au champs de visée. Pour résumer, j'aimerais directement savoir quelles valeurs je dois afficher selon la position de mon avion et son champ de vue... Savez-vous comment puis-je faire celà ??? Sinon toutes vos propositions sont bonnes et je les attends impatiemment car je suis en manque total d'imagination....

Merci d'avance et j'espère que vous pourrez m'aiguiller

[bartmanb]

bon finalement j'ai réussi à stocker mes 77millions de pixels et à afficher tout ça en utilisant des parcelles de 256x256. Il faut certes à peu près 1min sur le vieux pc du boulot pour m'afficher mon quad mais au moins après je peux bouger ma caméra d'une manière assez réactive.

Maintenant j'ai le même soucis en 3D : je veux afficher mes élévations en 3D de la même manière mais en vue "avion" embarqué, seulement j'aimerais restreindre l'affichage à ce que la caméra "voit", pour éviter de lancer toute la boucle dans ma fonction d'affichage. Si vous avez des bonnes idées je suis preneur...

[oxyde356]

Regarde du coté des "Level of detail" (LOD) sur google. Pour un terrain il existe pas mal de technique d'optimisation : Octree, ROAM, GeoClipMapping ...
Déjà comment affiche tu tes parcelles de terrains, utilise tu encore le glVertex ou tu es passé aux VBO ?