|
Description
VTK : The Visualization ToolKit est une puissante bibliothèque Open Source de visualisation scientifique, traitement et synthèse d’images en trois dimensions. Elle est de plus en plus reconnue et utilisée dans le monde scientifique que ce soit au niveau industriel ou recherche académique.
Fonctionnement général
VTK est une librairie utilisable En divers langages, notamment le C/C++. Mais elle dispose de son propre langage : le TCL.
Le but principal de VTK est d’offrire un systéme complet et puisant, mais simple à utiliser. En effet en plus d’effectuer un rendu graphique de donn´ees, la bibliothéque fournit un ensemble d’algorithmes de visualisation (scalaires, vecteurs, tenseurs, ...) et de modélisation (surfaces implicites, reduction polygonale, d´etection de contour, triangulation de Delaunay, ...) ainsi que des routines de manipulation d’images.
VTK doit pouvoir etre utilisee par un panel large d’utilisateurs (étudiants, chercheurs, ingenieurs,...), spécialistes ou non.
VTK fonctionne sur la pluspart des plateformes Unix, Linux, MacOS X (`a partir de MacOS 10.2) et MS Windows (98/ME/NT/2000/XP). Cette bibliothéque est d´eveloppee en C++ a un niveau d’abstraction plus élevé qu’OpenGL ou PEX et optimisée pour des performances élevées, des bindings ont été réalisé en TCL, Python et Java. Ce qui permet de developper des applications rapidement, avec des interfaces utilisateurs graphiques ou non.
Une documentation conséquente existe en plus de plusieurs ouvrages ecrits, de plus une communauté importante s’est d´eveloppée par le biais de mailing-lists.
Travail effectué
Découverte de vtk
Etude d'un programme rendant un cône en TCL
Le Code commenté pour illustrer les points clef du pipeline
|
|
|
|
int main( int argc, char *argv[] )
{
//On crée le cône en initialisant sa hauteur, sa résolution et son rayon.
vtkConeSource *cone = vtkConeSource::New();
cone->SetHeight( 3.0 );
cone->SetRadius( 1.0 );
cone->SetResolution( 10 );
//vtkPolyDataMapper permet de conversion des données en primitives graphiquesvtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
coneMapper->SetInput( cone->GetOutput() );
/* vtkActor vtkActor : représente un objet de la scène rendue
- Multiplicité des acteurs dans une scène
- chaque acteur est associé à un mapper
- plusieurs acteurs peuvent se référer au même mapper */
vtkActor *coneActor = vtkActor::New();
coneActor->SetMapper( coneMapper );
/* vtkRenderer :
- génère l’image 2D correspondant à une scène 2D/3D
- coordonne acteurs , caméras et sources de lumières */
vtkRenderer *ren1= vtkRenderer::New();
ren1->AddActor( coneActor );
ren1->SetBackground( 0.1, 0.2, 0.4 );
// C’est la fenêtre d’affichage
vtkRenderWindow *renWin = vtkRenderWindow::New();
renWin->AddRenderer( ren1 );
renWin->SetSize( 300, 300 );
//Associe la fenêtre d’affichage
vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
iren->SetRenderWindow(renWin);
vtkInteractorStyleTrackballCamera *style =
vtkInteractorStyleTrackballCamera::New();
iren->SetInteractorStyle(style);
iren->Initialize();
iren->Start();
// Supprime tous les objets qui ont été créé
cone->Delete();
coneMapper->Delete();
coneActor->Delete();
ren1->Delete();
renWin->Delete();
iren->Delete();
style->Delete();
return 0;} |
|
|
|
|
VTK & Marching Squares
Environement de travail : VTK
Le but de ce TP est de réaliser la même présentation des données que pour le TP 1 (en utilisant un algorithme de type marching square) mais en utilisant la bibliothèque VTK. Il faudra d'abord convertir les données au format VTK puis programmer le même algorithme en utilisant les classes fournies par ce kit.
Conversion des données
Nos données sont organisées selon une topologie régulière en 2D. Nous avons donc choisi une format de type "points structurés" à deux dimensions en codant les valeurs sur des float. De plus, ce format est très proche du format "maison" que nous avons utilisé dans le TP1 (à part le header, les données des points on été copiées telles-quelles). Voici ce que cela donne :
|
|
|
|
# vtk DataFile Version 2.0
# Nos valeurs
ASCII
DATASET STRUCTURED_POINTS
DIMENSIONS 7 7 1
ORIGIN 0 0 0
SPACING 1 1 1
POINT_DATA 49
SCALARS values float
LOOKUP_TABLE default
3.01916 2.29619 2.05086 2.19015 2.9936 3.35122 3.84358
3.02469 2.53018 2.2264 2.32983 2.74447 2.9486 3.67591
3.0196 2.8549 2.76266 2.693 2.81074 3.07573 3.2075
3.19939 3.29857 3.4215 3.33166 3.02826 2.81074 2.60939
2.98634 3.5737 3.89092 3.75675 3.17829 2.76569 2.20287
2.9677 3.5676 3.90497 3.77949 3.29418 2.68257 2.19999
2.97887 3.29238 3.50024 3.43863 3.17162 2.82848 2.57565
Le code TCL destiné à lire ce fichier est le suivant :
# lecture des points
vtkStructuredPointsReader reader
reader SetFileName "points.vtk" |
|
|
|
|
Calcul et affichage des isolignes
Le composant utilisé pour calculer les isolignes est un vtkContourFilter. L'algorithme du marching square n'étant en ce moment par encore disponible pour des raisons de brevet, c'est cet algorithme, légèrement plus lent, que nous avons choisi.
Afin d'afficher le résultat de ce calcul, l'enchaînement classique du vtkPolyDataMapper (transformant nos données en polygones) et du vtkActor (acteur à représenter dans la scène) est chaîné à la suite du filtre précédent.
Nous nous sommes cependant heurté à un problème : le résultat affiché était plat, les isolignes étant situées dans le même plan. Cela est dû au fait que nous utilisons un format de données de type "points structurés", contrairement à la majorité des autres binômes. Il faut donc insérer dans la chaîne des filtres un vtkWarpScalar qui changent les coordonnées des points selon un vecteur (ici le vecteur unité en Z) en fonction de la valeur de chaque point. Voici ce que donne le code en TCL :
|
|
|
|
# isolignes
vtkContourFilter msContour
msContour SetInput [reader GetOutput]
msContour GenerateValues 20 2.0 4.0
msContour Update
vtkWarpScalar msWarp
msWarp SetInput [msContour GetOutput]
msWarp SetNormal 0 0 1
msWarp UseNormalOn
msWarp SetScaleFactor 2
msWarp ReleaseDataFlagOn
vtkPolyDataMapper msMapper
msMapper SetInput [msWarp GetOutput]
msMapper SetScalarRange 2.0 4.0
vtkActor msActor
msActor SetMapper msMapper |
|
|
|
|
Calcul et affichage de la surface
Le composant que nous avons utilisé est vtkImageDataGeometryFilter, qui converti des données images (le type de donnée "image" dérive du type "points structurés", cette fonction est indiquée comme remplaçant celle utilisée pour les points structurés dans la documentation de VTK) en une surface, en utilisant la LUT (table de couleurs en fonction de la valeur des points) pour en définir les couleurs.
Comme pour les isolignes, nous devons rajouter un filre vtkWarpScalar afin d'élever la surface en fonction de la valeur des points. Puis nous ajoutons deux filtres permettant d'améliorer la visualisation : vtkSmoothPolyDataFilter et vtkPolyDataNormals, qui calculent les normales et adoucissent la surface. Le suite est classique : le mappper puis l'acteur. Voici ce que cela donne en TCL :
|
|
|
|
# surface
vtkImageDataGeometryFilter Geom
Geom SetInput [reader GetOutput]
Geom ReleaseDataFlagOn
vtkWarpScalar geomWarp
geomWarp SetInput [Geom GetOutput]
geomWarp SetNormal 0 0 1
geomWarp UseNormalOn
geomWarp SetScaleFactor 1
geomWarp ReleaseDataFlagOn
vtkSmoothPolyDataFilter geomSmooth
geomSmooth SetInput [geomWarp GetOutput]
geomSmooth SetNumberOfIterations 20
geomSmooth SetRelaxationFactor 0.01
vtkPolyDataNormals geomNormals
geomNormals SetInput [geomSmooth GetOutput]
geomNormals SetFeatureAngle 60.0
vtkPolyDataMapper geomMapper
geomMapper SetInput [geomNormals GetOutput]
geomMapper SetScalarRange 2.0 4.0
geomMapper SetScalarModeToUsePointData
vtkActor geomActor
geomActor SetMapper geomMapper |
|
|
|
|
|
