Augmented Reality | Étienne Peillard

TP — Réalité augmentée sur smartphone

Thu, 26 Feb 2026 00:00:00 +0000

Objectif

Créer une application de réalité augmentée capable de :

détecter une image utilisée comme marqueur,
afficher un objet 3D attaché à ce marqueur,
détecter un plan dans l’environnement,
définir une zone de jeu,
créer des interactions entre les marqueurs et la zone.

Partie 1 — Création du projet

Créer un projet Unity.
Basculer la plateforme vers Android dans les Build Settings.

Pour avoir accès aux logs sur le téléphone, installer Android Logcat depuis le Package Manager.

Installer AR Foundation.
Installer ARCore XR Plugin (Android) ou ARKit XR Plugin (iOS).
Ouvrir Project Settings → XR Plug-in Management et activer :
- ARCore dans l’onglet Android
- ARKit dans l’onglet iOS (si nécessaire)
Dans Project Settings → Player → Android :
- définir Minimum API Level : Android 10 / API 29.
- Dans Graphics APIs, désactiver Vulkan et conserver OpenGLES3 uniquement.
Ajouter dans la scène :
- AR Session
- XR Origin (avec AR Camera)
Configuration du rendu mobile
- Dans le projet, ouvrir : Assets/Settings/Mobile_Renderer
- Dans l’inspecteur : Add Renderer Feature → AR Background Renderer Feature

Vérifier que l’application se lance sur le téléphone et que le flux caméra est visible.

Lors du premier lancement sur le téléphone, autoriser l’accès à la caméra lorsque le système le demande.

Partie 2 — Détection d’image

Créer un nouvel asset Reference Image Library.
Ajouter une image marqueur.
Ajouter un composant ARTrackedImageManager au XR Origin.
Associer la bibliothèque d’images.
Créer un prefab d’objet 3D à afficher sur le marqueur.
Associer ce prefab au ARTrackedImageManager.

Vous pouvez utiliser les marqueurs prévus pour ce TP. L’asset ImageLibrary est disponible ici et les marqueurs sont ici.

Partie 3 — Détection de plans (sélection d’un plan + zone de jeu)

Objectif

détecter des plans horizontaux/verticaux via AR Foundation,
permettre à l’utilisateur de taper sur un plan détecté,
placer une zone de jeu (GameBoard) sur ce plan.

3.1 Ajouter les composants AR nécessaires

Sur l’objet XR Origin :

ARPlaneManager

Sert à détecter et maintenir les plans.
Associer un Plane Prefab pour visualiser les plans.

Créer un Plane Prefab simple

Create → Empty GameObject
Nommer l’objet : ARPlanePrefab
Ajouter les composants :
- AR Plane
- AR Plane Mesh Visualizer
- Mesh Renderer
- Mesh Filter
Créer un matériau simple (ex : Unlit / Color transparent).
Assigner ce matériau au Mesh Renderer.
Glisser l’objet dans le dossier Project pour créer un prefab.
Assigner ce prefab dans ARPlaneManager → Plane Prefab.

ARRaycastManager

Sert à projeter un rayon depuis l’écran pour détecter les plans.

Réglage conseillé :

Detection Mode → Horizontal

3.2 Créer un prefab de zone de jeu (GameBoard)

Créer un prefab simple :

un Quad posé à plat
un matériau semi‑transparent
une échelle ~ 0.5 m
optionnel : BoxCollider

3.3 Implémenter le tap-to-place (New Input System)

Dans ce TP, on utilise le New Input System (Unity Input System Package) pour récupérer les taps.

Prérequis

Ouvrir Project Settings → Player
Mettre Active Input Handling → Input System Package (New)

Principe

Créer un script BoardPlacement.cs. Le script doit :

activer EnhancedTouch (au démarrage)
récupérer le premier touch actif
filtrer sur la phase Began
lancer un ARRaycast vers les plans (PlaneWithinPolygon)
créer ou déplacer le GameBoard à la pose du hit

Fonctions / API utiles :

EnhancedTouchSupport.Enable() / Disable()
Touch.activeTouches
touch.phase (New Input System)
touch.screenPosition
ARRaycastManager.Raycast(...)
TrackableType.PlaneWithinPolygon
Pose
Instantiate(...)
transform.SetPositionAndRotation(...)

Checkpoint

Vous devez pouvoir :

voir les plans détectés
toucher un plan
placer la zone de jeu

Partie 4 — Interactions

4.1 Interaction basique

Implémenter une interaction entre :

les marqueurs détectés
la zone de jeu

Exemples possibles :

un objet apparaît lorsque le marqueur entre dans la zone
le marqueur déplace un objet dans la zone
l’orientation du marqueur modifie un paramètre

Cette partie est volontairement libre.

4.2 Ressources pour aller plus loin

Le package AR Foundation fournit plusieurs fonctionnalités utiles pour enrichir votre projet.

Suivi des images

ARTrackedImageManager
événements : trackedImagesChanged
accès à la position d’un marqueur

Détection de plans

ARPlaneManager
accès aux plans détectés

Raycast AR

ARRaycastManager.Raycast()
permet d’interagir avec l’environnement réel

Ancres AR

ARAnchorManager
permet de fixer durablement un objet dans l’espace

Estimation de la lumière

ARCameraManager
permet d’adapter la lumière des objets virtuels à la scène réelle

Tracking du visage / du corps (selon appareils)

Face Tracking
Body Tracking

Documentation officielle :

https://docs.unity3d.com/Packages/com.unity.xr.arfoundation

Partie 5 — Scénarisation

Vous avez maintenant tous les éléments techniques pour créer une expérience AR complète.

Inventez une petite application ou un mini‑jeu utilisant :

un marqueur ou plusieurs marqueurs
une zone
au moins une interaction.

Extensions possibles

plusieurs marqueurs
interactions entre marqueurs
effets visuels
interface utilisateur AR

Livrables

Compte rendu (PDF) avec :
- description de l’application
- captures d’écran
- explications techniques
- lien Git vers le projet Unity

Barème

Mise en place du projet — 2 pts
Image tracking — 2 pts
Détection de plan et placement — 4 pts
Interactions — 4 pts
Scénarisation — 5 pts
Qualité technique — 2 pts
Rendu — 1 pt

TP — Réalité augmentée projective

Thu, 19 Feb 2026 00:00:00 +0000

Réalité Augmentée Projective

▶ Code de base

Objectifs

Ce tutoriel introduit les fondements de la réalité augmentée projective (AR), depuis la détection d’événements par caméra jusqu’à l’augmentation spatiale via un projecteur.

L’application de référence est un jeu de morpion (tic-tac-toe), mais l’architecture peut être réutilisée pour tout scénario d’augmentation de surface (ex. jeux de plateau augmentés, visualisation scientifique, dispositifs expérimentaux).

Vous apprendrez à :

Calibrer la caméra, le projecteur et la surface physique
Calculer les matrices de transformation (homographies) entre espaces
Détecter des modifications sur la surface
Projeter des augmentations cohérentes en temps réel

Vue d’ensemble du système

Nous travaillons dans trois espaces distincts :

Espace image caméra
Espace image projecteur
Espace plateau physique

Ces espaces ne sont pas alignés. Une calibration est nécessaire pour calculer les transformations entre eux.

L’objectif principal est :

Convertir un coup détecté (espace caméra) en coordonnées du plateau
Convertir une coordonnée du plateau en coordonnées projecteur

Installation

Assurez-vous que Python et pip sont installés.

Le TP a été testé avec Python 3.12 et 3.13. D’autres versions peuvent fonctionner, mais des ajustements pourraient être nécessaires.

Installez les dépendances requises :

pip install numpy==1.26.4
pip install opencv-python==4.10.0.84
pip install opencv-contrib-python==4.6.0.66

OpenCV : bibliothèque de vision par ordinateur
Aruco : module de génération et détection de marqueurs (inclus dans opencv-contrib)

Documentation : https://docs.opencv.org/4.x/index.html

Génération des marqueurs

Exécutez :

python generateMarkers.py

Si l’installation est correcte, quatre marqueurs définissant la zone de jeu seront générés.

Imprimez-les et placez-les sur le plateau.

Conventions de coordonnées

Représentation matricielle (images)

Les images sont des matrices NumPy en ordre ligne-major :

Premier indice → ligne (vertical, vers le bas)
Second indice → colonne (horizontal, vers la droite)
(0,0) correspond au coin supérieur gauche

Représentation des points

Les points suivent la convention image :

Origine : coin supérieur gauche
X → droite
Y → bas

Système de coordonnées :

(0,0) - X →
 |
 |
 Y
 ↓

Soyez extrêmement attentif lors du passage entre indexation matricielle et coordonnées géométriques.

Structure du code

Quatre composants principaux :

Camera
Projector
CoreAR
TicTacToe

Toutes les parties manquantes sont indiquées par :

### TODO

1️⃣ Initialisation

Camera

Recherche automatiquement une caméra disponible
Exposition configurable
Doit être libérée via :

camera.release()

Complétez toutes les sections TODO.

Projector

Constructeur : aucune modification requise.

Implémentez :

drawBlack()

Comprenez le fonctionnement du dessin dans l’espace projecteur.

CoreAR

Le constructeur stocke uniquement les références.

Aucune modification requise.

2️⃣ Calibration

Calibration caméra

Objectif :

Détecter les quatre marqueurs ArUco
Associer les coins détectés aux coordonnées du plateau
Calculer l’homographie entre plateau et caméra

Complétez toutes les sections TODO dans :

calibrateCamera()

Calibration projecteur

Principe :

Projeter des marqueurs à des positions projecteur connues
Les détecter avec la caméra
Convertir les détections caméra en coordonnées plateau
Calculer l’homographie projecteur → plateau

Complétez :

drawMarkers() dans Projector
calibrateProjector() dans CoreAR

3️⃣ Dessin dans l’espace projecteur

Implémentez :

draw()
checkCalibration()

Cela permet :

D’afficher le plateau de jeu
De valider visuellement la calibration

Testez l’ensemble de la chaîne de calibration.

4️⃣ Logique du jeu

La classe ticTacToe est déjà implémentée.

Vous devez maintenant vous concentrer sur la détection des coups.

5️⃣ Détection des coups

Stratégie :

Capturer une image de référence
Comparer l’image courante à la référence
Calculer l’image différence
Appliquer un seuillage
Appliquer une ouverture morphologique
Extraire la position du blob
Valider la stabilité temporelle
Mettre à jour l’image de référence

Complétez toutes les sections TODO dans :

findMove()

Les lignes intermédiaires imshow() peuvent être décommentées pour le débogage.

Pipeline de traitement d’image

Soustraction d’images
Seuillage
Ouverture morphologique
Extraction de contours

Cela permet d’isoler les nouveaux coups placés sur le plateau.

Améliorations & Réglages

Vous pouvez ajuster :

L’exposition de la caméra
La luminosité du projecteur
La valeur de seuil

Un réglage fin influence fortement la robustesse de la détection.

Ce que vous avez construit

À la fin de ce tutoriel, vous avez implémenté :

Une calibration caméra-projecteur
Une estimation d’homographies multi-espaces
Une augmentation de surface en temps réel
Une détection d’événements basique

Cette architecture peut être réutilisée pour :

Jeux de plateau augmentés
Surfaces interactives
Dispositifs expérimentaux
Visualisation scientifique

Livrables

Code complété (tous les TODO remplis)
Calibration fonctionnelle
Morpion augmenté entièrement opérationnel

Optionnel :

Améliorations de détection
Améliorations graphiques
Fonctionnalités de jeu supplémentaires

Clarifications (Suite aux questions étudiantes)

Installation OpenCV avec Conda

Si pip n’est pas disponible, utilisez :

conda install -c conda-forge opencv

Dans la plupart des cas, Aruco est installé automatiquement.

Sinon :

conda install -c conda-forge aruco

Si ArUco est toujours absent, installez pip et utilisez opencv-contrib-python.

Matrice de projection Caméra → Projecteur (R2P)

La matrice de projection du plateau réel vers l’espace projecteur (R2P) :

Est calculée dans CoreAR
Est assignée dans main.py via :

proj.R2P = core.R2P

Il n’y a pas de mécanisme d’encapsulation ici. L’attribut est ajouté dynamiquement à l’instance Projector.

Dans la classe Projector, utilisez simplement :

self.R2P

Cela fonctionne car draw() est appelé uniquement après la définition de l’attribut.

Fonctions de calibration et matrices de transformation

`calibrateCamera()`

Détecte les marqueurs ArUco physiques placés sur le plateau
⚠ Ne placez pas les marqueurs sur un fond noir
Calcule la matrice :

R2C (Réel → Caméra)

`calibrateProjector()`

Le projecteur affiche des marqueurs virtuels
La caméra détecte ces marqueurs projetés
Une correspondance est effectuée entre :
- Positions projetées connues
- Positions détectées en espace caméra
Une transformation Caméra → Projecteur est calculée

On en déduit :

R2P (Réel → Projecteur)

Chaîne complète :

Réel → Caméra → Projecteur

Finalement :

R2P = (C2P) ∘ (R2C)

Fin du tutoriel.

TP — Suivi de marqueurs avec OpenCV

Thu, 12 Feb 2026 00:00:00 +0000

Marker Tracking

▶ Code de base

Librairies requises:

pip install opencv-python

pip install numpy

Introduction

Le but de ce TP est de vous initier à plusieurs notions essentielles de vision par ordinateur, à travers un cas d’application concret : la détection et la localisation d’un marqueur plan dans un flux vidéo.

Vous travaillerez notamment sur :

la détection de points caractéristiques (points d’intérêt, feature points),
la description de ces points (descripteurs locaux),
le matching (mise en correspondance) de points détectés dans deux images,
le calcul d’une homographie (transformation projective),
une augmentation du flux vidéo basée sur la localisation du marqueur.

À l’issue du TP, vous disposerez d’un programme qui, à partir :

d’une image de référence (le marqueur),
d’un flux vidéo (webcam ou fichier),

détecte automatiquement la présence du marqueur dans la scène et masque la zone du marqueur en la remplaçant par un polygone blanc (pour valider visuellement la détection).

Principe de l’application

L’idée générale du système est la suivante :

Charger l’image du marqueur (image de référence).
Ouvrir un flux vidéo (webcam ou fichier vidéo).
Détecter dans l’image du marqueur un ensemble de points d’intérêt (FP_M).
Calculer pour ces points un ensemble de descripteurs (FD_M).
Pour chaque frame I_t du flux vidéo :
- détecter un ensemble de points d’intérêt (FP_t),
- calculer des descripteurs (FD_t),
- effectuer le matching entre FD_M et FD_t pour obtenir des correspondances,
- filtrer ces correspondances pour ne conserver que des « bons matchs ».
Estimer la transformation géométrique reliant le plan du marqueur à la frame : une homographie H_{M->t} calculée de manière robuste avec RANSAC.
Utiliser H_{M->t} pour :
- projeter les 4 coins du marqueur dans l’image I_t,
- masquer la zone détectée en la remplissant en blanc.

Remarque importante : ce TP réalise une localisation par « redétection + matching » à chaque frame. Il ne s’agit pas d’un suivi temporel (type KLT/optical flow), mais d’une approche robuste et simple à mettre en œuvre.

Détection de points d’intérêt

L’objectif de la détection de points d’intérêt (ou plus généralement de « régions » d’intérêt) est de sélectionner automatiquement des éléments de l’image qui présentent des propriétés remarquables : coins, textures, zones contrastées, etc.

Un détecteur de features prend en entrée une image et renvoie un ensemble de coordonnées (pixels) correspondant aux points jugés « intéressants » par l’algorithme.

Important : un détecteur fournit des positions (et parfois une échelle/orientation) mais pas de signature descriptive associée.

Exemples de détecteurs : Harris, FAST, Shi-Tomasi, ORB, AKAZE, SIFT, etc.

Ressources (à lire après le TP) :

Description de points d’intérêt

Un descripteur de features vise à caractériser numériquement l’apparence locale autour d’un point d’intérêt.

Il prend en entrée :

une image,
une liste de points d’intérêt,

et renvoie un vecteur (ou une matrice) de descripteurs, un par point.

Ces descripteurs représentent une forme « d’empreinte digitale » locale permettant de comparer des points détectés dans des images différentes.

Propriétés souhaitables d’un descripteur :

invariance (ou robustesse) aux rotations,
invariance (ou robustesse) aux changements d’échelle,
robustesse aux variations photométriques (éclairage),
robustesse aux transformations géométriques modérées.

Exemples : ORB, AKAZE, BRISK, SIFT (détecteur+descripteur), etc.

Ressources (à lire après le TP) :

Matching (mise en correspondance)

Le matching correspond à la question suivante :

Étant donné une feature dans l’image du marqueur, comment trouver la feature la plus similaire dans la frame vidéo courante ?

L’idée générale est :

Définir une distance ou une similarité entre descripteurs.
Pour chaque descripteur du marqueur, trouver le descripteur le plus proche dans la frame.

Mesures possibles : L1, L2, Hamming (descripteurs binaires), ratio test, etc.

Méthodes de matching :

Brute force : compare tous les descripteurs 2 à 2 (simple, peut être coûteux).
FLANN : approche par plus proches voisins approximatifs (plus rapide sur grands volumes).

Après le matching, il faut définir une règle de filtrage pour ne conserver que les correspondances pertinentes. Une approche classique (et celle utilisée dans la base de code fournie) consiste à utiliser un seuil basé sur la distance minimale observée :

threshold = alpha * minDist

où alpha est un coefficient (typiquement entre 3 et 20 selon la méthode et la qualité attendue).

Ressources (à lire après le TP) :

Homographie et projection

Une fois des correspondances établies entre le marqueur (plan) et la frame (image), on souhaite estimer la transformation géométrique reliant ces deux ensembles de points.

Pour un objet plan, cette transformation est une homographie (matrice 3x3). Elle permet de modéliser la perspective et relie deux vues d’un même plan.

On cherche à estimer une matrice H à partir des bons matchs (après filtrage). L’estimation doit être robuste aux mauvais matchs : on utilise RANSAC.

Ressources (à lire après le TP) :

Implémentation dans OpenCV

L’objectif du TP est d’implémenter les étapes précédentes dans OpenCV en partant d’un squelette de code.

Base de code fournie

Vous disposez des fichiers suivants :

main.py fileciteturn1file0
MyFeatureDetector.py fileciteturn1file3
MyDescriptorExtractor.py fileciteturn1file1
MyDescriptorMatcher.py fileciteturn1file2

Ces fichiers contiennent des sections TODO qui guident votre implémentation.

Important : la base actuelle charge deux images fixes. Vous devez l’adapter pour gérer :

une image de référence marker.jpg,
un flux vidéo (webcam ou fichier).

Vous supprimerez la partie finale de génération d’une image transformée (warp) et la remplacerez par une augmentation (masquage du marqueur) basée sur la projection des coins.

Questions

Question 1 : Lecture et compréhension du code fourni

Lisez le code fourni et identifiez :

où sont chargées les images,
où sont instanciés le détecteur, l’extracteur et le matcher,
où sont stockés les points détectés et les descripteurs,
comment la liste des meilleurs matchs est construite,
comment l’homographie est calculée.

Expliquez en quelques lignes le rôle de chaque fichier.

Question 2 : Créer un détecteur de features (ORB)

Dans MyFeatureDetector.py, complétez la fonction changeFeatureDetector pour créer un détecteur ORB.

Objectif : remplir l’attribut myFeatureDetector en appelant le constructeur OpenCV approprié (par exemple cv.ORB_create(...)).

Question 3 : Afficher les points détectés

Dans main.py, affichez les points d’intérêt détectés :

sur l’image marker.jpg,
sur une frame de la vidéo.

Indication : utilisez la méthode displayFeatures et les sections TODO déjà présentes dans le squelette.

À faire : ajoutez une capture d’écran montrant les résultats sur le marqueur et sur une frame.

Option : ajoutez des paramètres à cv.ORB_create(...) (nombre de points, seuil, etc.), puis commentez l’impact.

Question 4 : Instancier un extracteur de descripteurs (ORB)

Dans MyDescriptorExtractor.py, complétez changeDescriptorExtractor pour créer un extracteur ORB.

Question 5 : Calculer les descripteurs

Complétez computeDescriptors() dans MyDescriptorExtractor.py et complétez les appels correspondants dans main.py pour :

calculer les descripteurs du marqueur,
calculer les descripteurs d’une frame.

Vérifiez que les descripteurs sont bien calculés (dimensions cohérentes, non nuls).

Question 6 : Réaliser le matching

Dans MyDescriptorMatcher.py, complétez la méthode match pour ne conserver que les correspondances dont la distance est inférieure à un seuil :

threshold = alpha * minDist

Les matchs retenus doivent être stockés dans bestMatches.

Question 7 : Afficher le résultat du matching

Dans main.py, appelez drawMatchingResults() et affichez l’image résultante.

À faire : illustrez ce résultat par une capture d’écran dans votre compte rendu.

Question 8 : Comprendre et calculer l’homographie

À partir des meilleurs matchs, construisez deux listes de points 2D :

points dans l’image du marqueur,
points dans la frame vidéo.

Calculez ensuite l’homographie avec cv.findHomography(..., cv.RANSAC, epsilon).

Expliquez en quelques lignes ce que fait ce calcul et pourquoi RANSAC est nécessaire.

Question 9 : Augmentation — masquer le marqueur

Une fois l’homographie H estimée, projetez les 4 coins du marqueur dans la frame.

Étapes attendues :

Définir les 4 coins du marqueur dans son repère image.
Les projeter avec cv.perspectiveTransform.
Dessiner le contour (recommandé pour le debug).
Remplir le polygone projeté en blanc avec cv.fillConvexPoly.

Condition : n’effectuez l’augmentation que si H est valide et si le nombre d’inliers est suffisant (seuil à définir et justifier).

À faire : fournissez une capture d’écran où le marqueur est effectivement masqué.

Question 10 : Tester sur d’autres séquences

Testez votre programme avec :

une autre vidéo (ou une autre scène webcam),
un autre marqueur (image de référence différente).

À faire : illustrez au moins un test supplémentaire et commentez la robustesse.

Question 11 : Changer de détecteurs/descripteurs (option)

Essayez une autre combinaison de détecteur/descripteur (par exemple AKAZE) et comparez :

le nombre de points détectés,
la stabilité du matching,
le nombre d’inliers,
la robustesse aux variations d’échelle/éclairage,
le coût en temps de calcul.

À faire : illustrez et commentez.

Livrables

Vous devez rendre :

Le code complété.
Un court compte rendu (PDF ou Markdown) contenant :
- les captures demandées,
- vos choix de paramètres (alpha, seuil d’inliers, etc.),
- une analyse de robustesse (tests, cas d’échec).