Affichage et rendu 3D pour un environnement Java d`analyse d`image

Master 2 IICI - Projet 150 heures – année 2007/08
Affichage et rendu 3D pour un environnement
Java d'analyse d'image
Encadrant : Sébastien Lefèvre
Etudiants : Matthieu Dirrenberger / Vincent Colas

Rapport de projet 150h – M2 IICI – Affichage et rendu 3d pour un environnement Java
1

Rapport de projet 150h – M2 IICI – Affichage et rendu 3d pour un environnement Java
2
Sommaire
Introduction ............................................................................................................................................. 3
Les Choix technologiques ........................................................................................................................ 4
OpenGL 2.0 .......................................................................................................................................... 4
Shaders GLSL ....................................................................................................................................... 5
Java 3d ................................................................................................................................................. 6
JOGL ..................................................................................................................................................... 6
Mise en place de JOGL............................................................................................................................. 8
Installation ........................................................................................................................................... 8
Configuration de la machine virtuelle Java ......................................................................................... 8
Matériel graphique requis : ................................................................................................................. 8
Algorithme de rendu 3d topographique ................................................................................................. 9
Algorithme ........................................................................................................................................... 9
Algorithme de rendu volumique : ......................................................................................................... 11
Comment afficher 134 000 000 de cubes ? ....................................................................................... 11
Comment passer de 1Go à 10 Mo de données et l’animer de façon fluide ? ................................... 12
Algorithme : ....................................................................................................................................... 13
Exemples : ......................................................................................................................................... 14
Traitements d’image 2d accélérés par Shaders : .................................................................................. 16
Les filtrages : ...................................................................................................................................... 16
Le FrameBuffer : ................................................................................................................................ 18
Algorithmes divers : ........................................................................................................................... 18
Conclusion : ........................................................................................................................................... 19

Rapport de projet 150h – M2 IICI – Affichage et rendu 3d pour un environnement Java
3
Introduction
Le sujet que nous avons choisi de traiter consiste à pouvoir visualiser en 3d des données n’étant pas
initialement prévues pour un rendu 3d. En effet, les coupes 2d d’un scanner ne sont pas aisément
visualisables, car elles nous donnent des données volumiques et non pas surfaciques, ce qui pose
quelques problèmes tels que la taille des données à traiter ou des soucis de qualité d’affichage.
Le travaille réalisé s’articule autours du la librairie Pelican qui est une plate forme de développement
et d’outils liés à l’imagerie 2d. Cette plate forme est développée en Java permettant ainsi une grande
compatibilité et une redistribution on-line plus facile.
Nous verrons par la suite les choix techniques que nous avons faits pour pouvoir intégrer nos outils
de visualisation 3d à Pelican, puis nous présenterons une méthode de rendu 3d topographique pour
images 2d en niveaux de gris, ainsi qu’une méthode de rendu 3d volumique de coupes en niveaux de
gris. Enfin nous présenterons quelques techniques de traitement d’image 2d développées grâce aux
shaders qui permettent un traitement très rapide des images, notamment une technique basée sur
le « frame buffer » qui permettra d’affiner le rendu 3d en temps réel.

Rapport de projet 150h – M2 IICI – Affichage et rendu 3d pour un environnement Java
4
Les Choix technologiques
OpenGL 2.0
Dans un souci de compatibilité inter-systèmes il paraît évident d’utiliser OpenGL pour gérer
l’affichage 3d. OpenGL est une interface permettant de communiquer directement avec la carte
graphique en lui envoyant des primitives 3d telles que des coordonnées de sommets 3d à afficher. Le
seul concurrent sérieux d’OpenGL 2.0 est Microsoft DirectX 10, mais cela nous contraindrait à utiliser
uniquement Windows pour nos Viewers 3d car l’interfaçage DirectX/Java n’est que supporté sous
Windows dans Java3d. De plus cette version est incomplète par rapport à la version OpenGL de Java
3d.
Quand nous parlons d’OpenGL, nous précisons OpenGL 2.0 car nous utiliserons par la suite les
shaders GLSL (OpenGL Shaders Language) de la carte graphique, qui sont de petites unités de calcul
parallèles très utiles et puissantes. Il est à noter qu’OpenGL jusqu’à sa version 1.4 ne supporte pas la
programmation des shaders, et qu’ils ne sont disponibles qu’à partir de la version 2.0.
Pour pouvoir utiliser OpenGL en Java nous avons besoin de Binding Java/OpenGL. La plupart des
implémentations OpenGL sont écrites en C. Donc nous ne pouvons pas y accéder tel quel. On
utilisera JNI (Java Native Interface) qui permet d'utiliser du code natif écrit en C/C++ dans du Java.
Ceci permet de mettre en œuvre l'idée du binding OpenGL à travers JOGL. Il s'agit d'une API utilisant
JNI pour accéder à l'implémentation en C d'OpenGL. Donc toute cette gestion d'accès au code natif
est faite à l'intérieur de cette API. Au final, nous avons des API permettant d'utiliser l'OpenGL
(presque) comme si l'on développait en C. Pour ce qui est des performances, elles sont quasiment
identiques à celles du C (en ajoutant les appels JNI et diverses petites choses).
Il est nécessaire d’éclaircir quelques peu le fonctionnement des shaders GLSL car nous en parlerons
tout au long du rapport.
http://www.opengl.org/