Rapport

Document Sample
Rapport Powered By Docstoc
					Filière Informatique
Travail de bachelor INF3gen-i




                          Editeur d’objets 3D
                                 11INF-TB212
                                   Rapport


Etudiant : Lionel Heim

Responsable : Pierre Chatelain

Expert : Jean-Luc Gyger



Date : 08.08.2011
Filière Informatique
Lionel Heim
Résumé

Le projet « Editeur 3D » a pour but de fournir un outil de création d’objets en 3 dimensions qui
peuvent être facilement réutilisés dans d’autres logiciels ou dans une scène 3D qui serait créée de
toute pièce. En choisissant cet éditeur, l’utilisateur peut laisser libre cours à son imagination, il peut,
en effet, aisément déformer les différents objets proposés ou importés. Il y a 7 formes de base
disponibles dans l’application ; ce sont les triangles, cercles, carrés, cubes, sphères, cônes et
cylindres. Ce logiciel peut être utilisé dans le cadre de projets d’infographie réalisés dans l’école. Il a
été conçu de manière à être facilement pris en main. Le format d’exportation est libre, il s’agit des
wavefront.




Summary

The project « Editor 3D » is a tool to make object in 3 dimension that could be use in a other
software or in 3D scene that we can made it from scratch. By using the editor the user can let his
imagination go throw everything while he can modifiy the different form that the software has or
load existing objet. The editor has 7 differents king objet there are triangle, square, circle, cube,
sphere, cone and cylinder. This software will be used in the computer graphics course. This software
is made to be friendly user. The exporting file are the wavefront (obj).




Rapport                                              2                                          08.08.2011
Filière Informatique
Lionel Heim
Table des matières

Résumé .................................................................................................................................................... 2
Summary ................................................................................................................................................. 2
Table des matières .................................................................................................................................. 3
Introduction............................................................................................................................................. 4
   Cahier des charges............................................................................................................................... 4
       Situation initiale............................................................................................................................... 4
       Contraintes ...................................................................................................................................... 4
   Situation après le travail de printemps ............................................................................................... 5
Architecture logicielle.............................................................................................................................. 6
Analyse .................................................................................................................................................... 7
   Vue....................................................................................................................................................... 7
   Model .................................................................................................................................................. 8
Controller............................................................................................................................................... 12
Conception ............................................................................................................................................ 13
   Sérialisation ....................................................................................................................................... 13
   Création des éléments....................................................................................................................... 15
   Déformation ...................................................................................................................................... 26
   Matrice .............................................................................................................................................. 28
   Regroupement................................................................................................................................... 29
   Picking................................................................................................................................................ 30
   Interface (UI) ..................................................................................................................................... 31
   Etude pour les animations................................................................................................................. 33
Bugs connus........................................................................................................................................... 35
Amélioration .......................................................................................................................................... 36
Conclusion ............................................................................................................................................. 37
Annexes ................................................................................................................................................. 38
       Document : .................................................................................................................................... 38
       Liens internet : ............................................................................................................................... 38




Rapport                                                                       3                                                              08.08.2011
Filière Informatique
Lionel Heim
Introduction
Ce document est séparé en plusieurs parties la première consiste à présenter l’architecture de
l’application puis une analyse de la manière dont elle est conçu. Par la suite, la conception avec
l’explication des différentes techniques qui ont été implémentés afin de solutionner les différentes
demandes. Une étude sur la création d’animation est aussi présentée. Pout terminé une conclusion
afin de réalisé une synthèse du travail réalisé.

Ce rapport n’explique pas tous les éléments de l’application, certains points tels que la librairie de
chargement des fichiers obj sont présent dans le rapport du semestre de printemps mis en annexe.



Cahier des charges
Situation initiale
Ce travail est une suite du projet réalisé pendant le semestre de printemps (11ING-TP212).

But du projet
Il s’agit maintenant de réaliser l’éditeur 3D proprement dit.

Démarche proposée
    Analyser la façon dont on veut pouvoir créer, éditer, modifier un objet 3D de n’importe quel
     forme
    Mettre en place l’éditeur pour des formes simples (cubes, sphères, cylindres, cônes)
    On doit pouvoir
          o Créer ces objets
          o Les déformer (déplacer les vertex, en ajouter, en supprimer)
          o Leur appliquer des couleurs, de l’éclairage, des textures
          o Les sauvegarder en format obj
          o Les relire à partir d’un fichier
          o Les combiner entre eux, puis sauvegarder le groupe
    La modification de formes plus complexes peut se faire à partir d’objets créés dans d’autres
     logiciels puis importés.
    Prévoir une animation des différents objets dans la scène, Analyser tout d’abord les outils
     nécessaires pour la réalisation de ces animations (lignes de temps en particulier)
    Si le temps le permet, on développera aussi la création d’objets plus complexes comme, par
     exemple, des formes créées à partir des surfaces de Bézier ou des surfaces NURBS.

Contraintes
On utilisera QT pour le développement et OpenGL pour le graphisme 3D




Rapport                                            4                                        08.08.2011
Filière Informatique
Lionel Heim
Situation après le travail de printemps
A la fin du travail de semestre de printemps, je disposais :

       D’une interface graphique
       Une librairie de lecture et écriture de fichier obj
       Affichage du rendu OpenGL d’une scène importé
       Gestion des matériaux (couleur et texture)

L’application pouvait être qualifiée de bon viewer de fichier obj. Il manquait toute la partie de
création et modification des formes en elles-même.




Rapport                                             5                                        08.08.2011
Filière Informatique
Lionel Heim
Architecture logicielle
Pour début voici un diagramme de classe qui résume l’architecture de l’application.




L’application est divisée en trois grands groupes qui sont le model, la vue et les formulaires.



MainWindow

Cette classes est la fenêtre principale du programme, Elle contient tous les formulaires ainsi que les
interactions avec les différents menus disponibles.



GLWidget

Représente les différentes vues disponible en OpenGL. Elle gère les déplacements de la souri les
différentes interactions avec le clavier. Le picking est aussi intégré à cette classe. Pour pouvoir
appliquer facilement OpenGL cette classe hérite de QGLWidget fourni par QT.



ObjScene

Cette classe est le point d’entré pour la gestion du model de l’application. Elle contient les différents
éléments à afficher permet de les modifier, en supprimer, en ajouter ainsi que de dessiner le rendu.



Formulaires

Les différents formulaires servent principalement à la saisie de donnée pour la création ou l’édition
des différents éléments graphique. Les formulaires sont contenus dans la fenêtre principale à l’aide
de DockWidget (QDockWidget).




Rapport                                             6                                         08.08.2011
Filière Informatique
Lionel Heim
Controller

La classe controller sert principalement d’intermédiaire entre le model et la vue ou les différents
formulaires. Cette classe a été créée afin que les formulaires n’ont pas besoin de connaitre
directement le model afin d’interagir dessus.




Analyse
Cette section va présenter les trois grandes sections présentes dans l’application qui sont la vue, le
model et le controller.

Chacune de ses parties sera détaillée au niveau de ses fonctionnalités et sa structure

Vue
Le programme propose un affichage de rendu à l’aide de 4 vues (face, dessus, droite et perspective).




L’affichage du rendu se réalise à l’aide de différentes projections 3D ou 2D grâce à OpenGL. Toutes
les vues sont sous la forme de widget.

Voici une représentation de la structure mise en place dans l’application.




Une séparation entre les vues 2D et la vue 3D a été réalisée car il y a une différence dans le mode de
projection des éléments à l’écran. La vue 2D est réalisée avec glOrtho pour avoir une projection en
2D pour la vue en 3D cela se réalise avec gluPerspective.

Chaque vue à sa propre manière d’afficher les axes, le nom, les rotations nécessaire afin d’afficher la
scène dans le bon sens ainsi que les diverses actions souri.

Rapport                                            7                                         08.08.2011
Filière Informatique
Lionel Heim
Les mouvements souris pour le déplacement de la scène est propre à chaque vue. Le déplacement de
forme doit être interprété différemment suivant la vue. Par exemple sur la vue de face qui est
représenté par les axes X et Y le déplacement de réalisera uniquement dans ces deux directions.

Toutes les vues 2D ont une fonction de picking implémenté afin de réaliser la sélection d’élément
directement sur l’affichage.

La vue 3D a aussi une gestion des touches claviers pour pouvoir ce déplacement dans la scène. Cela a
été réalisé avec les méthodes proposées par QT.



Model
La structure du model a été revue de celle présente au début du projet suite à diverses modifications
tel que la création de nouvelle forme ou l’édition.




ObjScene est la class principale du model elle contient tous les différents éléments qui constituent la
scène graphique ainsi que tous les différents matériaux. L’appel pour le rendu graphique ce réalise
depuis cette class par exemple.

ObjElement représente chaque élément présent graphique de la scène. Ils peuvent être de deux
types différents soit un élément de type création ou un model.

ObjModel est utilisé pour les fichiers obj importés.

ObjCreation représente toutes les formes que l’on peut réaliser depuis l’application.

Cette différenciation a été réalisée pour avoir un model plus complet ainsi que de pouvoir facilité la
création de nouveau objet.

ObjCreation est redéfini par 7 classes qui sont les différentes formes que l’on peut créer à savoir
carrée, triangle, sphère, cube, cercle, cylindre, cône.

Pour pouvoir réaliser une nouvelle forme (par exemple une étoile) il suffit de redéfinir la class
ObjCreation et de compléter la méthode createGroup qui est appelée lors de la génération de la
forme voulu.




Rapport                                            8                                         08.08.2011
Filière Informatique
Lionel Heim
Comme l’affichage est réalisé depuis le model plusieurs états d’affichage sont présents. Le premier
est un affichage simple de tout le contenu en plein, un deuxième pour afficher le rendu en fils de fer.
Un mixe des deux premier est utilisé pour afficher une sélection. L’élément sélectionné est affiché en
plein alors que le reste de la scène est en fils de fer ou inversement. Une troisième possibilité est lors
que l’on veut afficher les différents points de construction (vertex) qui est utilisé pour la
déformation.




Affichage de la forme sélectionée en fils de fer et le reste de la scène en affichage plein.




Affichage de la forme sélectionnée en affichage plein.




Affichage des points de construction



Un autre system d’états a été mis en place qui celui-ci est pour l’ajout de vertex ou la déformation
qui lui est sous la forme d’un compteur pour connaitre le nombre de vertex déjà sélectionné. Ce
concept sera expliqué dans la section de modification de forme.



Les trois différents types d’affichage sont représentés de la manière suivante :

       AFF_PLEIN
           o Actif par défaut
           o Représente une sélection si l’affichage normal est en mode fil de fer
       AFF_FILSDEFER
           o Représente une sélection si l’affichage normal est en mode plein
       AFF_DEFORMATION
           o Affiche tous les points (vertex)
           o Affiche uniquement l’élément sélectionné

Rapport                                             9                                          08.08.2011
Filière Informatique
Lionel Heim
Structure des données

Par rapport à la version précédente de l’application la structure des données a évolué.
Précédemment il n’y avait pas de notion d’élément et tout était uniquement séparé par des groupes.

Les différentes structures de la version actuelle :

       Material pour la couleur ou les textures.
       Group rassemblement de face ainsi qu’une sélection de matériel.
       Face regroupe les indices de vertex, les normales et les épingles de texture.
       CalcNormal structure utile à la génération de normal.

La structure des sous-groupes n’est plus présente actuellement car elle n’a plus d’utilité. Une autre
différence avec la version précédente est qu’il y a un conteneur de moins les faces sont directement
contenue dans les structures groupes.

Voici une représentation de la structure




Une scène peut contenir plusieurs matériaux ainsi que plusieurs éléments. Un élément est constitué
de 4 conteneurs qui sont une liste de vertex, de normales, d’épingles de texture et des groupes.
Chaque groupe représente une série de face qui seront représenté sur la vue. Le groupe contient lui
le matériel qui constituera la forme. Chaque face est attribuée à un groupe et représente une partie
ou toute la forme que l’on souhaite afficher. Pour rappel une face est une série de vertex qui sont
utilisé de manière à afficher une forme. Les formes sont dessinées à l’aide de la primitive OpenGL
triangle fan.



Classe ObjScene

Comme dit précédemment cette classe est le point d’entré du model elle contient toutes les
descriptions des structures de donnée. Cette classe contient aussi la liste des matériaux dans un
QVector. Les principales fonctions de cette classe sont la communication d’information par exemple
l’ajout d’une nouvelle forme ou la suppression s’effectuent depuis cette classe.

Rapport                                               10                                   08.08.2011
Filière Informatique
Lionel Heim
Pour facilité la gestion des modifications que l’on peut apporter a un élément cette classe contient
un attribut qui liste tous les éléments qui on été sélectionné par l’utilisateur. Cette liste doit être
mise à jour à chaque action que l’on réalise sur la sélection d’objet.

Si par exemple une translation d’un objet est réalisée la classe ObjScene passera les valeurs aux
différents éléments sélectionnés.

Cette classe permet aussi de remplir les différents champs de l’interface telle que la liste d’objet, les
propriétés de transformation (rotation, scale, etc …) ou la liste de matériaux.

La gestion des matériaux ce réalise dans cette classe création, édition, suppression, attribution.



Classe ObjElement

Cette classe représente chaque objet de la scène, elle est de type abstraite elle doit être spécialisée
pour pouvoir être utilisée. Elle contient toutes les valeurs utiles à la construction de l’objet. Pour cela
il y a quatre conteneurs différent à savoir la liste des vertex, des normal, des épingles de texture ainsi
qu’une liste de groupe qui eux représentent le regroupement des vertex afin de créer la forme
désirée. Il y a aussi les différentes valeurs pour les transformations scale, translation et rotation de
l’objet dans l’espace.

Lorsqu’une modification est appliquée elle transmit à cette classe depuis la classe conteneur qui est
ObjScene.

Cette classe contient la fonction d’affiche de l’objet. Elle permet aussi les actions telles que
supprimer un vertex, ajout ou déplacement.



Classe ObjModel

ObjModel représente les fichiers importés c’est classe surcharge la classe ObjElement. Elle ne
contient pas de fonctionnalité supplémentaire. Les conteneurs sont remplis à l’aide la bibliothèque
réalisé lors de la partie précédente du projet.



Classe ObjCreation

Cette classe représente toutes les formes qui peuvent être créée. C’est une classe abstraite. Elle est
redéfinie pour chaque forme proposée dans l’application. Cette classe possède des méthodes pour la
modification des paramètres de génération.




Rapport                                             11                                         08.08.2011
Filière Informatique
Lionel Heim
Classe de création d’objet

ObjCCube, ObjCTriangle, ObjCCarre, ObjCCercle, ObjCSphère, ObjCCone et ObjCCylindre sont des
classes qui permettent de créer les différents éléments elles spécialisent toutes la classe ObjCréation.
Une section plus loin explique les différentes méthodes utilisées pour la réalisation de ces formes.



Conclusion

Avec une structure de ce type on arrive plus facilement à étendre l’application avec l’ajout de
nouvelle forme par exemples. La structure a été faite pour être la plus simple possible.



Controller
La classe controller sert principalement d’élément de communication entre les différentes parties de
l’application et les traitements qui y sont réalisé sont pour la plus part très sommaire afin de gardé
toutes les manipulations de calcul ou autre dans le model.

Une tache particulaire du contrôleur est d’allé cherche des informations dans le model comme par
exemple la liste des matériaux et les envoyés au formulaire prévu à cet effet.

Une autre tâche importante est la création d’objet qui est réalisée dans le controller. Cela est
représenté sous forme d’une fonction qui permet au travers d’un paramètre sélectionné et générer
le bon type d’objet. Pour réalisé cela le patron methode factory a été mis en place.




Rapport                                           12                                        08.08.2011
Filière Informatique
Lionel Heim
Conception
Voici les principaux point de développement qui on été réalisé dans ce travail. Beaucoup d’élément
touche le model directement et d’autre sont des interactions directs depuis la vue sur le model. Il
faut savoir que le développement de cette application a été réalisé pour qu’il respect au mieux le
pattern MVC.



Sérialisation
Le logiciel offre la possibilité de sauvegarder la scène dans l’état voulu sans avoir à réaliser
d’exportation. Pour cela une sérialisation a été mise en place.



Structure de sérialisation :

Matériaux :

   Nombre de matériaux
   Pour chaque matériau :
       o Nom
       o Composante diffuse
       o Composante Ambiante
       o Composante Spéculaire
       o Shininess
       o Indice du matériel
       o Nom de texture
       o Indice texture
       o Présence de texture



Eléments

       Nombre d’élément présent
       Pour chaque élément
           o Son type (triangle, carré, etc …)
           o Le nombre de vertex
           o Pour chaque vertex
                    Les 3 composantes du vertex
           o Le nombre de normal
           o Pour chaque normal
                    Les 3 composantes de la normal
           o Le nombre d’épingle de texture
           o Pour chaque épingle
                    Les 2 composantes de l’épingle
           o Le nombre de groupe


Rapport                                             13                                             08.08.2011
Filière Informatique
Lionel Heim
             o Pour chaque groupe
                      Le nombre de face
                      Pour chaque face
                             Le nombre de sommet de la face
                             Pour chaque sommet
                                  o Les indices des vertex
                                  o Les indices de normal
                                  o Les indices d’épingle de texture
                             La normal à la face
                      Nom du groupe
                      Numéro du groupe
                      Indice de matériel du groupe
      Translation de l’élément
             o X, Y, Z
      Rotation
             o X, Y, Z
      Scale
             o X, Y, Z
      Nom de l’élément



Lors de l’écriture du fichier on réalise une simple lecture de tous les arguments et enregistre sans
traitement particulier.

Lors de la relecture il y a plus de traitement à réaliser car il faut tout réinstancier les objets ainsi que
le remplir. Afin d’avoir les bons objets c’est la raison pour la quelle on sauvegarde son type. Suite a
cela on remplit tous les conteneurs.

Afin de simplifier l’utilisation de texture les images sont directement copiées dans le même
répertoire que le fichier de sortie.




Rapport                                              14                                          08.08.2011
Filière Informatique
Lionel Heim
Création des éléments
La création comporte 7 différentes formes de base, triangle, carré, cercle, cube, cône, sphère et
cylindre. Toutes ces formes sont créées de toutes pièces (vertex, face, épingle de texture) pour
pouvoir répondre à la structure des fichiers OBJ.

La construction se réalise en 2 étapes :

    1. générer les différents points dans l’espace (vertex)
    2. relier les différents points afin de créer les faces

Sur chaque forme il y a la possibilité d’appliquer des textures, pour cela sur chaque forme des
épingles ont été calculé.



Triangle

Le triangle est la forme plus simple à réaliser car il suffit de 3 points et une seule face qui est la
structure minimum dans un fichier OBJ.

Pour la génération des points est une suite de point prédéfinit.




Les trois points ont les coordonnées suivantes :

    -   1 : (-2,0,0)
    -   2 : (2,0,0)
    -   3 : (0,2,0)

Le triangle comporte une seule face pour qui est composé des 3 points




La face est créé de manière à être « counter clock wise » afin qu’elle apparaisse comme une face
avant dans OpenGL.

Exemple de réalisation :




Rapport                                              15                                          08.08.2011
Filière Informatique
Lionel Heim
Si on regarde avec l’affichage des points :




Application d’une texture :




La texture affiché n’est pas affiché en intégralité c’est pour ne pas avoir de déformation. Le principe
est de découper un triangle dans l’image.




Le triangle vert représente ce qui sera affiché comme texture.



Carré

Pour pouvoir réaliser un carré il faut quatre sommets.




Les points ont les coordonnées suivantes :

    -   1 : (-1,0,0)
    -   2 : (1,0,0)
    -   3 : (1,2,0)
    -   4 : (-1,2,0)

Tout comme le triangle le carré sera composé d’une seule face qui contiendra deux triangles.




Rapport                                            16                                        08.08.2011
Filière Informatique
Lionel Heim




Exemple de création :




Affichage des points et des lignes de constructions :




Application d’une texture :




Dans le cas des carrés la texture est appliquée entièrement sur la surface.



Cercle

La création de forme arrondie en Opengl est plus compliquée car il faut la réaliser à l’aide de lignes
droite. De plus la création doit pouvoir être paramétrable en donnant un rayon ainsi qu’un nombre
de facettes.

Les points d’un cercle sont générés dans la manière suivante :




Rapport                                            17                                        08.08.2011
Filière Informatique
Lionel Heim
Le point central est toujours le premier à être généré et il est en position (0,0,0) la suite des points
sont générés grâce à une boucle pour le nombre de face. Ils sont calculés de la manière suivante :

       X = Rayon * Cos(A)
       Y=0
       Z = Rayon * Sin(A)

A varie de 0 a 360 par pas de « 360/nombre de facette souhaité ».

Les points sont reliés par ordre croissant et la forme est représentée par une seule face.




Exemple de création :




Affichage des lignes des constructions et des points




Exemple de texture :




L’application de texture ce réalise d’une texture ce type :




Rapport                                             18                                         08.08.2011
Filière Informatique
Lionel Heim




Le point 1 est épinglé sur le centre du cercle le reste des points sont placés sur le bord du cercle. Pour
avoir des textures non déformé il faut respecter ce format.



Cube

Les cubes sont des formes à volume mais simple il suffit d’avoir 8 points dans l’espace pour pouvoir
les réaliser.




Tout comme le carré et le triangle ce sont des points prédéfini à l’avance.

Le point 1-4 forme un carré en z = 1 et de 5-8 en z = -1.




Le cube est composé de 6 faces une pour chaque coté. Les faces sont de simple carré de cette
manière on peut appliquer un matériel par face.

Exemple de création :




Rapport                                            19                                         08.08.2011
Filière Informatique
Lionel Heim
Ligne de construction et points




Application de différent matériaux sur chaque face




L’ajout de texture ce fait de la même manière que les carrés et il y a la possibilité de le faire sur
chaque face.



Sphère

Les sphères sont les formes les plus complexes le principe est très semblable au cercle mais il y a une
variation en y pour varier la hauteur. La sphère a deux paramètres de création le nombre de face
ainsi que son rayon.

Voici le nuage de point que l’on créer afin d’obtenir une sphère.




Le sommet ainsi que le fond ne sont pas directement calculé. Ils sont en (0,R/2,0) et (0,-R/2,0).

Le reste des points sont calculé de la manière suivante :

       Y = Rayon * Sin(T)
            o X = Rayon * Cos(A)
            o Z = Rayon * Sin(A)

T varie de 0 à 180 (volume) et A varie de 0 a 360 (cercle).


Rapport                                             20                                          08.08.2011
Filière Informatique
Lionel Heim
Pour la création des faces ce sont une multitude de carré qui sont réalisés à l’aide de quatre points.
Chaque point est utilisé quatre fois.




Voici un éxemple de création du ventre de la sphère. Pour pouvoir facilement réaliser cela il suffit de
bien réspecter l’ordre dans lequel on génère les points. Le regroupement pour créer une face ce fait
de la manière suivante :

       Parcours des lignes de la sphère en commencant par la deuxième
       Pour chaque ligne
            o On parcours tous les points
            o A chaque point on créer une face qui est composé des points suivants :
                    Point courrant (A)
                    Point courrant + 1 (B)
                    Point courrant – nombre de face + 1 (C)
                    Point courrant – nombre de face (D)
            o Une face supplémentaire doit être réalisé pour pouvoir compléter le cercle qui relie
               le dernier point du cercle au premier.

Chaque face est créée dans le sens inverse des aiguilles d’une montre.

De cette manière on obtient le ventre de la sphère, le chapeau ainsi que le fond de la shère sont
réalisé de la même manière que le cercle.



Exemple de création :




Rapport                                           21                                        08.08.2011
Filière Informatique
Lionel Heim
Ligne de construction et points




Application de texture




La texture que l’on veut appliquer dois être une texture que l’on peut répéter en horizontal. Lors de
l’ajout de cette texture sur la sphère elle est découpée comme cela :




Le point A représente le sommet de la sphère et le point B le fond de la sphère. Chaque intersection
telle que le point C recouvre le ventre de la sphère.

Les épingles de texture sont mise de la même manière que les points sont reliés à une différence
près. Pour compléter le cercle il ne faut pas reprendre la première épingle (gauche) mais la dernière
à droite.




Rapport                                           22                                       08.08.2011
Filière Informatique
Lionel Heim
Cône

Un cône est une forme géométrique qui est composé de 2 cercles. Ces deux cercles ont un seul point
différent qui est le point central. Cette forme à trois paramètres variables la hauteur, le rayon ainsi
que le nombre de faces.

Les points sont générés de la même manière que pour le cercle :




Au point 1 il y a deux points différents le premier est en (0,0,0) et le second est en (0,H,0).



Exemple de création :




Ligne de construction et point :




Application de texture :




Pour les textures cela fonctionne de la même manière que pour le cercle.

Un cône à deux faces bien distinctes la base et le haut, le programme offre la possibilité de pouvoir
sélectionner un matériel différent pour chacune de ces faces.

Rapport                                             23                                            08.08.2011
Filière Informatique
Lionel Heim
Cylindre

Un cylindre est composé de deux cercles distants dans l’espace ainsi qu’une zone entre les deux.
Tout comme le cône cette forme à trois paramètres variables qui sont la hauteur, le rayon et le
nombre de faces.

La génération de point ce réalise à l’aide de deux cercle un placé en y = 0 et le second en y = hauteur.
Le corps du cylindre est réalisé de la même manière que pour la sphère.

Création du corp




Exemple de création




Ligne de construction et point




Application des textures

Sur le haut et le bas du cylindre les textures sont appliquées de la même manière que pour les
cercles. Sur la face latérale elle est applique de la même manière que sur les carrés.




Rapport                                            24                                        08.08.2011
Filière Informatique
Lionel Heim
Structure

Voici la structure uml qui est implémentée pour la création de forme.




Chaque forme spécialise la class de création. De cette manière l’ajout d’une nouvelle forme peut se
faire facilement. Pour la création d’objet au sens informatique cela ce réalise dans la class contrôleur
avec une méthode factory qui est appelée depuis le formulaire d’ajout d’objet. Une évolution pour ce
faire avec une class qui aurait comme fonction la création d’objet ainsi que le remplissage du
formulaire de création.



Conclusion

La création des différentes formes a été réalisée de manière à être la plus simple possible. Toutes les
formes sont créées de manière à ce que les faces soient construites dans le sens inverse des aiguilles
d’une montre afin de ne pas avoir de problème à la génération des normales. Ces normales sont
créées depuis la fonction prévue à cet effet qui a été réalisé lors de la version précédente du projet.
Avec ces 7 formes la possibilité de création déjà grande. L’ajout de nouvelle forme peut ce réaliser
assez facilement grâce à l’héritage bien qu’il y a d’autre classe à modifier.




Rapport                                           25                                        08.08.2011
Filière Informatique
Lionel Heim
Déformation
Le logiciel offre la possibilité de déformer les différentes formes créées cela se réalise principalement
depuis la vue OpenGL. Il y a trois possibilités de déformation le premier est le déplacement de vertex,
la deuxième est l’ajout de point et la dernière est la suppression d’un point de la forme.



Déplacement de vertex

Le principe est le suivant :

       Sélectionner un élément
       Afficher ces points de construction
       Sélectionner un point et le déplacer




Pour pouvoir réaliser cela il faut changer le mode de fonctionnement du model en passant au type
d’affichage déformation. Suite à cela si un point est sélectionné il apparaitra en bleu à l’écran ce qui
signifie qu’il est sélectionné et peut être déplacé. Le déplacement est transmit depuis la vue openGL
et est représenté par la différence entre le clique de départ de la souri et la position actuel du
curseur. Pour avoir des valeurs correctes l’indice de zoom est pris en compte.



Ajout de vertex

L’ajout de vertex ce fait en 2 parties la première consiste à sélectionner deux points sur la forme déjà
existante. La deuxième partie est la génération d’un troisième point entre les deux sélectionnés.

La manière de réaliser cela est la suivante :

       Création d’une nouvelle face
       Ajout des deux indices sélectionné
       Calcul du troisième point à l’aide des deux premiers points
       Nouveau point :
            o X = (P1.x + P2.x)/2
            o Y = (P1.y + P2.y)/2
            o Z = (P1.z + P2.z)/2
       Un ajout d’épingle de texture est effectué ce sont les même épingle que lors de la création
        d’un triangle.
       Ajout des épingles a la nouvelle face

Rapport                                            26                                        08.08.2011
Filière Informatique
Lionel Heim
      Ajout de la face au groupe ou appartient le premier point sélectionné.




Voici un exemple de d’ajout de point un nouveau triangle apparait.



Suppression de vertex

La suppression de vertex est un mécanisme assez complexe car il y a plusieurs cas possibles. Un
vertex peut appartenir à une ou plusieurs faces de différent groupe. Cela nécessite de réalisé un
parcours complet de tous les éléments d’un objet et de reconstruire les différentes faces en fonction
de la suppression.

La manière mise en place dans l’application est la suivante :

       Parcours de tous les groupes puis sous groupes à la recherche d’une face qui contient le
        vertex
              o Lors que l’on trouve une face on teste si elle a 3 points
              o Si oui
                        On ajoute la face dans une liste de face a supprimé
              o Si non
                        On recréer une nouvelle face avec le point en moins
       Une fois le groupe parcouru on supprime toutes les faces qui ont que 3 points
       Si il y a plus de face présente mais qu’il reste 4 points on recréer une face sans le point qui
        sera supprimé.
       Une fois le parcours de groupe terminé ont supprime le vertex ainsi que ca normal
       On reparcours toutes les faces pour mettre à jour les indices de vertex
              o Si un indice est supérieure à celui supprimé on le décrémente de 1
       Pour terminer on régénère toutes les normales de l’élément



La recréation de face est réalisée de deux manières différentes la première consiste à une recréation
de la même face mais sans le point que l’on veut supprimer la deuxième est utilisé lorsqu’il y a plus
de face présente mais qu’il y a assez de point pour pouvoir en créer une nouvelle.




Rapport                                            27                                         08.08.2011
Filière Informatique
Lionel Heim




Voici un exemple de suppression d’un vertex avec recréation d’une nouvelle face.



Ces différentes actions sont possible grâce a la notion de picking qui est expliqué plus loin dans le
rapport.



Matrice
Du fait que le logiciel permet de réaliser différente transformation de forme tel que des translations,
rotations ou changement de taille (scale). Toutes ces transformations sont des actions OpenGl
(glTranslate, glRotate, glScale) elles n’influencent pas sur les coordonnées des vertex directement
mais sur la position. Un point positionné en (1, 0, 0) qui subit un agrandissement en X de 2 sera
toujours dessiné de la même manière me sera afficher en (2, 0, 0). Cela est dû aux modifications que
subit la matrice model view (GL_MODELVIEW) d’OpenGL.

Pour pouvoir obtenir le même résultat lors d’une exportation de forme il faut appliquer la matrice à
tous les vertex du model. La génération de la matrice ce réalise de la manière suivante :

          glPushMatrix();
          glLoadIdentity();
          // application des transformations
          glTranslatef(translateX,translateY,translateZ);
          glRotatef(rotX,1,0,0);
          glRotatef(rotY,0,1,0);
          glRotatef(rotZ,0,0,1);
          glScalef(scaleX,scaleY,scaleZ);
          // sauvegarde de la matrice
          glGetFloatv(GL_MODELVIEW_MATRIX, matrice);
          glPopMatrix();


Une fois la matrice généré l’application de celle-ci ce réalise de la manière suivante :

    newVec[0]= matrice[0]*vec[0]
             + matrice[4]*vec[1]
             + matrice[8]*vec[2]
             + matrice[12];
    newVec[1]= matrice[1]*vec[0]
             +matrice[5]*vec[1]
             +matrice[9]*vec[2]
             +matrice[13];
    newVec[2]= matrice[2]*vec[0]
             +matrice[6]*vec[1]
             +matrice[10]*vec[2]
             +matrice[14];



Rapport                                            28                                        08.08.2011
Filière Informatique
Lionel Heim


Le nouveau vertex aura les coordonnées réelles après transformation. En réalisant cela il faut
remettre à 0 toutes les valeurs de modifications (translation, rotation, scale).

C’est opération est effectuée pour l’exportation en fichier obj, lors de passage entre différent mode
d’édition d’objet, ainsi que pour le regroupement d’élément.

La source de cette méthode de génération est citée dans les annexes.



Regroupement
Pouvoir combiner des éléments ensemble a été implémenté. Pour cela le principe de créer un nouvel
élément de type model comme si c’était un élément importé. Copier les différents éléments
sélectionnés du model en générant les coordonnées réelles. Tout comme pour la suppression il faut
mettre les indices des faces à jour.

Si l’on veut regrouper un triangle (3 points) et un carré (4 points). L’action se déroule de la manière
suivante :

       Création d’un élément de type model
       Parcours de la liste d’élément
            o Pour chaque élément sélectionné
            o On copie tous les vertex et épingle de texture
            o On copie tous les groupes ainsi que les faces
            o Sur chaque face on met à jour l’indice des vertex
                      Pour chaque indice on addition le nombre de vertex qu’il y avait dans le
                         conteneur avant d’ajouté ceux de l’élément courant.
                      Lors de l’ajout du triangle il y a 0 élément l’addition de chaque élément sera
                         nul
                      Lors de l’ajout du carré il y a 3 vertex inséré dans le conteneur chaque indice
                         de vertex du carré sera augmenté de 3 (le premier sera 3 car les indices
                         commence à 0)
       Génération des normal sur le nouvel élément
       Ajout de l’élément à la liste
       Suppression des éléments qui ont été regroupé



De cette manière il est facile de regroupé des éléments il faut savoir que l’ont ne peut plus régénérer
les éléments tel que les cercles s’ils ont été regroupé.




Rapport                                            29                                        08.08.2011
Filière Informatique
Lionel Heim
Picking
Le mécanisme de picking permet l'interaction de l'utilisateur avec une scène 3D :

       Sélection d'un ou plusieurs objets à l'écran
       On donne un nom à chaque objet, le mécanisme de sélection renvoie la liste des noms

Le mécanisme de feedback permet de récupérer des informations sur ce qui doit être dessiné sur
l'écran.

Pour pouvoir utilisé le picking il faut nommer tous les éléments que l’on dessine à l’écran avec
glName.

Le principe est le suivant :

       On dessine une première fois la scène (dans le cas de l’application c’est un simple updateGL)
       On entre dans le mode de sélection (glRenderMode(GL_SELECT)).
       On créer un « clipping volume » à la position X, Y souhaité (position souri)
       On redessine la scène dans le framebuffer avec toutes les transformations (rotation,
        translation et scale) et on positionne la camera.
       Récupération des hits (collision)
       Lecture du buffer pour savoir qu’elle élément à été touché.



Le picking est une technique simple pour réaliser des sélections en 3D mais il faut être stricte dans la
manière de faire et bien respecter l’ordre des opérations.



La source sur le picking est citée dans les annexes




Rapport                                               30                                     08.08.2011
Filière Informatique
Lionel Heim
Interface (UI)
Dans cette section on parlera uniquement des différentes modifications qui ont été apportées à
l’application. Certain point on déjà été abordé lors de précédent rapport.

Les différentes modifications ce situe principalement au niveau du formulaire d’ajout d’élément et
de la liste d’élément dans la scène.

Ajout d’élément




    1.   Liste d’élément disponible en création
    2.   Option de création d’élément
    3.   Génération de l’élément
    4.   Nom
    5.   Rotation en X
    6.   Rotation en Y
    7.   Rotation en Z
    8.   Facteur de multiplication des scale
    9.   Scale




Voici la liste des éléments que l’on peut générer.




Rapport                                              31                                  08.08.2011
Filière Informatique
Lionel Heim




Les différentes options pour la génération. Comme expliqué précédemment tous les éléments n’ont
pas forcément des valeurs à modifier. Le triangle comme ici n’a aucun champ éditable. Seule la
position est disponible. Un masque de saisie pour chaque formes a été mis en place.



Liste d’objet




Le formulaire de liste d’objet a été revu. Auparavant il utilisait une liste widget afin d’afficher tous les
éléments. La nouvelle structure se base sur un affichage en arbre à l’aide des QTreeView. Cette
structure permet un affichage plus hiérarchique.



Avec ces améliorations l’éditeur est plus complet et son utilisation est simplifié. L’interface a subit
quelques autres modification mineurs tel que l’ajout de bouton sur la barre d’outils affin d’avoir les
raccourcis accessible rapidement.




Rapport                                             32                                          08.08.2011
Filière Informatique
Lionel Heim
Etude pour les animations
Une partie du projet était de réaliser une gestion d’animation. Par faute de temps il n’a pas été
possible de créer cette partie. Mais une petite étude a été réalisée mais n’a pas été implémentée. Le
principe serait de pouvoir réaliser une animation sur chaque objet ou groupe d’objet.

Model

Afin de pouvoir réaliser cela il y aurait une première modification à réalisé au niveau du model. La
structure devrait subir quelque modification. A lieu d’avoir une liste d’élément il faudrait avoir une
structure sous forme d’un arbre. Si on prend l’exemple du système planétaire on obtiendrait cela :




A lieu d’avoir dans une liste comme c’est le cas actuellement.

Chaque nœud serait un objet de type élément qui pourrait être édité comme tout objet la grande
différente serait que lors du regroupement on puisse définir un père et des fils. De plus le formulaire
de liste d’objet permettrait facilement de représenter cela grâce à ca nouvelle structure.

La deuxième étape serait de réaliser une classe animation qui pourrait gérer les différentes actions
que l’on désire.

Cette classe devrait contenir toutes les méthodes utiles afin de réalisé les animations. La classe
animation devrait être associée à chaque élément que l’on créer.

On obtiendrait un diagramme de classe suivant :




Les mouvements proposés seraient rotation, déplacement et changement de taille.

Le principe pour jouer les animations serait que lors de chaque dessin on applique le mouvement
avant de réalisé le rendu.

De cette manière on peut réaliser le schéma des planètes précédent en faisant tourner la lune autour
de la terre qui elle-même tourne autour du soleil tout comme les autres planètes.


Rapport                                            33                                        08.08.2011
Filière Informatique
Lionel Heim
Ligne de temps

Pour pouvoir gérer une ligne de temps il aurait besoin de définir une fréquence d’affichage qui elle
définirait un timer de refresh. Avec cela on peut définir un temps d’animation, si par exemple un
cube doit ce déplacer du point a au point b pendant 10 secondes on peut définir quel sera le pas
d’incrémentation du déplacement.

Si le timer est à 20ms (50fps) et que l’on veut un déplacement de 100u pendant 10 secondes cela
veut dire qu’à chaque itération le déplacement est de 0.2u (100u / 10s * 20ms).

Si l’on veut réaliser un autre type d’animation après le déplacement une rotation pour cela on peut
non pas avoir une animation mais une liste d’animation dans chaque élément qui s’activerais à la
suite (fin de la première, démarrage de la seconde etc).



Types d’animation

Les différents types d’animation pour être premièrement les différentes transformations disponibles
sous OpenGL (translation, rotation et scale). Un deuxième type pourrait être l’apparition d’élément
ou leurs disparitions. Plus complexe a réalisé serais une déformation tel que le déplacement d’un ou
plusieurs vertex uniquement.



Conclusion

Voici une première approche que l’on peut avoir pour générer des animations. Cet ajout peut
représenter de nombreux changements dans l’application surtout au niveau du model. Un autre
élément à ajouter pourrait être de créer un moteur de rendu pour pouvoir visionner la sortie. Cette
sortie pourrait avoir une barre de défilement afin de naviguer rapidement dans le temps.

L’idée de cette manière de faire vient du framework Irrlicht, qui lui a une structure en arbre et offre
une gestion d’animation, le lien est cité dans les annexes.




Rapport                                            34                                        08.08.2011
Filière Informatique
Lionel Heim
Bugs connus

Dans le formulaire d’ajout d’élément lors que l’on veut effectuer un agrandissement il y a la
possibilité de choisir un facture de multiplication. Celui-ci n’est pas remis à jour ou à 1 lorsqu’il a été
modifié.



Si l’on a paramétré la génération d’un élément et que l’on modifie la valeur sans forcément vouloir
l’appliqué il n’y pas possibilité de voir la valeur qu’il y avait précédement. Exemple si l’on créer un
cercle avec 10 faces qu’on le sélectionne et que l’on modifie cette valeur sans validé il n’y pas de
possibilité de revenir en arrière.



Les dernières épingles de texture générées sur la face du cylindre ont un défaut. Le cercle ne se
referme pas complètement.




Rapport                                             35                                          08.08.2011
Filière Informatique
Lionel Heim
Amélioration


Model

Une des premières améliorations serait de modifier le model pour avoir une structure d’arbre et non
plus sous forme de liste. Cette amélioration permettrait de pouvoir, par la suite, ajouter la gestion
des animations.



Animation

Implémenté la gestion des animations tel que décrite précédement.



Bibliothèque

Avoir une série d’objet déjà réalisé ce qui offrirait un apport plus volumineux à la scène que l’on veut
créer. Par exemple avoir des arbres, véhicule, table etc … .



Historique

Offrir la possibilité de réaliser des undo et redo dans l’application. Une solution simple serait de cloné
la scène à chaque changement en gardant un historique des 10 dernières versions.




Rapport                                            36                                         08.08.2011
Filière Informatique
Lionel Heim
Conclusion
Au terme du projet, on peut considérer que tous les objectifs principaux on été réalisé qui sont la
création ainsi que la modification d’objet. Le logiciel a été amputé de la partie animation par faute de
temps. Mais une étude sur ce sujet à été réalisé et me semble de mon point de vue relativement
facile à ajouter.

Tous les éléments développés ont été réalisé de manière à être au plus simple possible. L’ergonomie
du logiciel est satisfaisante elle est assez simple à prendre en main et plus facile à prendre en main
qu’un logiciel tel que Blender. L’application peut facilement acquérir de nouvelle forme grâce à la
structure mise en place pour la création d’objet. Grâce à l’exportation importation on peut
facilement prendre des model des réalisés.

Le développement de certain point a été plus volumineux que prévu tel que la sérialisation, la
génération des épingles et leurs application sur les différentes formes ont été les 2 tâches qui ont
pris du beaucoup de temps.

Pour une personne comme moi qui n’est pas forcément très doué en matière de graphisme un
logiciel de la sorte peut facilement aidé à la conception d’une scène sans trop de problème.




Rapport                                           37                                        08.08.2011
Filière Informatique
Lionel Heim
Annexes

Document :


Rapport semestre printemps

Guide utilisateur



Liens internet :


Génération des matrices de transformation :

http://www.developpez.net/forums/d216913/applications/developpement-2d-3d-jeux/api-
graphiques/opengl/application-matrice-opengl-propre-code/



Picking :

http://devernay.free.fr/cours/opengl/makeslide/selection/overview.htm



IRRLICH :

http://irrlicht.sourceforge.net/

http://www.irrlicht3d.org/wiki/index.php?n=Main.IrrlichtManualChapter2#no2.3



Forge google :

http://code.google.com/p/editeur-3d-gt/




Rapport                                       38                                 08.08.2011

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:9
posted:8/28/2012
language:Unknown
pages:38