simulation 3d d'un dispositif de fourchette électronique · 2010-04-12 · qu’un squelette...
TRANSCRIPT
École Polytechnique de l’Université de Tours64, Avenue Jean Portalis37200 TOURS, FRANCETél. +33 (0)2 47 36 14 14
www.polytech.univ-tours.fr
Département Informatique5e année
2008 - 2009
Rapport de projet de réalité virtuelle
Simulation 3D d’un dispositif defourchette électronique
EncadrantPierre [email protected] [email protected]ébastien [email protected]
Université François-Rabelais, Tours
ÉtudiantsJonathan Courtois
[email protected] Tazé
DI5 2008 - 2009
Version du 25 mai 2009
Table des matières
1 Introduction 5
2 Présentation du projet 62.1 Le sujet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.2 Etude de l’existant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.3 Outils utilisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3.1 Subversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3 Modélisation sous Blender 83.1 Présentation de Blender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83.2 Importation du dispositif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83.3 Récupération du personnage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.4 Animation du personnage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.5 Exportation vers jMonkey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.5.1 La scène . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.5.2 Les Meshes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.5.3 Les materials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4 Conception architecturale 134.1 Descriptif de la modélisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134.2 Diagramme UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5 Implémentation dans jMonckey 145.1 Présentation de jMonkey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145.2 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.2.1 Librairie OgreLoader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155.2.2 Création de l’univers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155.2.3 Création et Importation de la scène . . . . . . . . . . . . . . . . . . . . . . . . . 165.2.4 Lecture d’une animation définie dans Blender . . . . . . . . . . . . . . . . . . . . 165.2.5 Création de l’animation de rotation . . . . . . . . . . . . . . . . . . . . . . . . . . 175.2.6 Création de l’animation de la fourchette . . . . . . . . . . . . . . . . . . . . . . . 185.2.7 Gestion de la nourriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
6 Conclusion 20
Fourchette électronique III
Table des figures
2.1 Dispositif réalisé sous CATIA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2 Logo de subversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.1 Animation sous Blender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83.2 Représentation du dispositif sous blender après importation . . . . . . . . . . . . . . . . . 93.3 Présente le personnage récupéré sur internet, (a) le modèle (b) l’armature (c) l’armature
associée au modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103.4 Interface de la partie animation sous Blender . . . . . . . . . . . . . . . . . . . . . . . . . 113.5 Présente les interfaces d’exportation sous Blender, (a) ”Ogre Scene Exporter” (b) ”Ogre
Meshes Exporter” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.1 Diagramme de classe du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.1 Logo de JMonkey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145.2 Exemple de jeu réalisé avec JMonkey (1/2) . . . . . . . . . . . . . . . . . . . . . . . . . 145.3 Exemple de jeu réalisé avec JMonkey (2/2) . . . . . . . . . . . . . . . . . . . . . . . . . 15
6.1 Demo de la fourchette électronique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
IV Fourchette électronique
Introduction
Ce document est un rapport de projet de l’option Réalité Virtuelle. Ce projet a été réalisé durant ladernère année de l’école d’Ingénieurs en Informatique de Polytech’Tours par deux étudiants :
• Courtois Jonathan <[email protected]>• Tazé Guillaume <[email protected]>
Ce projet a pour but de représenter en 3D un modèle de fourchette électronique en action. Une fourchetteélectronique permet à une personne handicapé de se nourrir de façon autonome. L’objectif est de réaliserles différentes étapes du repas d’une personne utilisant ce type de dispositif. Ce projet est réalisé avec lelangage de programmation Java grâce au moteur de rendu 3D JMonkey.
Fourchette électronique 5
Présentation du projet
2.1 Le sujet
Certains handicaps nécessitent une assistance pour pouvoir manger à chaque repas. Avec les avancéstechnologiques, il existe dorénavant des dispositifs permettant à ces personnes d’être autonome pour cenourrir. Ce projet a pour objectif de simuler le repas d’une personne handicapé utilisant un dispositif defourchette électronique. La simulation sera composé de l’animation du dispositif de fourchette réalisé aucours d’un précédent projet et de l’animation d’un avatar en train de manger. Le projet sera réalisé en javaet executer à l’aide du moteur de rendu 3D jMonkey.
La simulation doit comporter les étapes suivantes :
1. L’utilisateur prend la fourchette avec la bouche2. L’utilisateur recupére de la nourriture dans l’assiette à l’aide de la fourchette3. L’utilisateur repose la fourchette sur la partie supérieur du dispositif (aimanté)4. L’aimant est actionné et bloque la fourchette5. Le dispositif est mis en rotation de manière à présenté la nourriture face à l’utilisateur6. L’utilisateur mange7. La fourchette revient en position initiale
2.2 Etude de l’existant
Le dispositif de fourchette électronique a été réalisé par des éléves du département productique au coursd’un enseignement de ”Conception Produits Processus”. Le projet s’est porté sur la faisabilité mécaniquedu système avec une étude précise sur les pièces à utilisés, le prix des composants et le fonctionnement mé-canique du dispositif. Un prototype numérique a été réalisé à l’aide du logiciel CATIA (Conception AssistéeTridimensionnelle Interactive Appliquée). A travers cette application, les éléves ont testé les contraintes defaisabilité du dispositif et mis en place une gamme de fabrication. La figure 2.1 présente le dispositif réalisésous CATIA agrementé d’un plateau repas.
2.3 Outils utilisés
Au curs de ce projet en binome nous avons utilisés le logiciel Blender pour toute la partie modélisationet animation 3D, le moteur jMonkey pour le rendu de la scène 3D et subversion qui est un outil de travailcollaboratif. La présentation et l’utilisation de Blender et jMonkey seront détaillées dans les chapitresmodélisation et implémentation. Nous allons donc ici présenté l’outil subversion.
2.3.1 Subversion
Subversion (aussi appelé SVN) est un outil de travail collaboratif permettant de partager des donnéesentres plusieurs utilisateurs. Il permet de gérer plusieurs versions d’un même code ainsi que les conflits et lesfusions de fichiers provenant de différents utilisateurs. Le projet a été lancé en février 2000 par CollabNet
6 Fourchette électronique
Outils utilisés
Figure 2.1 – Dispositif réalisé sous CATIA
et est distribué sous licence Apache et BSD. Subversion se base sur un dépôt unique des données enligne. Nous avons utilisés un dépôt héberger par le site web XP-Dev : http://xp-dev.com/). SVN nécessitel’utilisation d’un client, il en existe un grand nombre. Nous avons choisis d’utiliser tortoiseSVN sur laplateforme Microsoft Windows. La figure 2.2 présente le logo de subversion.
Figure 2.2 – Logo de subversion
Fourchette électronique 7
Modélisation sous Blender
3.1 Présentation de Blender
Blender est un logiciel d’animation 3D libre et gratuit. Il est disponible sur de nombreux systèmesd’exploitation tels que Windows, Mac OS et Linux. Cette application permet entre autre de modéliser desobjets en 3D, de les texturer, de réaliser des armatures dans le but de les animer, etc. Le développementde Blender est sous la responsabilité de la Fondation Blender, une organisation à but non lucratif présidéepar Ton Roosendaal, l’auteur originel du logiciel.
Blender est réalisé en très grande partie en langage C et C++ avec une utilisation de Python pour lesscripts. Il s’agit actuellement du logiciel de référence en 3D libre. La version que nous avons utilisée dansce projet est la 2.48. La figure 3.1 représente l’écran d’accueil du logiciel Blender.
Figure 3.1 – Animation sous Blender
3.2 Importation du dispositif
Le projet existant a été réalisé sous CATIA (Conception Assistée Tridimensionnelle Interactive Appli-quée), un logiciel de conception assistée par ordinateur (CAO). Les fichiers que nous avons donc récupérésétaient uniquement lisibles par ce logiciel étant donné qu’il est propriétaire. Nous avons donc été au dépar-tement mécanique (DM) dans le but d’ouvrir ces fichiers sous CATIA et de tenter de les exporter dans unformat connu par Blender. Le seul format en commun que nous avons trouvé entre les 2 logiciels de 3D estle VRML. Nous avons donc exporté le dispositif assemblé ainsi que quelques éléments de la scène CATIAtels que la chaise, la table et le plateau repas.
L’importation des fichiers VRML sous Blender est une fonctionnalité de base. Cela nous a permisd’obtenir le dispositif et ces différentes couleurs dans le logiciel Blender. Cependant, lors de l’importation,toutes les faces ont été dessinées de façon indépendantes avec chacun leur matériel. Aucun n’objet étaitexploitable directement. Nous nous sommes retrouvés avec des milliers de faces dans le fichier Blender sans
8 Fourchette électronique
Récupération du personnage
pouvoir les identifier à des objets.
Le premier travail a donc été de sélectionner toutes les faces de chaque objet à l’aide d’un outil desélection pour différencier les différentes parties du dispositif. En effet, pour faire tourner l’axe de rotation,la fourchette, les aimants, etc, il n’était pas possible de tout regrouper dans le même objet. Cela a été untravail long et fastidieux par lequel nous avons du passer pour ne pas avoir à remodéliser le dispositif dansson intégralité. Une fois ce travail terminé, nous avons obtenu l’assemblage complet de plusieurs objetsreprésentant le dispositif de la fourchette comme nous pouvons le voir sur la figure 3.2.
Figure 3.2 – Représentation du dispositif sous blender après importation
3.3 Récupération du personnage
La modélisation d’un personnage étant très longue, nous avons préféré nous concentrer sur l’animationde la scène 3D et chercher un personnage déjà réalisé sur internet. Nous avons trouvé un modèle sur le sitehttp://www.katorlegaz.com/3d_models/ qui proposait un homme en costume déjà armaturé. Cela signifiequ’un squelette d’os était déjà réalisé sur tout le corps et que le modèle était lié à cette armature. Enbougeant ainsi les os du modèle, la texture du corps suit le mouvement. Cependant, aucune contrainten’était réalisée sur les jointures entre les os. Il peut donc être réalisé des animations qui ne sont humainementpas possibles comme tourner la tête de 360ř. Ce travail est également très difficile et long à mettre enplace et n’était pas d’une utilité très important vu le peu de mouvement que nous allions faire faire à notrepersonnage. Nous avons décidé de ne pas réaliser cette étape supplémentaire par manque de temps. Lafigure 3.3 présente le modèle du personnage (a), son armature (b) et l’armature associée au modèle (c).
3.4 Animation du personnage
Pour pouvoire réaliser la scène 3D d’un personnage handicapé entrain de manger de façon autonomeen utilisant notre dispositif de fourchette électronique, il a fallu animer notre personnage. Pour l’animersous Blender, nous avons déjà défini une scène qui contient tous les éléments avec lesquels il va intéragir.
Fourchette électronique 9
Chapitre 3. Modélisation sous Blender
(a) (b) (c)
Figure 3.3 – Présente le personnage récupéré sur internet, (a) le modèle (b) l’armature (c) l’armatureassociée au modèle
La chaise sur laquelle il est assis, la table où est posé le dispositif et la plateau repas à une certaine hauteuret la fourchette qu’il va placer dans sa bouche.
Une fois l’ensemble de ces éléments mis en place, nous avons d’abord assis le personnage sur la chaiseavec les 2 mains posées sur les cuisses. Il s’agira par la suite de notre position de départ ou position d’at-tente. Il a ensuite été réalisé les différentes animations du personnage grâce à l’interface de action éditor.La figure 3.4 présente l’interface de l’étape d’animation sous Blender.
Les 3 animations réalisées sont les suivantes :
1. Position d’attente
2. Prend la fourchette dans la bouche, récupère de la nourriture et replace la fourchette sur le dispositif
3. Mange la nourriture qui se trouve sur la fourchette aimantée par le dispositif.
3.5 Exportation vers jMonkey
Pour pouvoir utiliser les objets réalisés et animés à l’aide de Blender dans jMonkey, nous avons duprocéder à une étape d’exportation. Cette étape s’est réalisée avec les script python ”Ogre Scene Exporter”et ”Ogre Meshes Exporter”. La figure 3.5 présente les 2 exporteurs utilisés avec à gauche l’exporteur descène et à droite l”exporteur de mesh.
10 Fourchette électronique
Exportation vers jMonkey
Figure 3.4 – Interface de la partie animation sous Blender
3.5.1 La scène
Le fichier .scene est un fichier XML chargé dans jMonkey comportant l’ensemble des objets de la scène,leurs positions, leurs orientations, leurs dimensions et également le .mesh associé. Ce fichier est obtenu àpartir d’une scène Blender et permet de définir la scène entière sous jMonkey. Il est cependant possible demodifier ce fichier pour déplacer des objets à l’initialisation de la scène. Le code suivant est un extrait dufichier .scene. Un node correspond en faire à un objet .mesh dans la scène.
<node name="Fourchette"><position x="-1.001177" y="7.655997" z="-0.791490"/><quaternion x="-0.497282" y="-0.485483" z="-0.506318" w="0.510548"/><scale x="0.032578" y="0.032578" z="0.032578"/><entity name="Fourchette" meshFile="Fourchette.mesh"/>
</node>
3.5.2 Les Meshes
Le fichier .mesh.xml utilisé dans jMonkey est créé à partir du script d’exportation de Ogre à partir deBlender. Il s’agit d’un fichier encodé qui contient toutes les informations sur l’objet ainsi qu’une corres-pondance avec les materials utilisés. Ce fichier peut être accompagné d’un .skeleton portant le même nomque l’objet lorsqu’une armature est liée à cet élément et qu’un certain nombre d’animations ont été misesen place. C’est le cas de notre personnage. Ces .mesh sont ensuite référencés dans le fichier .scene qui estchargé dans le code de jMonkey.
Fourchette électronique 11
Chapitre 3. Modélisation sous Blender
(a) (b)
Figure 3.5 – Présente les interfaces d’exportation sous Blender, (a) ”Ogre Scene Exporter” (b) ”OgreMeshes Exporter”
3.5.3 Les materials
Les materials sont exportés dans le même script que les .mesh. Une association est faite entre les faceset les materials dans ce fichier. Un material respecte la structure de code suivante pour définir une couleursur une face. Une lumière ambiante, diffuse, spéculaire et émissive dans notre cas. Nous aurions pu ajouterà nos modèles un certain nombre de textures, mais l’exportation est délicate et le temps ne nous a paspermis de s’attarder sur ce détail.
material Fourchette{
receive_shadows ontechnique{
pass{
ambient 0.500000 0.500000 0.500000 1.000000diffuse 0.655686 0.655686 0.800000 1.000000specular 0.500000 0.500000 0.500000 1.000000 12.500000emissive 0.000000 0.000000 0.000000 1.000000
}}
}
12 Fourchette électronique
Conception architecturale
4.1 Descriptif de la modélisation
Etant donné qu’une grande partie du projet était réalisée dans la partie de modélisation des modèles,la modélisation objet quant à elle est réduite à quatre grandes classes :
• DemoFourchette : c’est la classe principale du projet (le point de lancement de l’application). Cetteclasse hérite de la classe SimpleGame de JMonkey.• Scene : c’est la classe qui va importer la scène modélisée sous blender.• Animation : c’est la classe qui va gérer l’enchainement des différentes animations pour générer uneanimation fluide et cohérente.• Assiette : cette classe représente l’assiette et contient des aliments qui vont êtes au fur et à mesuremangés par le personnnage.
4.2 Diagramme UML
Figure 4.1 – Diagramme de classe du projet
Fourchette électronique 13
Implémentation dans jMonckey
5.1 Présentation de jMonkey
JMonkey est un moteur de jeu 3D développé en Java et utilisable en Java.
Figure 5.1 – Logo de JMonkey
La représentation d’une scène au sein de celui-ci se fait par un graphe de scène. Un graphe de scèneest une structure permettant d’organiser les objets par dépendance parent-enfant. Cela permet de gagneren rapidité d’affichage notamment au niveau de la phase de culling (d’élimination des objets non visibles).
Figure 5.2 – Exemple de jeu réalisé avec JMonkey (1/2)
14 Fourchette électronique
Implémentation
Figure 5.3 – Exemple de jeu réalisé avec JMonkey (2/2)
5.2 Implémentation
5.2.1 Librairie OgreLoader
Une librairie permettant d’importer des fichiers dans JMonkey qui étaient à l’origine destinés au moteurOgre existe. Elle se nomme OgreLoader. Il peut exister plusieurs versions de cette librarie sur internet. Celleque nous utilisons est celle compilée à partir du dépôt svn de son créateur : http://radakan.googlecode.com/svn/trunk/ogreloader.
Nous avons eu un problème concernant cette librairie car les animations définies dans Blender généraientune exception lorsque l’on les lançait. Nous avons donc regardé le code source de cette librairie et trouvéle bug correspondant. Après l’avoir corrigé, nous avons donc utilisé notre propre version de cette librairie.
5.2.2 Création de l’univers
Au lancement de l’application, la classe DemoFourchette va créer automatiquement une fenêtre derendu et créer un comportement par défaut au travers de sa classe mère SimpleGame. Ce comportementne nous plaisant pas, on le redéfinit dans la fonction redefinedInputKey() :
pr i va te void r e d e f i n e d I n pu tKe y ( ) {// S u p r e s s i o n des r e l a t i o n Key <−> Command dé j à en p l a c eKeyBindingManager . getKeyBindingManager ( ) . remove ( " fo rwa rd " ) ;KeyBindingManager . getKeyBindingManager ( ) . remove ( " backward " ) ;KeyBindingManager . getKeyBindingManager ( ) . remove ( " s t r a f e L e f t " ) ;KeyBindingManager . getKeyBindingManager ( ) . remove ( " s t r a f e R i g h t " ) ;KeyBindingManager . getKeyBindingManager ( ) . remove ( " e levateDown " ) ;KeyBindingManager . getKeyBindingManager ( ) . remove ( " e l e va t eUp " ) ;KeyBindingManager . getKeyBindingManager ( ) . remove ( " t u r nR i gh t " ) ;
Fourchette électronique 15
Chapitre 5. Implémentation dans jMonckey
KeyBindingManager . getKeyBindingManager ( ) . remove ( " t u r n L e f t " ) ;
// Mise en p l a c e des n o t r e sKeyBindingManager . getKeyBindingManager ( ) . s e t ( " f o rwa rd " , KeyInput .KEY_Z) ;KeyBindingManager . getKeyBindingManager ( ) . s e t ( " backward " , Key Input .KEY_S) ;KeyBindingManager . getKeyBindingManager ( ) . s e t ( " s t r a f e L e f t " , KeyInput .KEY_Q) ;KeyBindingManager . getKeyBindingManager ( ) . s e t ( " s t r a f e R i g h t " , KeyInput .KEY_D) ;
}
5.2.3 Création et Importation de la scène
Une fois l’application créée, on va créer et importer notre scène à partir des fichiers exportés de Blender.Pour cela on utilise la classe SceneLoader de la librairie OgreLoader :
// I n i t i a l i s e l e chemin pour l e s t e x t u r e sResou rceLoca to rToo l . addResou rceLoca to r ( Resou rceLoca to rToo l .TYPE_TEXTURE,
new S imp l eRe sou r c eLoca to r (DemoFourchette . c l a s s . g e tC l a s s Load e r ( ) . g e tRe sou r ce ( " f o u r c h e t t e / data /" ) ) ) ;
// I n i t i a l i s e l e chemin pour l e s modelsResou rceLoca to rToo l . addResou rceLoca to r ( Resou rceLoca to rToo l .TYPE_MODEL,
new S imp l eRe sou r c eLoca to r (DemoFourchette . c l a s s . g e tC l a s s Load e r ( ) . g e tRe sou r ce ( " f o u r c h e t t e / data /" ) ) ) ;
// Crée r un o b j e t pour c h a r g e r l a s cèneSceneLoader s cene = new SceneLoader ( ) ;// D é f i n i l e chemin de l a s céneURL sceneURL = DemoFourchette . c l a s s . g e tC l a s s Load e r ( )
. g e tRe sou r ce ( " f o u r c h e t t e / data / f o u r c h e t t e . s c ene " ) ;// Charge l a s cénes cene . l oad ( sceneURL . openStream ( ) ) ;// Récupére l e noeud de l a s cénesceneNode = (Node ) scene . ge tScene ( ) ;// Récupère l e s d i f f é r e n t s noeuds dont on va a v o i r b e s o i n pour l ’ an imat i onnodePersonnage = (Node ) sceneNode . g e tCh i l d ( " PersonnageDotNode " ) ;nodeFourche t t e = (Node ) sceneNode . g e tCh i l d ( " FourchetteDotNode " ) ;nodeObjetCyan = (Node ) sceneNode . g e tCh i l d ( "ObjetCyanDotNode " ) ;nodeOb j e tV io l e tFonce = (Node ) sceneNode . g e tCh i l d ( " ObjetV io le tFonceDotNode " ) ;n o d eA s s i e t t e = (Node ) sceneNode . g e tCh i l d ( " GrandeAss i e t teDotNode " ) ;// On c r é e r l ’ a s s i e t t ea s s i e t t e = new A s s i e t t e ( t h i s ) ;
Le SceneLoader va donc lire les fichiers XML exportés depuis Blender et va charger tous les modèleset animations s’y trouvant.
5.2.4 Lecture d’une animation définie dans Blender
Pour lire une animation créée dans Blender, il faut récupérer un contrôleur qui est attaché au noeudde l’entité possédant cette animation. Par exemple pour le personnage on veut récupérer le contrôleur deses animations :
16 Fourchette électronique
Implémentation
c o n t r o l l e r = ( MeshAn imat i onCont ro l l e r ) s cene . ge tPe r sonnage ( ) . g e tCh i l d ( " Personnage " ) . g e t C o n t r o l l e r ( 0 ) ;
Une fois ce contrôleur récupéré, on peut lancer une animation avec une seule ligne :
c o n t r o l l e r . s e tAn imat i on ( " p r e n d r eNou r r i t u r e " ) ;
5.2.5 Création de l’animation de rotation
Toutes les animations n’ont pas été définies dans Blender, notamment l’animation de rotation du méca-nisme. Pour définir cette rotation, nous utilisons la classe SpatialTransformation qui permet de définir pourun ensemble d’objets différentes KeyFrame (images clefs) en donnant la position, l’orientation et l’échellede chaque objet à cette image. Les KeyFrames sont gérées par unité de temps (en seconde). On va doncdéfinir une animation pour tourner les trois objets suivants : la fourchette, et les deux parties du support.
t ou rne rVe r sPe r s onnage = new Spa t i a lT r a n s f o rme r ( 3 ) ;t o u r n e r V e r s E x t e r i e u r = new Spa t i a lT r a n s f o rme r ( 3 ) ;// Fou r che t t et ou rne rVe r sPe r s onnage . s e tOb j e c t ( s cene . g e tFou r ch e t t e ( ) , 0 , −1);t ou rne rVe r sPe r s onnage . s e tRo t a t i o n (0 , 0 , new Quate rn ion (
new f l o a t [ ] { ( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;t ou rne rVe r sPe r s onnage . s e tRo t a t i o n (0 , 1 , new Quate rn ion (
new f l o a t [ ] { ( f l o a t ) Math . PI / 2 f , 0 , ( f l o a t ) Math . PI } ) ) ;t ou rne rVe r sPe r s onnage . s e tRo t a t i o n (0 , 2 , new Quate rn ion (
new f l o a t [ ] { ( f l o a t ) Math . PI / 2 f , ( f l o a t ) −Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;t o u r n e r V e r s E x t e r i e u r . s e tOb j e c t ( s cene . g e tFou r ch e t t e ( ) , 0 , −1);t o u r n e r V e r s E x t e r i e u r . s e tRo t a t i o n (0 , 0 , new Quate rn ion (
new f l o a t [ ] { ( f l o a t ) Math . PI / 2 f , ( f l o a t ) −Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;t o u r n e r V e r s E x t e r i e u r . s e tRo t a t i o n (0 , 1 , new Quate rn ion (
new f l o a t [ ] { ( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI , ( f l o a t ) Math . PI } ) ) ;t o u r n e r V e r s E x t e r i e u r . s e tRo t a t i o n (0 , 2 , new Quate rn ion (
new f l o a t [ ] { ( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;// Objet Cyant ou rne rVe r sPe r s onnage . s e tOb j e c t ( s cene . getObjectCyan ( ) , 1 , −1);t ou rne rVe r sPe r s onnage . s e tRo t a t i o n (1 , 0 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) −Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;t ou rne rVe r sPe r s onnage . s e tRo t a t i o n (1 , 1 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI , ( f l o a t ) Math . PI } ) ) ;t ou rne rVe r sPe r s onnage . s e tRo t a t i o n (1 , 2 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;t o u r n e r V e r s E x t e r i e u r . s e tOb j e c t ( s cene . getObjectCyan ( ) , 1 , −1);t o u r n e r V e r s E x t e r i e u r . s e tRo t a t i o n (1 , 0 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;t o u r n e r V e r s E x t e r i e u r . s e tRo t a t i o n (1 , 1 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , 0 , ( f l o a t ) Math . PI } ) ) ;t o u r n e r V e r s E x t e r i e u r . s e tRo t a t i o n (1 , 2 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) −Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;// Objet V i o l e t Foncét ou rne rVe r sPe r s onnage . s e tOb j e c t ( s cene . g e tOb j e tV i o l e t Fon c e ( ) , 2 , −1);t ou rne rVe r sPe r s onnage . s e tRo t a t i o n (2 , 0 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) −Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;t ou rne rVe r sPe r s onnage . s e tRo t a t i o n (2 , 1 , new Quate rn ion (
Fourchette électronique 17
Chapitre 5. Implémentation dans jMonckey
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI , ( f l o a t ) Math . PI } ) ) ;t ou rne rVe r sPe r s onnage . s e tRo t a t i o n (2 , 2 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;t o u r n e r V e r s E x t e r i e u r . s e tOb j e c t ( s cene . g e tOb j e tV i o l e t Fon c e ( ) , 2 , −1);t o u r n e r V e r s E x t e r i e u r . s e tRo t a t i o n (2 , 0 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;t o u r n e r V e r s E x t e r i e u r . s e tRo t a t i o n (2 , 1 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , 0 , ( f l o a t ) Math . PI } ) ) ;t o u r n e r V e r s E x t e r i e u r . s e tRo t a t i o n (2 , 2 , new Quate rn ion (
new f l o a t [ ]{−( f l o a t ) Math . PI / 2 f , ( f l o a t ) −Math . PI / 2 f , ( f l o a t ) Math . PI } ) ) ;
// d é f i n i t i o n des p r o p r i é t é s de l ’ an imat i ont ou rne rVe r sPe r s onnage . setNewAnimationTimes (0 , 2 ) ;t ou rne rVe r sPe r s onnage . i n t e r p o l a t eM i s s i n g ( ) ;t ou rne rVe r sPe r s onnage . setRepeatType ( Spa t i a lT r a n s f o rme r .RT_CLAMP) ;t o u r n e r V e r s E x t e r i e u r . setNewAnimationTimes (0 , 2 ) ;t o u r n e r V e r s E x t e r i e u r . i n t e r p o l a t eM i s s i n g ( ) ;t o u r n e r V e r s E x t e r i e u r . se tRepeatType ( Spa t i a lT r a n s f o rme r .RT_CLAMP) ;
On définit alors chaque point de passage avec ici juste des coefficients de rotations à trois temps dis-tincts séparés d’une seconde chacun. On définit enfin l’intervalle de temps de l’animation, on indique àl’animation que l’on désire une interpolation entre chaque KeyFrame et que l’animation ne sera pas répétéemais restera dans son état final (SpatialTransformer.RT_CLAMP).
Pour lancer l’animation par la suite, il faut l’attacher à un noeud du graphe pour qu’il se mette à jouret effectue son travail.
// On remet l ’ an imat i on à 0an imat i on . setCurTime ( 0 ) ;// On l ’ a j o u t e au noeud de l a s cène pour qu ’ e l l e s e mette à j o u rs cene . getSceneNode ( ) . a d dCon t r o l l e r ( an imat i on ) ;
5.2.6 Création de l’animation de la fourchette
La fourchette n’ayant pas d’animation prédéfinie, il a fallu faire en sorte qu’elle suive l’animation dupersonnage lorsqu’il la prend dans la bouche et qu’il va chercher de la nourriture avec.
Pour réaliser ceci, il a fallu extraire un Bone du personnage (une armature), représentant le milieu dela bouche du personnage et se nommant "Lip upper center". Grâce à ce noeud, on peut lui attacher lenoeud de la fourchette, et alors la fourchette va donc effectuer le même mouvement que ce Bone. Voici lamarche à suivre :
// On r é c u p è r e l e bone de l a bouchebouche = c o n t r o l l e r . getBone ( " l i p upper c e n t e r " ) ;// On a t t a ch e l e noeud du bone au mondes cene . ge tPer sonnage ( ) . a t t a c hCh i l d ( bouche . getAttachmentsNode ( ) ) ;
On remarque que le noeud du bone n’est pas attaché par défaut au monde. En fait c’est un noeud necomportant aucun élément mais permettant de simplifier la tâche des utilisateurs car il va subir les mêmestransformations que le bone.
// On détache l a f o u r c h e t t e du monde
18 Fourchette électronique
Implémentation
s cene . getSceneNode ( ) . d e t a chCh i l d ( s cene . g e tFou r c h e t t e ( ) ) ;// On l ’ a t t a ch e au noeud du bonebouche . getAttachmentsNode ( ) . a t t a c hCh i l d ( s cene . g e tFou r ch e t t e ( ) ) ;// On sauvega rde l a p o s i t i o n de l a f o u r c h e t t epo sFou r che t t e = scene . g e tFou r ch e t t e ( ) . g e t L o c a l T r a n s l a t i o n ( ) . c l o n e ( ) ;o r Fou r c h e t t e = scene . g e tFou r ch e t t e ( ) . g e t L o c a lRo t a t i o n ( ) . c l o n e ( ) ;// On f i x e l a n o u v e l l e p o s i t i o n par r a p p o r t au bones cene . g e tFou r ch e t t e ( ) . s e t L o c a l T r a n s l a t i o n (0 , 0 . 4 f , 0 .05 f ) ;s c ene . g e tFou r ch e t t e ( ) . s e t L o c a l R o t a t i o n (
new Quate rn ion (new f l o a t [ ] { ( f l o a t ) Math . PI , 0 , ( f l o a t ) Math . PI / 2 f } ) ) ;
Une fois ces opérations effectuées, la fourchette va suivre l’animation du bone définie dans Blender. Ilfaut bien sûr effectuer les opérations inverses lorsque le personnage va reposer la fourchette sur le dispositif.
5.2.7 Gestion de la nourriture
La nourriture est gérée par la classe Assiette. A sa création, elle va créer plusieurs centaines de petitsaliments (brocolis par exemple) et les disposer sur l’assiette (grâce au noeud Assiette du graphe). Lorsquele personnage va descendre sa fourchette dans l’assiette, un aliment tiré aléatoirement va alors s’accrocherà cette fourchette. Cet aliment est donc retiré du noeud de l’assiette et ajouté au noeud de la fourchette :
// on p ique un b r o c o l i s de l ’ a s s i e t t eb r o c o l i s = scene . g e t A s s i e t t e ( ) . getRandomBroco l i s ( ) ;// on l ’ a j o u t e au noeud de l a f o u r c h e t t es cene . g e tFou r ch e t t e ( ) . a t t a c hCh i l d ( b r o c o l i s ) ;// on l e p o s i t i o n n eb r o c o l i s . s e t L o c a l T r a n s l a t i o n (15 , 0 , 0 ) ;b r o c o l i s . s e t L o c a l S c a l e ( 0 . 25 f ) ;
Fourchette électronique 19
Conclusion
Au travers de ce projet nous avons appris à utiliser un graphe de scène en Java grâce au moteur derendu JMonkey.
Nous avons appris à modéliser tous les éléments d’une scène sous Blender et à les importer dans ce moteur.
Nous avons aussi appris à réaliser des animations de squelette sous Blender ainsi que des animations d’ob-jets sous JMonkey.
La figure 6.1 est une capture d’écran de la scène 3D réaliser au cours de ce projet.
Figure 6.1 – Demo de la fourchette électronique
20 Fourchette électronique
Simulation 3D d’un dispositif defourchette électronique
Département Informatique5e année
2008 - 2009
Rapport de projet de réalité virtuelle
Résumé : Ce document est un rapport de projet de l’option Réalité Virtuelle de dernière année d’étudeà l’école d’Ingénieurs en Informatique de Polytech’Tours. Ce projet a pour but de représenter une scèneen 3D comprenant une fourchette électronique permettant à une personnage handicapée de se nourrir defaçon autonome.
Mots clefs : 3D, Réalité Virtuelle, Projet, Fourchette Electronique, Handicap, Nourriture, Se Nourrir
Abstract: This document is a report about a project of Virtual Reality from the last year of the engi-neering school in computer science at Polytech’Tours. This project is about the visualisation of a 3D sceneincluding an electronic fork wich permits for a disabled person to eat food alone.
Keywords: 3D, Virtual Realitv, Project, Electronic Fork, Disabled, Food, To Eat
EncadrantPierre [email protected] [email protected]ébastien [email protected]
Université François-Rabelais, Tours
ÉtudiantsJonathan Courtois
[email protected] Tazé
DI5 2008 - 2009