RAPPORT PROJET TUTORE 3

INTERFACE GRAPHIQUE POUR SUIVI DE

CAGE THORACIQUE SUR IMAGE DE RAYON
X

Marie ROUSSELET – Pierre GAUTSCH – Flavien DELIENNE Année 2016-2017

Table des matières
Introduction ........................................................................................................................................... 3
Partie 1 : Présentation du projet ........................................................................................................ 4
A- Contexte ..................................................................................................................................... 4
B- Etat de l’art ................................................................................................................................... 5
C- Scénario d’application .................................................................................................................. 7
Partie 2 : Conception .............................................................................................................................. 8
A- Diagramme UML ............................................................................................................................ 8
B – Cahier des charges........................................................................................................................ 9
C – Répartition des tâches ................................................................................................................ 10
Partie 3 : Installation ............................................................................................................................ 10
A- Linux ......................................................................................................................................... 10
B) Windows ...................................................................................................................................... 12
Partie 4 : Méthode ............................................................................................................................... 13
A- Etude du code existant ................................................................................................................ 13
B- Création de l’interface ................................................................................................................. 14
C- Mise en place et animations des objets ....................................................................................... 15
D- Outils collaboratifs utilisés............................................................................................................ 16
Partie 5 : Résultats ............................................................................................................................... 17
A- Résultat obtenu ........................................................................................................................... 17
B- Remarques ................................................................................................................................... 22
C- Autres fonctions possibles ........................................................................................................... 22
Conclusion ............................................................................................................................................ 22
Annexes ................................................................................................................................................ 24
A– Cahier des charges ...................................................................................................................... 24
A- Introduction .................................................................................................................................. 26
1- Contexte ................................................................................................................................... 26
2- Historique ................................................................................................................................. 26
1- Les objectifs .............................................................................................................................. 27
2- Produit du projet ...................................................................................................................... 27
3- Les fonctions du produit ........................................................................................................... 27
4- Critères d’acceptabilité et de réception .................................................................................... 28
B- Contraintes ................................................................................................................................... 28

Page 1 sur 34
 1- Contraintes de coûts ................................................................................................................. 28
2- Contraintes de délais ................................................................................................................ 28
3- Autres contraintes .................................................................................................................... 28
C- Déroulement du projet ................................................................................................................. 29
1- Planification .............................................................................................................................. 29
2- Ressources ................................................................................................................................ 29
B- Résumé en anglais........................................................................................................................ 30
Introduction ......................................................................................................................................... 30
A- Presentation of the project .......................................................................................................... 30
1.Context ...................................................................................................................................... 30
2.Applications ............................................................................................................................... 30
3.Distribution of roles................................................................................................................... 31
B- Installation ................................................................................................................................... 31
1.Linux .......................................................................................................................................... 31
2.Windows ................................................................................................................................... 31
C- Implementation ........................................................................................................................... 31
1.Working atmosphere ................................................................................................................. 31
2.Program ..................................................................................................................................... 32
Conclusion .......................................................................................................................................... 32
Sources sur l’état de l’art.................................................................................................................. 34

Page 2 sur 34
Introduction
L’objectif de notre projet est de présenter une modélisation de cage thoracique réalisée grâce à la
réalité augmentée. La réalité augmentée permet de traduire la réalité du monde de tous les jours en
ajoutant un modèle virtuel 2D ou 3D en temps réel. Ses applications sont nombreuses, notamment
dans l'éducation, la culture, l’apprentissage de la médecine, archéologie, la géolocalisation,
l’architecture, le E-commerce, la publicité, l’industrie, la police, le cinéma, les jeux vidéo et les parcs
d’attraction. En d’autres termes la réalité augmentée a totalement envahi notre vie quotidienne.
Prenons un exemple concret avec Google traduction.

Exemple de traduction en réalité augmentée

Comme nous pouvons le constater sur cette image, nous avons une application de réalité augmentée
car grâce à votre smartphone, vous pouvez voir la réalité ainsi qu’un élément virtuel qui est dans ce
cas la traduction en temps réel.

Dans le cadre de notre projet, nous réaliserons une interface destinée à l'apprentissage de la
médecine, en effet cette modélisation permet d’avoir une vue des organes interne en 3D. Cela permet
aux chirurgiens et futurs chirurgiens de prévoir une stratégie lors des opérations et quels problèmes
cela peut occasionner ou bien de pouvoir tester plusieurs techniques avant de le réaliser en
intervention.

Pour cela nous avons utilisé Polar qui est une bibliothèque, qui permet l'intégration 2D/3D ainsi que la
gestion des mouvements physiques de la cage thoracique et la gestion de scène. Cependant Polar
dépend de Qt qui est une interface de programmation applicative orientée objet et d’OpenSceneGraph
qui est un moteur 3D open source.
Les principales difficultés reposent sur la perspective, avec la projection de la forme et de la lumière.

Page 3 sur 34
Partie 1 : Présentation du projet
A- Contexte

Ce projet basé sur la réalité augmentée s’inscrit dans un enjeu technologique qui s’étend de manière
exponentielle dans notre société. En effet cette technologie représente un grand enjeu durant les
années à venir étant donné qu’à terme, la réalité augmentée fera partie de notre vie quotidienne.
En 2020 le marché de la réalité augmentée devrait atteindre 120 milliards de dollars contre 30 milliards
pour la réalité virtuelle (cf graphique ci-dessous). Cette différence s’explique par les domaines
d’application de ces deux technologies. La réalité augmentée n’a pas de limite, si ce n’est le réel alors
que la réalité virtuelle consiste à immerger l’utilisateur dans un monde totalement fictif, qui n’est
appliqué que pour les joueurs dans le cas présent.

Un tel engouement s’explique par le potentiel de développement possible. La réalité

augmentée peut être utilisé par des particuliers tout comme des professionnels, c’est pourquoi
les fabricants tentent de se démarquer en proposant une solution idéale qui pourra guider les
différents acteurs.

Page 4 sur 34
B- Etat de l’art

La réalité augmentée présente de nombreux avantages et des applications presque illimitées. L’intérêt
de cette technologie est de permettre à l’utilisateur de se déplacer et d’avoir en toute circonstance
une assistance numérique.
Les domaines d’application concernent l’ensemble de nos tâches quotidiennes. Cela peut vous
permettre de vous orienter en ville en affichant les rues à suivre, ou encore vous faire voyager dans le
temps en affichant les monuments historiques comme ils étaient autrefois, vous assistez dans une
réparation mécanique en affichant le manuel de réparation, traduire en temps réel le texte visé, vous
assistez afin de voir les constellations ou bien dans le cadre d’enseignement, à partir d’une feuille vous
pouvez visualiser l’objet. Voici quelque exemple ci-dessous :

Visualisation 3D à partir d'une feuille

Cependant, même si une fois plus développée et démocratisée la réalité augmentée ferait partie de
notre quotidien, l’application qui aurait le plus d’impact concerne le marketing.
Le fait de baser la promotion des produits via la réalité augmentée engendrerait une modification du
comportement des consommateurs.
Tout d’abord la marque pourrait d’avantage être vue en organisant des opérations marketing dans la
rue. Cela créerait une surprise pour l’utilisateur et comme c’est encore peu utilisé cela attirerait
rapidement les foules. En 2014 Pepsi a réalisé une opération de ce genre. Un écran avait remplacé une
paroi de bus, et une caméra filmait la rue de l’autre côté. Les usagers avaient l’impression de voir
directement au travers de la paroi de plexiglass ce qu’il se passait dans la rue, puis des objets animés
en 3D apparaissaient, ce qui a bien évidement créé la surprise de tous.

Page 5 sur 34
 Exemple de la campagne de pub Pepsi 2004

Cela a attiré différents passants et a été relayé sur les réseaux sociaux, ce qui a permet à Pepsi de se
démarquer de ces concurrents et de faire mémoriser sa marque qui était affichée de l’autre côté du
panneau.
Un système similaire peut être mis en place sur la devanture d’un magasin, en filmant les passants.
Lorsque l’individu verra son visage à l’écran, de manière scénarisée, et sera tout de suite plus
intéressée d’entrer dans ce magasin, plutôt qu’un autre.
Puis une fois à l’intérieur, le consommateur pourra être guidé pour trouver le produit recherché, grâce
à la géolocalisation et un plan 3D du magasin. Cela augmenterait la satisfaction du client, ce que toute
entreprise recherche.
De plus, cela pourrait aller encore plus loin en proposant des démonstrations du produit, ses
déclinaisons et des produits similaires. En plus d’augmenter la satisfaction du client, cela lui permettra
de personnaliser son produit en choisissant le modèle et la couleur lui correspondant, dans la limite
des déclinaisons existantes.
Nous bénéficions également de la réalité augmentée chez soi. Prenons l’exemple de la marque RayBan.
Le fabricant a créé sur son site une application qui permet aux clients de modifier ses montures en
fonction des courbes de son visage, la webcam devient alors son miroir.
Page 6 sur 34
Pour toutes ces raisons, l’utilisation de la réalité augmentée changerait totalement le fonctionnement
de notre quotidien comme nous venons de le voir dans l’exemple du marketing.
Cependant des dérives pourraient avoir lieu car les entreprises traitent des données à caractères
personnels. Pour rester conforme à la loi, les entreprises devront remplir les formalités imposées par
la CNIL et informer ses utilisateurs de la collecte de ces données.
Et rappelons que le ciblage marketing doit respecter le règlement (UE) 2016/679 du Parlement
européen et du Conseil du 27 avril 2016.

C- Scénario d’application

Dans notre cas, nous allons nous intéresser à l’application de l’informatique dans le domaine médical
dans un but de visualisation 3D, d’enseignement et de simulation.
Cette application est particulièrement destinée aux médecins afin de visualiser les procédures à
appliquer durant une opération, par exemple, ou bien afin de poser un diagnostic. De plus, cela est
parfaitement adapté pour les étudiants en médecine.
Ce projet est basé sur la réalité augmentée car nous partons d’un cas concret avec des rayons X pour
modéliser par-dessus une cage thoracique en 3D.
Le but de ce projet est d’obtenir une application qui permettra une visualisation 3D de côtes qui seront
paramétrées pour obtenir la réplique virtuelle d’une cage thoracique humaine.

Description de l’utilisation du logiciel

Au démarrage du logiciel, l’utilisateur va importer un maillage de côtes (issus d’un scanner) et des
rayons X (radio).
Une interface est disponible à gauche de l’image. L’utilisateur aura alors la possibilité de choisir le
numéro de côte souhaité ainsi que du côté droit ou du côté gauche, grâce à menu déroulant proposant
tous les objets disponibles.
Ensuite afin de pouvoir superposer les côtes du modèle 3D sur le maillage de rayon X, l’utilisateur aura
alors 2 sliders, un pour chaque angle.
Le premier angle permet de bouger la côte suivant un angle de pompe à bras, c'est-à-dire vers le haut
ou vers le bas tout en étant attaché à la colonne vertébrale. Le 2ème angle permet de bouger la côte
suivant un angle d’anse de seau, c'est-à-dire élargir ou resserrer la cage thoracique.
Une fois l’initialisation terminée, l’utilisateur aura alors le maillage des côtes en 3D ainsi que les rayons
X en arrière-plan.
Prenons une utilisation concrète de l’interface, pour une biopsie du foie.
Le chirurgien pourra alors déterminer à l’avance comment placer ses outils pour pouvoir passer au
travers des côtes pour ensuite atteindre le foie.

Page 7 sur 34
Partie 2 : Conception

A- Diagramme UML

Pour mener ce projet nous avons pensé les

diagrammes UML suivant :
Diagramme de classe :

Page 8 sur 34
Use-case :

B – Cahier des charges

Nous avons ensuite construit un cahier des charges répondant aux fonctionnalités demandées par
notre commanditaire. Dans notre cas, notre commanditaire est notre tuteur.
Le cahier des charges est un document de plusieurs pages. Il est disponible dans les annexes.
Pour résumer en quelques lignes, les buts qui ressort dans notre cahier des charges sont luis suivantes :
 Superposer une cage thoracique 3D sur une radio à rayon X
 Créer une interface Homme-Machine
 S’adapter face à des outils et un langage encore inconnus
 Gagner de l’expérience en gestion de projet

Page 9 sur 34
C – Répartition des tâches

Comme nous pouvons le constater une grande partie de notre temps a été alloué à l’installation et
familiarisation de PoLAR ainsi que du langage C++.

Et comme ces outils nous étaient inconnus, nous avons aussi prévu une part conséquente pour la
réalisation de l’interface et des fonctions reliant les interactions de l’interface avec le modèle 3D. Cela
s’explique une nouvelle fois par notre manque d’expérience avec ces outils ce qui nous rend plus lents
qu’avec des outils familiers.

Partie 3 : Installation
A- Linux

L’installation de la bibliothèque PoLAR est relativement plus simple sous Linux. Dans notre cas nous
utiliserons Ubuntu 16.04.
Dans un premier temps, il faudra installer ses dépendances.

Page 10 sur 34
Pour cela, il faut ouvrir un terminal et entrer “apt-get install” suivi du nom du paquet et ce pour chaque
paquet nécessaire à l’installation.

Pour installer Qt, il y aura 7 paquets qui sont :

 qt5-default
 qttools5-dev-tools
 libqt5opengl5-dev
 qtmultimedia5-dev
 libqt5multimedia5-plugins
 qtdeclarative5-dev
 libqt5svg5-dev

Pour installer OpenSceneGraph nous aurons besoin des paquets :

 openscenegraph
 libopenscenegraph-dev

Pour installer OpenGL nous aurons besoins des 4 paquets :

 freeglut3
 freeglut3-dev
 libxmu-dev
 libxi-dev

Pour les fonctionnalités multimédia nous utiliserons gstreamer que nous installerons avec les paquets
suivants :
 libgstreamer0.10-0
 libgstreamer0.10-dev
 gstreamer-tools
 gstreamer0.10-plugins-good
 gnome-media

Et pour finir pour générer la documentation Doxygen nous utiliserons les paquets :
 doxygen
 graphviz

Une fois que nous avons toutes ces dépendances, il faut télécharger la bibliothèque PoLAR grâce à la
commande suivante :
 git clone https://scm.gforge.inria.fr/anonscm/git/polar/polar.git

Page 11 sur 34
Cependant nous pouvons également le télécharger sur le site PoLAR.inria dans la rubrique Download,
où une version compressée est disponible. Cela revient au même que d’entrer la commande git clone.

A ce niveau, l’installation de PoLAR est effectuée. On peut donc vérifier son fonctionnement en testant
quelques exemples.

Pour ce faire il faut se rendre dans le dossier polar, puis dans le dossier Examples où il se trouve un
fichier README.txt.
On y trouve des lignes de commande à entrer dans le terminal qui lancera l’exemple.

Voici un exemple : bin/testpick ../Examples/data/example1.ppm

../Examples/data/example1.proj ../Examples/data/armchair.ob

B) Windows

Sous windows l’installation est plus complexe. Comme précédemment nous allons installer toutes les
dépendances et télécharger la bibliothèque PoLAR.

Dans un premier temps, il faut installer Qt. Pour cela, il faut se rendre sur le site officiel de Qt disponible
à l’adresse suivante : https://www.qt.io puis de télécharger et d'exécuter le fichier.

Ensuite pour l'installation d’OpenSceneGraph, nous allons donc utiliser le logiciel CMake et Visual
Studio car son compilateur nous sera nécessaire.
CMake va nous permettre de “précompiler” le projet et va le créer dans Visual Studio. Les fichiers
seront alors créés dans le répertoire PoLAR.

Sous Linux il n’y a pas de problème majeur, l’installation se passe sans encombre. Cependant il peut
arriver d’installer des packages complémentaires qui sont proposés par l'invité de commande.

Sous Windows, les problèmes sont un peu plus nombreux. En effet lors de la compilation avec CMake
il ne reconnaissait pas les fichiers de PoLAR nécessaires pour compiler.
Pour résoudre ce problème, il a fallu copier les fichiers .dll et les copier dans le répertoire courant.
La dernière difficulté venait de l’utilisation de Visual Studio, qui nous était encore inconnue.

Page 12 sur 34
Partie 4 : Méthode
A- Etude du code existant

Pour mener à bien ce projet, nous avons créé un nouveau projet sous le dossier PoLAR, cependant,
lors de la compilation nos fichiers n’étaient pas reconnus.
Nous avons donc dû changer de méthode.

Dans le dossier PoLAR nous avons tout un dossier “Example” qui nous ont d’ailleurs servi à vérifier la
bonne installation de PoLAR comme expliqué précédemment.

Nous avons donc fait le choix de modifier les fichiers de l’exemple testpick étant donné que c’était
l’exemple le plus proche de notre but. Il disposait d’une interface et d’une image sur lequel étaient
ajoutés des objets 3D.

Résultat de testpick

Au départ nous avons réalisé quelques modifications sur cette interface pour découvrir le
fonctionnement du C++ et de l’utilisation de la bibliothèque.

Page 13 sur 34
En effet, nous n’avions aucune connaissance avec ce langage, Qt, OpenSceneGraph et PoLAR. Il nous
a donc fallu un temps assez important afin de comprendre le fonctionnement de tous ces éléments,
que ce soit pour l’installation, la compilation, comprendre comment était écrit le code, qu’elles étaient
ces fonctions, comment appliquer des actions aux objets, etc.

Ce fût en quelque sorte une phase de découverte pour voir le comportement des différents éléments
de l’interface en fonction des modifications que nous avons apportés.

B- Création de l’interface

Par la suite, après nous être familiarisés avec le C++, et l’API nous avons réalisé notre propre interface
exposée ci-dessous :

Image de l'interface

Cette interface dispose d’un menu déroulant qui permet à l’utilisateur de sélectionner un objet en
particulier, ce peut être la colonne vertébrale, les poumons, ou bien une côte en particulier qui sont
tous numérotés suivis de L ou R pour différencier les côtes à gauche ou à droite.

Une fois l’objet sélectionné, l’utilisateur dispose de 2 sliders qui lui permettent de bouger l’objet sous
2 angles différents que nous avons nommé « anse de seau » et « pompe à bras ». Dans le cas où une
côte est sélectionnée nous pouvons la faire pivoter suivant un axe horizontal et vertical.
L’interface dispose également de 3 checkbox.

Page 14 sur 34
La première « visible » permet de rendre visible ou non l’élément sélectionné. Cela a pour intérêt de
ne pas surcharger l’image et de se concentrer sur une côte en particulier sans que les poumons gênent
la vue par exemple.

La deuxième « mesh » permet de modifier la texture de l’élément sélectionné. On passe alors d’un
objet 3D à un maillage, qui permet de voir à travers et d’avoir tout de même la position et l’espace
qu’occupe l’objet sans que cela ne gêne la vue pour avoir une vue intégrale avec tous les éléments en
place.

La troisième et dernière checkbox « colorier en rouge » permet de colorer l’élément sélectionner pour
avoir un suivie particulier de l’élément voulu.

C- Mise en place et animations des objets

Pour ajouter des objets, nous avons repris le code existant en remplaçant les objets existants par les
nôtres. Pour cela nous avons dû les ajouter un par un, comme le montre l’exemple ci-dessus.
On peut voir que nous donnons le chemin d’accès à l’objet qui est contenu dans data, puis dans le
répertoire « ribs » qui contient toutes les côtes, puis nous donnons le nom du fichier. Ici ce sera
ribL2.stl qui correspond à la côte 3 gauche.

Si ce fichier n’existe pas nous avons un message d’erreur qui est « Unable to load model ».
Sinon dans le cas où tout se passe bien la côte est ajoutée. Sa position est déterminée par un script en
python qui se trouve dans le répertoire data sous le nom « translateMeshtoOrigin2.py ».
S’ajoute à cela la matrice de projection qui se trouve également dans le répertoire « data ». Cette
matrice positionne l’ensemble de la cage thoracique dans l’espace pour que sa position est l’air réel
comparé à l’image réel.
Une fois les objets ajoutés il faut ajouter les fonctions qui vont permettre d’animer les objets en
fonction des sliders « angle 1 » et « angle 2 » sur lesquelles l’utilisateur va interagir.

Page 15 sur 34
Pour cela on utilise la ligne de code suivant : viewer -> getObject3D (index).
Cela permet de sélectionner l’objet puis on applique les fonctions pour mettre en fonction les
modifications. Par exemple on utilise « mesh » pour rendre visible ou non l’objet sélectionné.

D- Outils collaboratifs utilisés

Pour les travaux de groupe, il existe une difficulté en plus. En effet il faut s’assurer de disposer de la
dernière mise à jour des documents, au risque d’avoir des problèmes de version et que 2 membres
travaillent sur la même chose en parallèle.
Pour faciliter la transmission des informations au sein du groupe et ainsi éviter ce genre de problèmes
nous avons utilisé plusieurs outils collaboratifs.

Dans un premier temps, pour tous les documents texte, notamment pour la création d’un scénario
utilisateur, la rédaction du cahier des charges, le rapport etc.
Nous avons utilisé Google drive, ainsi chacun d’entre nous a eu la possibilité de travailler à son rythme,
il n’y avait pas de problème de version étant donné qu’il était mis à jour instantanément, nous avions
donc la même chose à tout moment. De plus il dispose d’un suivi des modifications, ce qui permet de
ne manquer aucune information ajoutée ou modifiée.

Pour le code, nous avons utilisé GitHub qui est un service web d'hébergement et de gestion de
développement de logiciels.
Le problème premier avec le code, c’est qu’on arrive rapidement à une multitude de version qui est
multipliée par le nombre de personne travaillant dessous. Il faut donc un outils collaboratif efficace
pour que nous puissions nous transmettre le code, régulièrement avec les modifications apportées
sans que cela ne prenne trop de temps.

GitHub répond à toute ces attentes car nous avons créé un repository privé, pour que seul les
collaborateurs puissent y accéder et apporter des modifications.

Pour commencer il faut que l’on travaille sur le même dossier, pour cela, il faut entrer la commande
git clone <lienDuDépotGit> dans notre cas la commande était la suivante :
git clone https://github.com/PierreGautsch/Examples .

Ensuite sur cet espace de dépôt nous avons la possibilité d’envoyer le code modifier à l’aide des
commandes git commit -m <nomDuCommit> et de la commande git push et les autres membres du
groupe ont juste à entrer la commande git pull pour le récupérer.

Cet outil est très intéressant et utile car nous pouvons continuer de travailler sur un code déjà modifié
en tenant compte du travail des autres membres.

Page 16 sur 34
Il est bon de savoir que GitHub propose des services payant, notamment pour la création de repository
privé, mais il est gratuit pour les étudiants. Pour cela il faut demander le pack étudiant sur leur site,
pour le justifier il faut s’inscrire avec notre adresse mail étudiante pour bénéficier de tous leurs services
gratuitement.

Partie 5 : Résultats
A- Résultat obtenu

Tout d’abord il faut choisir l’objet sur lequel nous allons appliquer les modifications.
Cela se fait grâce au menu suivant :

Ce menu propose tous les objets disponibles, nous avons les

poumons et la colonne vertébrale en premier puis la liste des
côtes qui sont toute numéroté en fonction de leurs positions
10 correspondant à la plus haute et la 3 à la plus basse.

Menu déroulant

Après avoir sélectionné l’objet on lui applique la modification.

Une des fonctions premières consiste à déplacer une côte en lui appliquant une rotation.
Pour cela on modifie les sliders angles 1 et angles 2.

Au départ, la côte 6L est sélectionnée et colorée en rouge pour bien la visualiser.

Page 17 sur 34
Puis après avoir modifier les sliders des angles voici le résultat :

Page 18 sur 34
On peut constater que la côte colorée a bien été modifiée selon les angles 1 et 2.

Ensuite nous pouvons rendre l’objet visible ou non en décochant la check box « visible ». Dans ce cas
pour que ce soit bien visible, nous enlèverons les poumons.

Au départ :

Page 19 sur 34
Résultat après modification :

Ensuite nous pouvons changer la texture de l’objet, tout en restant sur l’exemple des poumons nous
cochons la checkbox « mesh ».
Résultat :

On constate bien que la texture à

changer en maillage.

Page 20 sur 34
La dernière fonctionnalité consiste à colorer l’objet en rouge.
Résultat :

Lorsque nous décochons les cases « mesh » et « colorer en rouge » l’image revient comme elle était
au départ.

En dehors des fonctionnalités présentées ci-dessus, l’utilisateur peut modifier la position de l’ensemble
de la cage thoracique à l’aide de la souris comme ceci :

Page 21 sur 34
B- Remarques

Les avantages de cette interface est qu’elle est assez simple car tous les éléments se trouvent au même
endroit sans pour autant la surcharger.
Chaque élément sur l’interface est nommé de manière suffisamment explicite pour identifier ses
fonctions.
Le point négatif vient du fait que l’interface ne répond pas correctement lorsque l’on lance le
programme sous une Virtual box de Linux. Cela provient des drivers ou de la carte graphique. On ne
peut pas le changer à notre niveau. Cependant cela fonctionne correctement sous dual boot.
Il faut tout de même souligner que ce n’est qu’un aspect esthétique puisque tous les éléments
fonctionnent normalement.

C- Autres fonctions possibles

Notre projet remplit ses fonctions premières mais avec davantage de temps il peut être perfectible.
En effet, nous pourrions ajouter d’autres fonctionnalités, comme ajouter une simulation de la
respiration ou ajouter d’autres organes comme le foie, le cœur, etc.

Pour finir nous pouvons ajouter un slider de temps, qui permettrait de contrôler l’animation de la
respiration.
Dans un premier temps on remplacerait l’image fixe par une vidéo de rayon X qui montre la respiration
de l’individu.

Puis en dessous des boutons existant pourrait se trouver un bouton “beginning” et “end”. Ces boutons
serviraient à initialiser la position des côtes 3D avec les côtes provenant de la vidéo de rayon X. Sur la
vidéo de rayon nous aurions la position des côtes au début et à la fin de la vidéo, donc en superposant
le modèle 3D à ces moments précis nous pourrions réaliser une interpolation et simuler la respiration
avec les objets 3D.

Conclusion
Pour conclure, ce projet est très intéressant car cela nous a permis de sortir de notre zone de confort
en découvrant un nouveau langage, et en utilisant une bibliothèque qui nous était également
inconnue.
Cela nous a conduit à développer notre adaptabilité et à nous familiariser avec de nouveaux outils.

Page 22 sur 34
Savoir se servir de PoLAR est intéressant dans l’imagerie, étant donné que la réalité augmentée est en
pleine expansion.

Si c’était à refaire, nous le referions, car nous serions plus rapides, et plus précis. De ce fait nous
pourrions non seulement remplir les fonctions de base du produit mais également ajouter des
fonctionnalités secondaires sans pour autant être hors délai.

Page 23 sur 34
Annexes
A– Cahier des charges

Cahier des charges

Cage thoracique

Page 24 sur 34
Table des matières
A- Introduction ................................................................................................................................. 26
1- Contexte ................................................................................................................................... 26
2- Historique ................................................................................................................................. 26
B- Description de la demande........................................................................................................... 27
1- Les objectifs .............................................................................................................................. 27
2- Produit du projet ...................................................................................................................... 27
3- Les fonctions du produit ........................................................................................................... 27
4- Critères d’acceptabilité et de réception ................................................................................... 28
C- Contraintes ................................................................................................................................... 28
1- Contraintes de coûts ................................................................................................................ 28
2- Contraintes de délais ................................................................................................................ 28
3- Autres contrainte ............................................................................... Erreur ! Signet non défini.
D- Déroulement du projet................................................................................................................. 29
1- Planification .............................................................................................................................. 29
2- Ressources ................................................................................................................................ 29

Page 25 sur 34
 A- Introduction
1- Contexte

Ce projet s’inscrit dans un enjeu considérable.

De nos jours on constate une augmentation de l’informatique dans le domaine médical avec le
développement de ce qu’on appelle désormais l’E-médecine ou encore télémédecine. Cette pratique
consiste à suivre les patients où qu’ils soient, grâce à Internet sans nécessité une visite physique
notamment via des visioconférences. Cette technique tend à se perfectionner afin de toucher autant
de public possible afin d’améliorer la qualité du service du service de santé publique et une diminution
des coûts.

De plus ce procédé est particulièrement intéressant pour les pays disposant de trop peu
d’infrastructures médicales.

Dans notre cas, nous allons nous intéresser à l’application de l’informatique dans le domaine médical
dans un but de visualisation 3D, d’enseignement et de simulation.

Cette application est particulièrement destinée aux médecins afin de visualiser les procédures à
appliquer durant une opération, par exemple, ou bien afin de poser un diagnostic. De plus, cela est
parfaitement adapté pour les étudiants en médecine.

Ce projet est basé sur la réalité augmentée car nous partons d’un cas concret avec des rayons X pour
modéliser par-dessus une cage thoracique en 3D.

2- Historique

La réalité augmentée existe déjà depuis plus de 40 ans. Cependant à l’époque, les moyens techniques
étaient bien trop limités pour parler de réalité augmentée. Ce terme est apparu en 1996 par Jun
Rekimoto, via des marqueurs 2D qui permettent une visualisation d’objet virtuel. Cette technologie
sera reprise en 1999 par Hirokazu Kato et Mark Bilinghurst, en développant une plateforme en logiciel
libre. AR Toolkit servira et sert toujours de base à la réalisation d’application de réalité augmentée.

En 1997, la première application en extérieur apparait, cependant il faut transporter un ordinateur

dans un sac à dos.

Cependant la réalité augmentée telle que nous la connaissons n’est apparue qu’en 2003 sur les
smartphones.

Page 26 sur 34
Aujourd’hui cette technologie touche l’intégralité du grand public avec, notamment, des applications
de localisation, de traduction, ou bien de jeux, comme avec PokemonGo qui est le dernier exemple en
date.

B- Description de la demande
1- Les objectifs

Le but de ce projet est d’obtenir une application qui permettra une visualisation 3D de côtes qui seront
paramétrées pour obtenir la réplique virtuelle d’une cage thoracique humaine.

Pour cela nous allons réaliser une IHM qui servira au paramétrage des côtes pour que celles-ci soient
identiques et superposables à celles des rayons X fournies.

Nous réaliserons également une affiche, ainsi qu’un résumé en anglais et 2 diagrammes UML.
Pour finir nous fournirons un rapport écrit et présenterons notre projet durant une soutenance devant
un jury et un public.

2- Produit du projet

Le produit se composera d’une IHM avec l’affichage des côtes qui doit permettre une rotation de la
cage thoracique, un déplacement des côtes (ensembles ou séparées) et elles devront être animées
d’un mouvement de respiration.
Le produit se composera d’une IHM avec l’affichage des côtes, d’une affiche, d’un rapport et d’un
résumé en anglais.

3- Les fonctions du produit

Le logiciel doit charger un maillage de côtes qui servira de base pour initialiser la position des organes
3D et des côtes à partir d’une vidéo de rayons X d’un patient afin d’avoir la position de chaque côte
durant sa respiration.
Ensuite l’utilisateur devra initialiser les paramètres en superposant le modèle 3D aux rayons X, pour
cela il devra choisir le numéro de côte souhaiter pour ensuite modifier l’angle suivant une pompe à
bras ou une anse de seau.
Ensuite, une fois l’initialisation terminée, les rayons X reste en arrière-plan. Ainsi, si nous prenons le
cas d’un chirurgien qui doit déterminer avant l’opération où placer ses outils entre les côtes, il aura
alors l’impact sur le modèle 3D qu’il pourra reporter sur les rayons X.

L’affiche doit traduire l’objet de notre projet. Et le résumé en anglais doit permettre à quiconque de
pouvoir comprendre l’intérêt et les fonctions de notre projet.

Page 27 sur 34
 4- Critères d’acceptabilité et de réception

Nous avons 2 critères afin de constater si les objectifs de performance sont atteints. L’interface doit
pouvoir être maintenue, ou encore ajouter de nouvelles fonctionnalités sans trop modifier le code
existant.

B- Contraintes
1- Contraintes de coûts

Pour ce projet les coûts sont nuls car il s’agit de livrer une IHM, ainsi qu’un rapport et une affiche sur
une cage thoracique dans le cadre de ce projet.

2- Contraintes de délais

Nous avons débuté l’installation de PoLAR début septembre. Par la suite nous avons eu X rencontres
chaque semaine avec notre tuteur afin de gérer différents problèmes lors de l’installation.

Nous devrons rendre :

• Le cahier des charges : Mi-Novembre

• Le diagramme UML : 02/12/16 (Le brouillon 19/10/2016)
• Affiche : 02/12/2016
• Résumé en anglais : Fin-Novembre
• Rapport : 16 janvier 2017
• Soutenance : 10 janvier 2017

3- Autres contraintes

Dans le cadre de ce projet, nous utiliserons comme langage le C++. Ce choix s’explique par les
avantages qu’il procure. C’est un langage très répandu, il est rapide ce qui permet de fonctionner en
temps réel. De plus il est portable, c'est-à-dire que le code peut être transformé sans difficulté en
exécutable sous Windows, Mac ou Linux.

Il existe de nombreuses bibliothèques afin de créer des programmes 3D, réseaux, audio, etc.

Page 28 sur 34
Le dernier point fort du C++ est la programmation orientée objet qui est reconnue pour avoir des
fonctions organisées, un code clair et donc plus facile à maintenir, mais également une meilleure
modularité, en effet on peut rajouter des éléments sans avoir à modifier tout le code.

C- Déroulement du projet
1- Planification

Notre projet va se découper en plusieurs phases qui sont :

- L’installation de PoLAR
- La familiarisation avec sa bibliothèque
- Le développement de l’interface
- La production de l’affiche
- La rédaction du résumé
- La rédaction du rapport
- Le développement de la présentation finale

Ces différentes phases ne peuvent pas s’exécuter dans n’importe quel ordre. En effet pour débuter ce
projet il nous faut installer PoLAR et se familiariser avec l’utilisation de ses bibliothèques. Ensuite le
développement de l’interface et la rédaction du rapport doivent se faire en parallèle afin de rendre
compte le mieux possible notre avancée, de notre travail, des problèmes rencontrés et des solutions
appliquées.

La production de l’affiche et du résumé n’ont pas d’autres contraintes que leurs deadlines, c’est
pourquoi ils seront produits en début de projet en parallèle du développement de l’interface.

Enfin, nous réaliserons la présentation finale car tous les éléments énoncés ci-dessus sont nécessaires
pour présenter ce projet.

2- Ressources
Le client (l’Université de Lorraine) peut mettre différentes ressources à disposition du prestataire. Par
exemple des ressources humaines comme du personnel compétent (les professeurs) ou encore des
ressources matérielles comme du matériel informatique, des livres de la bibliothèque etc…

De plus notre tuteur nous a fourni un certain nombre de données afin de réaliser le maillage de la cage
thoracique.

Page 29 sur 34
B- Résumé en anglais

Summary of tutored project untitled

augmented reality in the medical domain
Introduction

The aim of our project is to modelize a chest cavity carried out with augmented reality*.
Augmented reality’s applications are very wide, indeed we could see it in education, culture, medicine,
archaeology, geo-tracking, architecture E-commerce, … In other words, augmented reality has clearly
invaded our daily life.

A- Presentation of the project

1.Context
Our project is based on augmented reality which is exponentially expands in our society. In 2020 the
augmented reality market is expected to reach $120 billion. The augmented reality has many
advantages and almost unlimited applications.

2.Applications
The interest of this technology is to allow the user to move and to have at all times digital assistance.
The fields of application concern all our daily tasks. This can help you navigate through the city, view
the streets to follow, or take you back in time by displaying historical monuments as they once were.
Another example is translate a text in real time.

Our project target is the medicine, indeed these programs allowed learning of students in this subject
or make a follow-up of a surgery or of a patient.

Page 30 sur 34
 3.Distribution of roles

For our project we divided the roles as follows :

 Marie : Communication Manager, drafting of the specifications, the report, realization of the
poster and slideshow.
 Flavien : Programming (human-machine interface)
 Pierre : Programming (Placement of 3D objects)

B- Installation
To begin our project, we had to install some libraries* as OpenSceneGraph* and PoLaR*and some
toolkits for programming like Qt*.

1.Linux
First we have to install some packages* to allow the proper operation of the PoLAR library. Once this
was done it was necessary to install PoLAR by cloning a Git* repository and compile* PoLAR. All these
action are done through the execution of command lines provided in the PoLAR documentation. To
finish we have to install Qt in order to execute and edit our code.

2.Windows
On Windows, it’s a taffer work, indeed we have to download both OpenSceneGraph and PoLaR with
dependencies. Then, install Qt and Microsoft Visual Studio* and CMake*.
We first have to “precompile” the library with the software CMake and then compile OpenSceneGraph
and then PoLaR which use OSG.

C- Implementation
1.Working atmosphere
The atmosphere is calm and serious. This is because we are used to working together since last year.
Moreover, it is not the first project that we realize together.
Sometimes, however, there are tensions, but they are quickly settled.

Each project has developed our team spirit but the one more because we are few and we have to do
an important job, so we have to move forward together.

Working together is enriching because we have to self-manage.

Page 31 sur 34
 2.Program
In our project, we have to make a 3D visualisation which allowed learning and simulations.

We use the API (Application Programming Interface) Qt because it allowed the addition of many
features among others to make the man-machine interface.

The library PoLAR (witch is in particular

supervised by our tutor Pierre-Frédéric Villard)
allows us to use some features for 3D
representation of objects. The PoLAR library is
derived from the OpenSceneGraph library.

We have to make a program that we could

follow the chest cavity of the breathing.
For that, we have a background X-Ray video
and we have model supplied by Mr. Villard.

Example of the superposition of the 3D model on the ribs

To do that we have two steps which are the initialisation and the visualisation.
For the first part, using the man-machine interface, we have to select each rib and use two sliders to
choose its angles from the beginning of the breathing as well as its angles at the end of the inspiration.
And for the second, we have a slider which represent the time and we could stop the X-Ray and
resume.

Conclusion
To conclude the augmented reality applies in many areas like the one of medicine in our case. This
project was very interesting, reminded us of the importance of group work and taught us many things
about the augmented reality and the 3D representation of an object.

Page 32 sur 34
 Glossary (quote with *)
Augmented reality (AR) : addition of 2D or 3D models in real time.

CMake : prepare the compilation of a program.

Compile : action of translating the source code into binary code that will be understood by the
computer

Framework : generic functionalities provider

Git : version control system that is used for collaborative software development and other version
control tasks.
Cloning a git repository : This means that we have duplicated an online directory on our PC
which can be modified subsequently.

Library : code supplied which implements methods to add many possibilities, in short, some
functionalities.

OpenSceneGraph (OSG) : open source high performance 3D graphics library*.

Package : code supplied which implements methods to add many possibilities, in short, some
functionalities.

PoLaR : Library* which add rapid prototyping of Qt* based GUIs for AR* applications.

Qt : cross-platform application framework* that is widely used for developing application software
which add some packages.

Microsoft Visual Studio : integrated development environment (IDE) which allowed to compile our
project on Windows

Page 33 sur 34
Sources sur l’état de l’art

https://fr.wikipedia.org/wiki/R%C3%A9alit%C3%A9_augment%C3%A9e
http://www.augmented-reality.fr/cest-quoi-la-realite-augmentee/
http://www.augmented-reality.fr/cest-quoi-la-realite-augmentee/des-exemples-dutilisation-de-la-
realite-augmentee/
http://www.realite-virtuelle.com/definition-realite-augmentee
http://www.realite-virtuelle.com/applications-realite-augmentee
https://www.youtube.com/watch?v=lA9Yz76yX58
http://www.definitions-marketing.com/definition/realite-augmentee/

Page 34 sur 34