Discussion :

[Lork'han]

Bonjour à tous,
Je me présente, je m'appelle Yann et je suis tout nouveau sur le forum du moins en tant que participant. Je suis ingénieur en systèmes embarqués et pour un projet je me met à la programmation graphique ce qui n'est vraiment pas ma spécialité.
Je me suis auto formé à l'aide de l'excellent tutoriel sur ce site de Jean-Michel Fray sur l'utilisation de OpenGL pour avoir les bases.

Je vous explique mon projet et mes difficultés :

Globalement, je doit recréer en 3D une sphère réelle à partir d'image microscopique de sa surface. Au labo j'ai monté un dispositif ThorLabs de microscopie optique et à l'aide d'un asservissement je vais faire tourner ma sphère pour la parcourir et obtenir un très grand nombre d'images de sa surface ( en fois 250 à fois 500 pour le grossissement). Je suis parti dans l'optique de venir recoller ces images sur les facettes d'un icosphère dimensionnée comme il faut créé en OpenGL/C++.
J'ai trouvé un code en ligne dont j'ai une compréhension pour l'instant encore limitée, qui crée une icosphère et qui l'affiche avec de nombreuses options disponibles et qui prend en entrée un fichier Bmp qui va servir à texturer la sphère en wrap.
La forme requise pour ce fichier est la suivante :



J'aimerais donc créer ce genre d'image mais subdivisée en tout petits triangles sur lesquels je viendrais apposer mes images en .tiff pour le moment. Il faut que je puisse garder une très forte résolution et que je puisse gérer des milliers d'images...
Je sais qu'on ne peut pas amener autant d'images qu'on veut pour texturer un objet en OpenGL alors je suis un peu perdu sur la méthode à adopter...

Si vous avez des recommandations ou même que vous considérez que je suis parti dans la mauvaise direction en terme de langage de programmation ou de méthode n'hésitez surtout pas.

Je vous remercie par avance.

[LittleWhite]

Bonjour,

Il faudra falloir faire preuve d'ingéniosité pour afficher votre image très (très très) haute définition dans OpenGL. Premièrement, l'application d'une image (texture) est souvent limitée à l'utilisation de texture de 8192x8192 pixels. Par conséquent, je pense qu'il faudra faire un travail pour afficher la sphère triangle par triangle en changeant de texture à chaque triangle. On peut optimiser un peu, en essayant de dessiner plusieurs triangles à la fois.

[Lork'han]

Bonjour,

Merci beaucoup de votre réponse ! J'abandonne donc l'idée de la texture unique en effet...
Il va falloir que je m'approprie un peu mieux le code de l'icosphère que j'ai pour arriver à texturer chaque triangles indépendamment !

Je vais partir sur cette voie !

Sinon au cas où vous auriez des suggestions sur d'autres langages/manières de faire qui soit peut être plus orienté pour mon projet ?

En vous remerciant

[Lork'han]

Bonjour,

Mon programme a avancé dans le sens ou j'ai le mien avec possibilité de subdiviser mon icosphère autant de fois que je le veut pour augmenter son nombre de face.

Maintenant je bloque complétement, je n'arrive pas à comprendre comment je vais pouvoir texturer mes milliers de faces indépendamment... Simplement appliquer les coordonnées de textures pour chaque image et chaque face est envisageable ou ma mémoire vidéo va craquer ? j'ai du mal a saisir les principes d'images chargées ou pas en mémoire...

Si vous avez une piste

Merci

[Kannagi]

Oui tu dois mettre les coordonné de texture pour chaque vertex , je vois pas le souci :p

Par contre des milliers de vertex c'est peanut de nos jours , sauf si tu as une carte graphique qui date des année 90 (et encore ).
Je veux dire même sur PS1 on affichait 4000 polygone texturé à l'écran et pourtant elle doit être loin d'avoir la RAM que tu possède ! :p

J'ai un model 3D de 1200 triangles , en mémoire il me prend un peu moins de 30ko , donc je pense que si tu as plus de 30 ko de RAM dispo , ça devrait être bon

[Lork'han]

Ok super, tu me rassure merci beaucoup

Mais on est d'accord que je vais avoir une texture différente pour chaque vertex hein ?
C'est plus au niveau de la surcharge d'images de haute définition à l'écran qui me faisait peur...

[Kannagi]

Pourquoi avoir une texture pour chaque vertex ? (surtout que techniquement tu peux changer de texture que pour chaque triangle).
Par contre le changement de texture est plutôt coûteux , je te conseille d'avoir une bonne grosse texture de 2048x2048 que plein de 128x128 par exemple

[Lork'han]

Une image par triangle pardon (je suis un peu perdu avec le vocabulaire XD), et je vais monter à 20000 voir 80000 triangles...
Justement je ne peut pas, je doit garder une très haute résolution sur chacune des images et une texture unique implique que je perde cette résolution et donc que je ne voit pas bien l'information que je veut sur un point donné de la sphère (en zoomant dessus).
Mon projet est dans un but de recherche, d'où ma question de savoir si openGL était adapté

La il faudra que chacune des textures soit de 2048 par 2048 c'est pour ça que je me demande si la mémoire va pas se mettre a genoux...

Merci de ton aide en tout cas !!

[Kannagi]

Ben il faut faire le calcul alors pour 20000 texture de 2048x2048 on a donc 251 658 240 000 octets , soit 251 Go et pour 80 000 on a 1 To , ben je connais aucune VRAM qui a cette taille donc tu connais la réponse
(Et il faut avoir un bon disque dur ).

Bref ta méthode est plutôt mauvaise (parce qu'on aura jamais à l'écran un besoin d'un tel détails sur toute les textures) , il est plus judicieux de tout mettre en basse résolution et d'upload tout simplement la texture que tu zoom.
Tu peux très bien faire une partie des calcul 3D coté CPU (la transformation perspective) tu connaîtra la taille de chaque triangle à l'écran et donc de mettre la texture (de bonne taille) approprié.

Sinon oui OpenGL est adapté mais un peu obsolète , actuellement c'est Vulkan qui est utilisé.

[Lork'han]

En effet c'est bien ce que je pensais Mais alors j'ai aucunes idée de comment faire ce que tu dit (je suis vraiment débutant complet en programmation graphique -> a part le C et l'assembleur moi...)
Je pensais que ça se faisait automatiquement avec les MipMap...

[Kannagi]

Cela se fait automatiquement avec les MipMap dans le sens ça affichera la bonne texture stockée en VRAM , juste que les MipMap prenne 33% de plus en mémoire
(Elle stocke la plupart des tailles) , le but d'une MipMap c'est plus pour d'accélérer le rendu (parce que charger une texture de 2048x2048 pour afficher 3 pixel , c'est pas le truc le plus optimiser ).
Et ton souci actuelle , c'est que ce que tu veux faire est impossible ( il y'a aucune CG qui à 1 To de VRAM ).
Donc tu n'as pas le choix ,tu dois utiliser une technique de buffer pour afficher ce que tu veux (en gros mettre en buffer juste quelque texture 2048x2048 , bref ce que tu zoom).

Ben OpenGL n'est pas compliqué , tu as du code pour envoyer en VRAM glTexImage2D et glGenTextures(pour recuperer son id) et une pour la libérer glDeleteTextures.

a part le C et l'assembleur moi...)

Heureusement que c'est pas incompatible , je fais aussi du C et de l'assembleur

[Lork'han]

Je comprend bien oui ! Mais du coup comment je différencie les différents niveau de résolution ? Ca voudrait dire que j'ai plusieurs textures uniques avec différentes résolution et que je fait appel à l'une ou l'autre selon ma distance caméra/sphère (en ne prenant évidemment que la partie de l'image qui m’intéresse)
En gros ma sphère quelque soit la distance sera texturé à la même résolution comme ça.

La vache je vais galérer mais je comprend le principe XD

Ah bah je suis là pour apprendre c'est sur, merci en tout cas !!

[Bousk]

Par exemple. C'est ce qu'on appelle du LOD, et à distance ta sphère peut très bien devenir un carré ou n'avoir que quelques faces.

[Lork'han]

ohhhh d'accord merci pour le terme, je viens de faire quelques recherches là dessus mais je n'arrive pas à trouver d'exemple d'utilisation...

[Kannagi]

Si tu as bien compris , en gros il faudra upload ta texture 2048x2048 du Disque Dur -> VRAM.

C'est le même principe que le LOD , sauf que ça sera pas sur les vertex que tu dois réduire/augmenter la qualité.

Ben comment on fait , la formule c'est :

Code :

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

1
2
3
vec = Matrix x vecteur
w = 1/vec.w
vec.xyz *= w

En langage C , ça donne ça :

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
Vector3 TransformPerspective(float* matrix,Vector3 vec)
{
	float x,y,z,w;
 
	x = vec.x;
	y = vec.y;
	z = vec.z;
 
	vec.x = (matrix[0+0]*x) + (matrix[4+0]*y) + (matrix[8+0]*z) + (matrix[12+0]);
	vec.y = (matrix[0+1]*x) + (matrix[4+1]*y) + (matrix[8+1]*z) + (matrix[12+1]);
	vec.z = (matrix[0+2]*x) + (matrix[4+2]*y) + (matrix[8+2]*z) + (matrix[12+2]);
	w     = (matrix[0+3]*x) + (matrix[4+3]*y) + (matrix[8+3]*z) + (matrix[12+3]);
 
	if(w != 1.0f)
	{
		w = 1.0f/w;
 
		vec.x *= w;
		vec.y *= w;
		vec.z *= w;
	}
 
	return vec;
}

Et donc ça te donne les coordonnée 2D à l'écran , après c'est à toi de voir sur quelle taille du triangle tu dois appliquer quel texture