Introduction à VTK

VTK est une bibliothèque portable de visualisation de données scientifiques écrite en C++ et orientée objet. Elle permet de faire des traitements sur ces données en créant très simplement une chaîne d'algorithmes pour produire au final une image 2D/3D. Elle est utilisée par de nombreuses universités et entreprises.

VTK a de nombreux bindings et peut être ainsi utilisée dans les langages Java, Python et Tcl. De plus, elle peut être intégrée très facilement dans de nombreuses bibliothèques de GUI : Qt, Swing, Tk, FLKT.

Son grand avantage est son large spectre d'applications (du traitement de l'image à la visualisation de données volumiques). De plus, un logiciel de visualisation nommé ParaView permet de faire de la visualisation de données au format interne VTK et ceci sur de simples machines ou des clusters graphiques et même du post processing en appliquant directement certains algorithmes de VTK.

Ceci est donc un grand avantage par rapport à ses concurrents car il permet aux programmeurs d'une entreprise de se concentrer uniquement sur la conversion de ses données vers le format VTK et de laisser les traitements de post processing aux non-informaticiens, j'entends par là les mathématiciens, physiciens, etc.

VTK a aussi un système de picking et d'interaction avec les objets 3D très très avancé et utilisant divers algorithmes (sélection par frustum, pick color, etc.). Vous pouvez sélectionner des objets entiers ou des primitives graphiques (triangles, points, lignes, etc.).

Son principal défaut est qu'il n'a pas de système de graphe de scène. Ne comptez pas utiliser cette bibliothèque si vous avez besoin de ce type de structure de données, orientez-vous plutôt vers OpenSceneGraph ou en java vers jmonkey. De plus les performances de VTK s'effondrent s'il contient plus de 1000 objets 3D (j'entends par là des vtkActor). Si votre application dépasse ce nombre je vous déconseille son utilisation. Ceci est dû à l'architecture de VTK qui donne une très grande généricité d'utilisation mais détruit les performances pour un très grand nombre d'objets. Néanmoins avec peu d'acteurs les performances de VTK sont très correctes (utilisant des display list donc l'affichage d'objets de plusieurs millions de triangles est possible). Encore une fois, je vous conseille de tester ParaView pour voir ce que VTK a dans le ventre au niveau performance.

Si vous voulez des exemples d'utilisation de VTK je vous conseille d'aller voir les références. Pensez que tous les exemples qui sont donnés font en moyenne 100 lignes de code. Vous pouvez donc faire de la visualisation très avancée avec très peu d'effort grâce à VTK.

II-A. Prérequis▲

II-B. Création des fichiers de compilation▲

ccmake .

//Path to a file.
JAVA_INCLUDE_PATH:PATH=/usr/lib/jvm/java-6-sun/include
 
//Path to a file.
JAVA_INCLUDE_PATH2:PATH=/usr/lib/jvm/java-6-sun/include/linux

II-C. Compilation▲

#define VTK_TYPE_USE___INT64

II-D. Linkage▲

II-E. Programme minimaliste▲

import vtk.*;
 
public class test {
 
  // Constructeur statique qui charge la bibliothèque VTK.
  // Les bibliothèques doivent être dans le path de votre système.
  static { 
    System.loadLibrary("vtkCommonJava"); 
    System.loadLibrary("vtkFilteringJava"); 
    System.loadLibrary("vtkIOJava"); 
    System.loadLibrary("vtkImagingJava"); 
    System.loadLibrary("vtkGraphicsJava"); 
    System.loadLibrary("vtkRenderingJava"); 
  }
 
  // Fonction principale
  public static void main (String[] args)
  {
	// Créer une géométrie sphérique
	vtkSphereSource sphere = new vtkSphereSource();
	sphere.SetRadius(1.0);
	sphere.SetThetaResolution(18);
	sphere.SetPhiResolution(18);
 
	// Transforme la géométrie en primitives graphiques (OpenGL dans notre cas)
	vtkPolyDataMapper map = new vtkPolyDataMapper();
	map.SetInput(sphere.GetOutput());
 
	// L'acteur représente l'entitée géométrique.
	// Il permet de définir sa position, son orientation, sa couleur, etc.
	vtkActor aSphere = new vtkActor();
	aSphere.SetMapper(map);
	aSphere.GetProperty().SetColor(0,0,1); // color blue
 
	// Nous créons un renderer qui va faire le rendu de notre entitée.
	vtkRenderer ren1 = new vtkRenderer();
	ren1.AddActor(aSphere);
	ren1.SetBackground(1,1,1); // background color white
 
	// Nous créons une fenêtre de rendu
	vtkRenderWindow renWin = new vtkRenderWindow();
	renWin.AddRenderer(ren1);
	renWin.SetSize(300,300);
 
	// Nous créons un interactor qui permet de bouger la caméra.
	vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
	iren.SetRenderWindow(renWin);
 
	// Nous lançons le rendu et l'interaction
	renWin.Render();
	iren.Start();
  }
}

Lors de la présentation, nous avons insisté sur le large spectre d'application de VTK (affichage 2D, 3D et volumique). Nous nous concentrerons ici sur la partie 3D de VTK.

VTK divise en 3 grandes parties la construction et l'affichage d'un objet 3D.

Tout d'abord nous avons les données elles-mêmes qui sont créées avec un objet source ou lues dans un fichier avec un objet reader ou alors directement créées par programmation. Dans notre exemple nous utilisons un objet de type vtkSphereSource :

	// Créer une géométrie sphérique
	vtkSphereSource sphere = new vtkSphereSource();
	sphere.SetRadius(1.0);
	sphere.SetThetaResolution(18);
	sphere.SetPhiResolution(18);

Vient ensuite la génération des primitives OpenGL qui est faite à l'aide d'un objet nommé mapper. Il va transformer la structure de données en primitives OpenGL (GL_TRIANGLE, etc.) :

	// Transforme la géométrie en primitives graphiques (OpenGL dans notre cas)
	vtkPolyDataMapper map = new vtkPolyDataMapper();
	map.SetInput(sphere.GetOutput());

Il existe plusieurs types de mappers adaptés à chaque structure de données fournie par VTK. Dans notre cas, comme nous avons une structure de données vtkPolyData (la sortie donnée par GetOutput du vtkSphereSource est un vtkPolyData), nous utiliserons le mapper de type vtkPolyDataMapper. Il faut savoir qu'il existe plusieurs types de données disponibles dans VTK mais le type le plus usité pour l'affichage 3D est le vtkPolyData.

Dans ce code vous voyez le mécanisme de VTK pour créer l'association entre les différents algorithmes : le mapper reçoit en entrée (SetInput) la sortie de l'objet source (GetOutput). Vous pouvez faire cela plusieurs fois d'affilée et ainsi créer un graphe complexe (certains algorithmes reçoivent plusieurs entrées ou donnent plusieurs sorties). Vous n'êtes donc limité que par votre imagination et tout ce qu'il faut savoir en utilisant VTK c'est quelles sont les associations d'algorithmes qui vont vous permettre d'obtenir le résultat escompté.

La dernière partie est l'association du mapper à l'objet 3D VTK lui-même qui est un vtkActor :

	// L'acteur représente l'entitée géométrique.
	// Il permet de définir sa position, son orientation, sa couleur, etc.
	vtkActor aSphere = new vtkActor();
	aSphere.SetMapper(map);
	aSphere.GetProperty().SetColor(0,0,1); // color blue

vtkActor nous sert entre autre à positionner et orienter l'objet, à le colorer, choisir des propriétés graphiques (avec son membre vtkProperty obtenu avec la méthode GetProperty).

Enfin il y a la partie sur le rendu lui-même qui consiste en la création d'un objet de type vtkRenderer qui va s'occuper de lancer les algorithmes : exécution du vtkSphereSource qui va engendrer un vtkPolyData contenant une sphère qui va être envoyé au vtkPolyDataMapper qui va créer des primitives OpenGL qui seront ensuite affichées dans la fenêtre associée au vtkRenderer. Nous lui ajoutons notre objet 3D pour qu'il s'occupe de son rendu :

	// Nous créons un renderer qui va faire le rendu de notre entité.
	vtkRenderer ren1 = new vtkRenderer();
	ren1.AddActor(aSphere);
	ren1.SetBackground(1,1,1); // background color white

Nous créons ensuite la fenêtre qui affichera le rendu :

// Nous créons une fenêtre de rendu
	vtkRenderWindow renWin = new vtkRenderWindow();
	renWin.AddRenderer(ren1);
	renWin.SetSize(300,300);

Et pour que l'utilisateur puisse bouger la caméra à l'aide de la souris nous créons un objet nommé interactor de type vtkRenderWindowInteractor et lançons l'affichage de la fenêtre et l'interaction avec l'utilisateur (la boucle événementielle de VTK) :

	// Nous créons un interactor qui permet de bouger la caméra.
	vtkRenderWindowInteractor iren = new vtkRenderWindowInteractor();
	iren.SetRenderWindow(renWin);
 
	// Nous lançons le rendu et l'interaction
	renWin.Render();
	iren.Start();

L'introduction s'achève ici. J'espère vous avoir donné l'eau à la bouche pour utiliser cette bibliothèque pas comme les autres.

Merci à diogene pour sa relecture et à toute l'équipe 2D/3D/Jeux.

Voici différents liens qui pourraient vous être utiles :

• Site officiel de VTK.
• Site officiel du logiciel Paraview.
• Exemples d'utilisations de VTK.
• Site officiel du scene graph java jmonkey.
• Site officiel de OpenSceneGraph.