Développement d’un logiciel pour la chirurgie assistée par

ordinateur avec la réalité augmentée

ZERMANE Sara

July 25, 2024

Contents

Contents 1

List of Figures 3

List of Tables 4

1 Introduction 5
1.1 Présentation du Laboratoire EnCoV TGI . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Structure du Rapport . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Technologies Utilisées 7
2.1 Bibliothèques et Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3 Interface Utilisateur 8
3.1 Conception de l’Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2 Description des Composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2.1 Fenêtre 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2.2 Fenêtre 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4 Implémentation Technique 9
4.1 Utilisation d’OpenGL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.2 Matrices de Transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.3 Réalisme et Réalité Augmentée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

5 Gestion des Correspondances 10

5.1 Classe Mère : Correspondance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.2 Classes Filles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.3 Utilisation dans le Marquage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

6 Méthodes Pertinentes 11
6.1 Validation du Contexte OpenGL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.2 Sauvegarde et Chargement d’une Scène . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.2.1 Sauvegarde d’une Scène . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.2.2 Chargement d’une Scène . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.3 Changement d’Opacité et de Couleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.3.1 Changement d’Opacité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.3.2 Changement de Couleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.4 Redimensionnement de la Fenêtre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.4.1 Méthode resizeEvent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.5 Ajout d’Espace Noir et Dézoom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.5.1 Ajout d’Espace Noir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6.5.2 Dézoom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1
7 Résultats et Discussion 13
7.1 Résultats Obtenus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
7.2 Défis Rencontrés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
7.3 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

8 Conclusion et Perspectives 14
8.1 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
8.2 Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2
List of Figures

3
List of Tables

4
Introduction

1.1 Présentation du Laboratoire EnCoV TGI

Le laboratoire EnCoV TGI, situé à la faculté de médecine de l’Université Clermont Auvergne (UCA),
travaille en étroite collaboration avec le CHU de Clermont-Ferrand. Il se spécialise dans la recherche en
imagerie médicale et en réalité augmentée, sous la direction d’Adrien Bartoli. Le déroulement du stage
est supervisé par Adrien Bartoli et Yamid Espinel Lopez.

1.2 Contexte
La réalité augmentée (RA) se développe actuellement dans de nombreuses interventions chirurgicales,
notamment la résection laparoscopique des organes comme le foie, les reins, le pancréas, et d’autres
organes. Elle permet de superposer le modèle 3D virtuel de l’organe du patient, reconstruit à partir
des images préopératoires, sur les images laparoscopiques. Cela aide le chirurgien à voir les structures
internes de l’organe par transparence virtuelle. Les défis de la RA dans ces interventions découlent de la
grande déformabilité des tissus et du fait que toute la surface de l’organe n’est pas toujours visible dans
le champ de vision du laparoscope.

1.3 Objectifs
Les principaux objectifs de ce projet sont :
• Développer une interface utilisateur permettant de visualiser marquer et superposer des modèles
3D virtuels sur l’image 2D laparoscopique.
• Implémenter des transformations OpenGL pour le rendu de la réalité augmentée.

• Créer des classes pour gérer différents types de correspondances (points, courbes, etc.).
• Intégrer des fonctionnalités pour le changement d’opacité et de couleur des modèles 3D.
• Implémenter des calculs parallèles pour améliorer la fluidité des interactions.

1.4 Structure du Rapport

Ce rapport est structuré comme suit :
• Chapitre 2 : Technologies Utilisées - Présente les outils et bibliothèques utilisés dans ce projet.
• Chapitre 3 : Interface Utilisateur - Décrit la conception de l’interface utilisateur.
• Chapitre 4 : Implémentation Technique - Détaille les aspects techniques de l’implémentation,
y compris OpenGL et les matrices de transformation.
• Chapitre 5 : Gestion des Correspondances - Décrit les classes de correspondances et leur
rôle dans le marquage.

5
• Chapitre 6 : Méthodes Clés - Explique les méthodes importantes comme la sauvegarde, le
chargement, et le changement d’opacité et de couleur.
• Chapitre 7 : Résultats et Discussion - Présente les résultats obtenus et discute des défis
rencontrés.

• Chapitre 8 : Conclusion et Perspectives - Conclut le rapport et propose des perspectives

pour les travaux futurs.

6
Technologies Utilisées

2.1 Bibliothèques et Outils

Ce projet utilise plusieurs bibliothèques et outils pour atteindre ses objectifs :
• PyQt5 : Utilisé pour développer l’interface utilisateur.
• OpenGL : Utilisé pour le rendu des modèles 3D.

• NumPy : Utilisé pour les calculs numériques et les transformations matricielles.

• Qt Designer : Utilisé pour concevoir l’interface graphique, ensuite convertie en script Python.
• Spyder : Environnement de développement intégré (IDE) utilisé pour coder et tester l’application.

7
Interface Utilisateur

3.1 Conception de l’Interface

L’interface utilisateur de l’application est développée en utilisant PyQt5 et Qt Designer. Elle est composée
de deux fenêtres principales :
• Fenêtre 2D (Edit2DContours) : Permet de visualiser et de marquer les images 2D.
• Fenêtre 3D (Edit3DContours) : Permet de visualiser et de marquer les modèles 3D.

3.2 Description des Composants

3.2.1 Fenêtre 2D
La fenêtre 2D permet aux utilisateurs de charger une image et d’ajouter des marqueurs. Elle comprend
:
• Un widget OpenGL pour afficher l’image.

• Des boutons pour ajouter et supprimer des marqueurs.

• Une liste déroulante pour sélectionner les contours de l’image.

3.2.2 Fenêtre 3D
La fenêtre 3D permet aux utilisateurs de charger des modèles 3D et d’ajouter des marqueurs. Elle
comprend :
• Un widget OpenGL pour afficher les modèles 3D.
• Des boutons pour ajouter et supprimer des modèles.

• Une barre de défilement pour ajuster l’opacité des modèles.

8
Implémentation Technique

4.1 Utilisation d’OpenGL

OpenGL est utilisé pour le rendu des modèles 3D dans la fenêtre 3D. Les principales fonctionnalités
implémentées incluent :
• Chargement et affichage des modèles 3D.
• Application des transformations de vue et de projection.

• Manipulation des matrices de transformation pour le recalage.

4.2 Matrices de Transformation

Les matrices de transformation sont cruciales pour le rendu correct des modèles 3D. Les principales
matrices utilisées sont :
• Matrice de modèle : Transforme les coordonnées locales des modèles en coordonnées globales.

• Matrice de vue : Positionne et oriente la caméra dans la scène 3D.

• Matrice de projection : Définit le volume de visualisation et applique une projection perspective
ou orthographique.

4.3 Réalisme et Réalité Augmentée

L’utilisation combinée d’OpenGL et des matrices de transformation permet de superposer les modèles
3D sur des images 2D de manière réaliste, créant ainsi une expérience de réalité augmentée.

9
Gestion des Correspondances

5.1 Classe Mère : Correspondance

La classe abstraite Correspondance sert de base pour les différentes correspondances utilisées dans le
marquage. Elle définit les méthodes et attributs communs à toutes les correspondances.

5.2 Classes Filles

Quatre classes filles héritent de Correspondance pour gérer différents types de correspondances :
• Correspondence Point : Gère les correspondances de points simples.

• Correspondence Curve With End Point : Gère les correspondances de courbes avec deux
extrémités.
• Correspondence Curve Without End Point : Gère les correspondances de courbes fermées
sans extrémité.

• Correspondence Curve With Single End Point : Gère les correspondances de courbes avec
une seule extrémité.

5.3 Utilisation dans le Marquage

Ces classes permettent de reconnaı̂tre et de gérer différents types de marqueurs, facilitant ainsi le pro-
cessus de recalage et assurant une correspondance précise entre les modèles 3D et les images 2D.

10
 Méthodes Pertinentes

6.1 Validation du Contexte OpenGL

• initializeGL(self ) : Initialise les configurations OpenGL, configure les shaders, et prépare le
contexte OpenGL pour le rendu.
• makeCurrentContext(self ) : Assure que le contexte OpenGL est actif avant d’exécuter d’autres
opérations OpenGL.
• paintGL(self ) : Dessine la scène OpenGL, en commençant par s’assurer que le contexte OpenGL
est courant.
• addModelGL(self, modelp ath, modelc olor, scale = 1.0) : AjouteunmodèleàlascèneOpenGLaprèsvalidationducontexte

6.2 Sauvegarde et Chargement d’une Scène

6.2.1 Sauvegarde d’une Scène
La méthode de sauvegarde permet de sauvegarder l’état actuel de la scène, y compris les positions des
marqueurs et les modèles chargés. Exemple pratique : Sauvegarder la scène permet de reprendre le
travail plus tard sans perdre les modifications effectuées.

6.2.2 Chargement d’une Scène

La méthode de chargement permet de restaurer une scène précédemment sauvegardée. Exemple pratique
: Charger une scène permet de reprendre le travail là où il a été laissé.

6.3 Changement d’Opacité et de Couleur

6.3.1 Changement d’Opacité
La méthode de changement d’opacité permet de rendre les modèles plus ou moins transparents. Exemple
pratique : Rendre un modèle plus transparent permet de mieux visualiser les structures internes.

6.3.2 Changement de Couleur

La méthode de changement de couleur permet de distinguer différents modèles en leur appliquant des
couleurs différentes. Exemple pratique : Changer la couleur d’un modèle permet de mieux le différencier
des autres modèles.

6.4 Redimensionnement de la Fenêtre

6.4.1 Méthode resizeEvent
La méthode resizeEvent ajuste proportionnellement le rendu OpenGL lors du redimensionnement de
la fenêtre. Exemple pratique : Redimensionner la fenêtre permet d’adapter la vue pour une meilleure
visualisation sans distorsion.

11
6.5 Ajout d’Espace Noir et Dézoom
6.5.1 Ajout d’Espace Noir
L’ajout d’espace noir autour du rendu OpenGL permet de visualiser l’ensemble du modèle même avec un
champ de vision étroit. Exemple pratique : L’espace noir permet de voir les parties cachées du modèle
qui ne sont pas visibles avec le champ de caméra limité.

6.5.2 Dézoom
La fonction de dézoom permet de reculer la vue pour inclure plus d’espace noir autour du modèle.
Exemple pratique : Dézoomer permet de visualiser tout le modèle sans avoir à déplacer la caméra de
manière excessive.

12
Résultats et Discussion

7.1 Résultats Obtenus

Les principaux résultats obtenus incluent :
•• Une interface utilisateur fonctionnelle pour le marquage des images et des modèles 3D.
• Un système de recalage efficace permettant d’aligner précisément les modèles 3D avec les images
2D.

• La gestion de différents types de correspondances pour un marquage flexible et précis.

7.2 Défis Rencontrés

Les principaux défis rencontrés lors du développement de ce projet incluent :
• La manipulation des matrices de transformation pour assurer un rendu correct en OpenGL.

• L’implémentation d’algorithmes de recalage robustes et efficaces.

• La gestion des correspondances complexes lors du marquage.

7.3 Discussion
Le système développé montre une grande promesse pour les applications de réalité augmentée, notamment
dans le domaine médical où un alignement précis entre les images 2D et les modèles 3D est crucial.
Cependant, des améliorations peuvent être apportées pour augmenter la robustesse et la précision du
recalage.

13
Conclusion et Perspectives

8.1 Conclusion
Ce projet a permis de développer une application de marquage en réalité augmentée fonctionnelle,
intégrant des outils avancés pour le rendu 3D, le marquage et le recalage. Les résultats obtenus montrent
l’efficacité du système, bien que certains aspects puissent encore être améliorés.

8.2 Perspectives
Les perspectives futures pour ce projet incluent :

• L’optimisation des algorithmes de recalage pour une plus grande précision.

• L’intégration de techniques de vision par ordinateur pour améliorer la reconnaissance des corre-
spondances.
• L’extension de l’application à d’autres domaines tels que l’éducation et l’ingénierie.

14