readme - Romain

Aztech v1.0, 21 novembre 2006
Auteurs :
– Benoît Bossavit
– Stéphane Romero-Romero
– Romain Vergne
Chargé de TD :
– Pascal Desbarats
Responsable du cours :
– Tamy Boubekeur
Installation
Bibliothèques additionnelles requises :
– QT4 (http ://www.trolltech.com/)
– QGLViewer (http ://artis.imag.fr/ Gilles.Debunne/QGLViewer/)
– Trimesh2 (http ://www.cs.princeton.edu/gfx/proj/trimesh2/)
Recommandations :
– QGLViewer doit être compilé avec QT4
– Trimesh2 n’est pas indispensable pour l’application, il est utilisé seulement
par les plugins de chargement (load) et de sauvegarde (save) de fichiers.
Compilation de l’application principale :
– Modifier le fichier "buildcfg.pro" en y indiquant le chemin vers les bibliothèques citées ci-dessus.
– Se placer à la racine de l’application (répertoire Aztech/)
– Taper les commandes suivantes :
– qmake main.pro
– make
Remarque : le qmake est celui de QT4
Compilation des plugins
– Se placer dans le répertoire Aztech/plugins
– Taper les commandes suivantes :
– qmake plugins.pro
– make
Remarque : pour compiler de cette manière les plugins rajoutés ultérieurement,
il suffit d’ajouter dans le fichier plugins.pro le nom du plugin.
1
Utilisation
Lancement de l’application
– Se placer dans le répertoire Aztech/
– Taper ./aztech
Liste des raccourcis clavier
– Menu Mode
– ’tab’ : passage du mode object au mode d’édition et vice versa
– Menu Manipulation
– ’e’ : extruder des faces
– ’f’ : bouger des faces
– ’v’ : bouger des sommets
– Menu Subdivision
– ’l’ : Loop
– ’b’ : Butterfly
– ’s’ : Sqrt3
– Menu Settings
– ’ctrl+H’ : afficher l’historique
– ’ctrl+S’ : afficher les statistiques
– ’ctrl+F’ : afficher la fréquence de rafraîchissement
– Au niveau des visualiseurs
– ’a’ : afficher les axes
– ’g’ : afficher la grille
– ’h’ : afficher l’aide QGLViewer
Manipulations de la souris (hors plugin)
– ’clic gauche’ : tourner la caméra
– ’clic droit’ : translater la caméra
– ’molette’ : zoomer/dézoomer
– ’shift+clic gauche’ : sélectionner des sommets ou des faces
– ’ctrl+clic gauche’ : désélectionner des sommets ou des faces
– ’clic droit sur la sphère’ : déplacer la lumière
Remarque :
– Il existe beaucoup d’autres raccourcis (voir l’aide QGLViewer)
– Les plugins peuvent prendre la main sur les évenements souris. Par exemple,
pour bouger des points ou extruder des faces on utilisera le clic droit.
Architecture
L’application est structurée en quatre paquetages : GUI, Core, Support et
Plugin. Chacun de ces modules est construit sous forme de bibliothèque dynamique (voir figure ci-dessous).
2
Fig. 1 – Diagramme UML
GUI
L’interface graphique est gérée par la classe MainWidget qui contient 4 visualiseurs (un pour chaque vue bloqué sur un plan et un pour la vue libre en
3D), une zone reservée à l’historique et une autre à l’affichage des statistiques.
A chaque fois que l’utilisateur lance un plugin, son action est enregistrée
dans une structure. A l’aide de cette structure, l’utilisateur peut afficher l’historique, la sauvegarder dans un fichier ou charger un historique préalablement
sauvegardé.
Il peut afficher les statistiques correspondantes aux maillages, c’est à dire le
nombre de sommets et de faces.
L’interface RenderContext permet de changer le type de rendu utilisé pour
la vue libre. Quelqu’uns sont déja implémentés comme le rendu en fil de fer, le
phong shading, ...
L’interface est basée sur un modèle observeur/observé. En effet, MainWidget
contient un observeur qui se charge de remettre à jour toutes les composantes
3
de l’interface lorsque le maillage (observé) est modifié.
Core
Le paquetage Core contient le noyau de l’application, qui suit le protocole de
communication avec les plugins (voir partie correspondante). Cette classe possède le maillage qui est en statique afin de faciliter l’échange avec les plugins. Elle
possède aussi l’historique de toutes les actions effectuées dans le mainWidget.
Support
Le paquetage Support contient le maillage (Mesh) qui est utilisé par tous
les autres modules. Il contient aussi la classe History qui propose une structure
pour stocker les appels des plugins effectués par l’utilisateur.
Remarque : la base de notre maillage est composée seulement des sommets
et des faces, nous ne stockons pas de liste d’arrêtes.
Plugin
Ce paquetage contient tous les plugins chargés par l’application. Il contient
des plugins :
– créant des primitives
– cube
– tetrahèdre
– octahèdre
– sphère
– manipulant le maillage
– moveVertices
– moveFaces
– extrudeFaces
– effectuant des subdivisions
– loop
– butterfly
– sqrt3
– chargeant et sauvegardant des modèles (off, obj, ...)
– load
– save
Fonctionnement des plugins
Au lancement de l’application, tous les plugins présents dans le répertoire
Aztech/plugins sont chargés par un appel à la méthode loadPlugins() du module
Core. La méthode query() de chaque plugin est alors appelée et l’instance de la
structure PluginProperties qu’elle renvoie est stockée dans une table de hachage
indexée par le nom du plugin.
4
La structure PluginProperties contient les champs suivants :
– directory : nom du menu dans la barre de menu de l’application dans
lequel le plugin sera ajouté
– exec_event : évènement déclenchant l’exécution du plugin. Les choix possibles sont :
– ON_MENU_SELECTION
– ON_PRESSED_MOUSE
– ON_MOVED_MOUSE
– ON_RELEASED_MOUSE
– ON_LEFT_MOUSE_CLICK
– ON_RIGHT_MOUSE_CLICK
– ON_MID_MOUSE_CLICK
Remarque : un plugin peut exécuter des actions lors de plusieurs évènements différents. Par exemple, le plugin extrudeFaces crée les nouvelles
faces lors d’un clic souris droit
(ON_PRESSED_MOUSE | ON_RIGHT_MOUSE_CLICK) et change
la position des vertices de ces faces lors du déplacement de la souris
(ON_MOVED_MOUSE)
– exec_selection_mode : mode de sélection dans lequel le plugin peut être
exécuté. Les choix possibles sont :
– ON_EDIT_MODE
– ON_OBJECT_MODE
– shortcut_key : touche de raccourci clavier (cf Liste des raccourcis) permettant d’appeler le plugin (équivalent à sélectionner le plugin dans le
menu)
– args : liste des arguments nécessaires au plugin pour être exécuté (cf l’énumération labels dans le fichier Aztech/core/inc/labels.h pour une liste
exhaustive des paramètres que le plugin peut demander à l’application
principale)
Chaque plugin est ensuite ajouté au menu correspondant (spécifié dans le
champ directory), et son raccourci est également ajouté s’il a été spécifié (champ
shortcut_key)
Au moment de l’exécution d’un plugin (spécifié dans le champ exec_event),
l’application appelle la méthode run() du plugin avec comme paramètres ceux
demandés dans le champ args de la structure PluginProperties)
5
Fig. 2 – De gauche à droite : wire, flat, gouraud, phong, toon et normal shading
Résultats et performances
Comparaisons visuelles
Temps d’exécution
Cette première série de tests a été effectuée sous Linux, avec une machine
disposant d’une carte graphique nVidia GeForce Go 7600, de 1Go de mémoire
vive, et d’un processeur AMD Turion 64 X2 Mobile TL50, 1,6 GHz / 200 MHz :
N˚ iter
1
2
3
4
5
6
7
8
9
10
Sommets
26
98
386
1538
6146
24578
98306
393218
1572866
-
Faces
48
192
768
3072
12288
49152
196608
786432
3145728
-
FPS
> 125
> 125
> 125
> 125
> 125
> 125
94
24
6
-
Loop (s)
0.000148
0.00048
0.002042
0.007214
0.033532
0.145419
0.631621
2.61754
11.645
-
MAJ normales (s)
0.00473
0.004326
0.007024
0.017822
0.06205
0.223248
0.906983
2.28974
12.7065
-
Total (s)
0.004878
0.004806
0.009066
0.025036
0.095582
0.368667
1.5386
4.90729
24.3515
> 10 min
Fig. 4 – Subdivision Loop, effectuée sur la primitive cube, disposant de 8 sommets et 12 faces, avec un rendu de type Phong Shading dans une fenêtre de
590*420 pixels
6
Fig. 3 – Résulats des subdivisions
N˚ iter
1
2
3
4
5
6
7
8
9
10
11
Sommets
26
98
386
1538
6146
24578
98306
393218
1572866
6291458
-
Faces
48
192
768
3072
12288
49152
196608
786432
3145728
12582912
-
FPS
> 125
> 125
> 125
> 125
> 125
> 125
95
25
6
7
0.2
-
Butterfly (s)
0.000149
0.00036
0.001418
0.005736
0.02577
0.107876
0.478345
2.06021
8.81306
43.561
-
MAJ normales (s)
0.002
0.004356
0.006933
0.017343
0.055918
0.20828
0.511059
1.55928
6.15083
27.2584
-
Fig. 5 – Subdivision Butterfly, effectuée sur la primitive cube, disposant de 8
sommets et 12 faces, avec un rendu de type Phong Shading dans une fenêtre de
590*420 pixels
Total (s)
0.002149
0.004716
0.008351
0.023079
0.081688
0.316156
0.989404
3.61949
14.9639
70.8194
> 10 min
N˚ iter
1
2
3
4
5
6
7
8
9
10
11
12
13
Sommets
20
56
164
488
1460
4376
13124
39368
118100
354396
1062884
3188648
-
Faces
36
108
324
972
2916
8748
26244
78732
236196
708588
2125764
6377292
-
FPS
> 125
> 125
> 125
> 125
> 125
> 125
> 125
> 125
60
25
8.5
2.8
-
Sqrt(3) (s)
0.000112
0.00027
0.000702
0.001989
0.006006
0.01975
0.061038
0.18666
0.598279
1.86998
5.56012
17.5798
-
MAJ normales (s)
0.002014
0.002542
0.005545
0.009226
0.019334
0.05683
0.160463
0.48274
1.19116
3.76218
10.3578
30.1413
-
Total (s)
0.002126
0.002812
0.006247
0.011215
0.02534
0.07658
0.221501
0.6694
1.78944
5.63216
15.9179
47.7211
> 10 min
Fig. 6 – Subdivision Sqrt(3), effectuée sur la primitive cube, disposant de 8
sommets et 12 faces, avec un rendu de type Phong Shading dans une fenêtre de
590*420 pixels
On remarque que nos performances sont très bonnes. En moins d’une minute,
nous arrivons à obtenir un maillage (quelle que soit la subdivision) contenant
plus de 1.5 millions de sommets et plus de 3 millions de faces, ceci avec une fréquence de rafraîchissement toujours acceptable, grâce, entre autre, à l’utilisation
des Vertex Arrays d’OpenGL.
Le plus gros maillage est atteint avec la subivision Butterfly, pour laquelle
le nombre de sommets obtenu est supérieur à 6 millions, et le nombre de faces
dépasse 12.5 millions.
Le nombre de normales à mettre à jour est moins grand lors d’une subdivision
Butterfly que pour une subdivision Loop, ce qui explique, en partie, la rapidité
de l’algorithme.
La subdivision Sqrt(3) est rapide mais requiert une grosse mise à jour des
normales du maillage après exécution. Ceci est dû au fait que le nombre de faces
augmente d’un facteur de 3 à chaque fois.
Limites
Cette seconde série de tests montre les limites obtenues avec les primitives
de notre application. Ces tests ont été réalisés avec une carte graphique nVidia
GeForce 6600 GT, 1Go de mémoire vive, et un processeur Intel(R) Pentium(R)
4, 2.80GHz.
8
cube
tetrahedron
octahedron
Sommets
8
4
6
Faces
12
4
8
Fig. 7 – Primitives
cube
tetrahedron
octahedron
N˚ iter
9
10
9
Sommets
1572866
2097154
1048578
Faces
3145728
4194304
2097152
Temps (s)
24.3515
40.2883
16.6064
Fig. 8 – Limites obtenues avec la subdivision Loop
cube
tetrahedron
octahedron
N˚ iter
10
11
10
Sommets
6291458
8338810
4194306
Faces
12582912
16777216
8388608
Temps (s)
70.8194
198.396
41.1287
Fig. 9 – Limites obtenues avec la subdivision Butterfly
cube
tetrahedron
octahedron
N˚ iter
12
13
12
Sommets
3188648
3188648
2125766
Faces
6377292
6377292
4251528
Temps (s)
47.7211
44.9962
28.658
Fig. 10 – Limites obtenues avec la subdivision Sqrt(3)
On remarque que l’on obtient plus de 8 millions de sommets, et plus de 16
millions de faces avec la subdivision Butterfly sur le tetrahedron. Dans toutes
les subdivisions, on obtient facilement 4 millions de sommets et 6 millions de
faces. De plus, nous n’avons pas d’erreurs de segmentation, même en continuant
à subdiviser : cela montre que notre programme est robuste.
Problèmes et extensions
– Problèmes :
– La lumière est difficile à sélectionner lorsqu’on clique avec la souris.
– Les sommets et/ou faces sélectionnés le restent même après l’exécution
d’un plugin ne se servant pas de la sélection.
9
– On ne peut pas sélectionner un trop grand nombre de sommets à la fois
– Les paramètres de la caméra sauvegardés dans l’historique semblent
insuffisants car si l’on bouge la caméra et que l’on charge l’historique,
les résultats ne sont pas forcément ceux escomptés.
– Le plugin exécutant la subdivision Butterfly ne fonctionne que sur des
objets 2-variétés (et lève une erreur dans le cas contraire). Ainsi elle
ne fonctionne pas non plus après extrusion car celle-ci conserve la face
extrudée.
– Extensions :
– Pouvoir charger plusieurs modèles
– Proposer la suppression de faces et de sommets
10