Création d'une Miniature d'une vue OpenGL

Bonjour à tous.

Je travail actuellement sur un logiciel de calcul sur pièce mécanique qui inclus également un outils de visualisation des pièce mécanique en 3D.
Mon environnement de développement est Embarcadero® RAD Studio XE et tout est fait en C++.

Ces vues 3d sont faite avec OpenGL et il peut y avoir plusieurs vues ouverte en même temps.

J'aurais besoins, pour un nouveau module du logiciel , de créer un fenêtre contenant les aperçus de toutes les vue 3D ouverte. Un petit peu comme la fenêtre qui apparait sous Vista lorsqu'on fait alt+tab pour naviguer entre les fenêtres.

Pour le moment j'arrive à lister toutes les vue 3D ouvertes, ça aucun problème. Je récupère les TForm associées également.

Ensuite, pour l'aperçu, j'ai essayé différentes techniques :
- L'utilisation de la fonction GetFormImage() de la classe TForm me fait un screenshot de la TForm mais sans la vue 3D. La zone ou devrait apparaitre la vue est tout simplement vide:cry:.

-L'utilisation de la fonction glReadPixels. C'est avec cette fonction que j'ai eu les meilleurs résultats. Le hic c'est que je passe par un fichier temporaire pour convertir les pixel en un object Graphics::TBitmap.

Ne connaissant pas du tout le fonctionnement d'OpenGL j'ai repris les méthode de ce site pour la lecture des pixel et l'écriture du fichier .bmp


http://neogamedev.chable.net/index.php?PageID=2018 (section "Ecrire une image Bitmap")

Et il y aussi d'autres petits soucis avec cette méthode :
Si la fenêtre TForm contenant la vue 3D a été réduite à un très petit format (100x100 par exemple), le fichier .bmp temporaire créé est valide (selon l'aperçu windows).
Mais si ma fenêtre est agrandie le fichier .bmp créé n'est plus valide(selon l'aperçu windows toujours), mais je peu tout de même le visualiser avec paint. Et les couleurs de ma pièce mécanique ne correspondent plus à ma vue 3D.

Dans tous les cas j'arrive à charger l'image dans un objet Graphics::TBitmap à l'aide de la méthode LoadFromFile. Je redimensionne mon image à une taille d'environ 150x150 pour en faire un aperçu. Et après redimensionnement j'ai un autre soucis, mon image manque de netteté.

Donc au final je souhaiterai savoir pourquoi l'utilisation de la méthode glReadPixel et l'écriture de l'image dans un fichier échoue si ma vue 3D est "trop grande".

Et je souhaiterai également savoir s'il existe des techniques pour améliorer la netteté à l'affichage d'un objet Graphics::TBitmap (à l'aide de filtre ou autre).


Merci d'avance!!!!

En tout cas, je ne sais pas si tu maitrises la partie OpenGL, mais tu peux aussi passer par les FrameBufferObject pour faire le dessin en 2 endroits :
1 - la fenêtre (pour l'affichage normal)
2 - dans une texture (un buffer de pixels) que tu chargerais dans tes Graphics::TBitmap. Le mieux pour cela serait d'allouer un TMemoryStream qui recevrait directement les pixels de la texture, et tu ferais un LoadFromStream à partir de ton TBitmap.

Merci beaucoup pour les infos.

Non malheureusement je ne maitrise pas la partie OpenGL, enfin pas encore ;)! C'est l'occasion de s'y mettre.

Je suis en train de me renseigner sur les frameBufferObject et ce que je pourrait faire avec.
J'ai déjà regardé quelques info et effectivement ça pourrait tout a fait convenir au traitement que je cherche à réaliser. En revanche l'utilisation de cet objet pourrait m'obliger à faire des modifications majeures. Mais je garde cette option.

Je continue mes recherche et je vous tient au courant!

Tu n'as pas besoin de passer par un fichier temporaire pour assigner une image dans un TBitmap. Tu peux tout faire en mémoire:
Tu Dump le contenu de la fenêtre OpenGL dans un Buffer (pBits) et tu recopie ce buffer dans celui de TBitmap.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

BYTE* pBits = new BYTE[nWidth*nHeight]; BYTE* pOri = pBits; BYTE* pDst; glReadPixels(0,0,nWidth,nHeight, GL_BGRA_EXT, GL_UNSIGNED_BYTE, pBits); Graphics::TBitmap* pBmp = new Graphics::TBitmap(); pBmp->Width = nWidth; pBmp->Height = nHeight; pBmp->PixelFormat = pf32Bits; for (int nRow=0; nRow<pBmp->Height; nRow++) { pDst = pBmp->ScanLine[nRow); for (int nCol=0; nCol<pBmp->Width; nCol++) { *pDst++ = *(pOri++); // B *pDst++ = *(pOri++); // G *pDst++ = *(pOri++); // R *pDst++ = *(pOri++); // A } }

---

Il y a surement quelques coquilles, j'ai tappé ça vite fait.
J'espère que ça réponds à ton problème.

Bonjour à tous par cette belle journée de printemps !!!:)

Bon alors, après consultation de pléthore de tutoriel, forum ... je conclut que la solution à appliquer est bien l'utilisation de Frame Buffer Object.

D'un point de vue théorique j'ai saisi la marche à suivre. D'un point de vue pratique c'est autre chose...

Je vais essayer de résumer ce que j'ai compris de cet outils.
A la création de la vue 3D j'initialise une texture T dans laquelle tout mon modèle en trois dimensions sera tracé.
Ensuite j'initialise un fbo que je lie avec ma texture T.
J'active le fbo avant de dessiner des formes.
Je dessine mes formes.
Et ensuite soit je les affiches à l'écran, soit le fait le transfert fbo-> bitmap.

Donc la mise en place de cet outil n'aura aucun impact sur mes méthodes de dessins déjà existantes ?

Autre petite question, mon image sera au format 200*200 à peu près, et donc pour que la qualité soit optimale il faudrait que le buffer que je transfert en bitmap soit aussi au format 200*200. (la réduction d'une image bitmap ne donne pas de résultat correct).
Est ce que cela m'oblige à relancer le dessin de ma vue au format souhaité ?


Merci beaucoup yarp pour ce morceau de code, ça me sera très utile! J'essaie ça dès que j'ai réussi à mettre en place mon fbo ! Je me doutait bien qu'on devait pouvoir faire ça.

> Autre petite question, mon image sera au format 200*200 à peu près, et
> donc pour que la qualité soit optimale il faudrait que le buffer que je
Dans l'exemple que je t'ai donné tu as directement les Pixels de l'image dans le buffer pBits. Il te suffit de les redimensionner en 200x200 - facile.
Ce ne sont pas les algos qui manquent sur le net.

Perso j'utilise ceci (Regarde la fonction Scale):
http://www.codeproject.com/KB/graphics/CBitmapEx.aspx

Sinon tu trouvera des exemples similaires dans toutes les librairies d'image, mais il te faudra decortiquer un peu plus.

Il y a aussi ce site qui contient de nombreux exemples sur le traitement d'image avec la VCL:
http://www.efg2.com/Lab/Library/Delphi/index.html

Merci pour les info.

J'avais déjà vu comment redimensionner mon TBitmap en utilisant la STL.

Mes images se redimensionnent correctement, ça aucun soucis.

Mais mon petit soucis c'est que le modèle 3D n'est constitué que de traits représentant des éléments qui composent ma pièce mécanique. Et au rétrécissement de l'image certains trait passent à la trappe, et il est difficile de reconnaitre l'image d'origine.

C'est pour ça que je me disais que redessiner la vue en plus petit format en ofscreen avant de créer la bitmap pourrait corriger ce petit problème.

Mais j'ai toutes mes clé en main maintenant je devrai pouvoir m'en sortir.

Merci beaucoup pour vos réponses!