Modélisation Et Animation D'objets 2D/3D Et Réalité Augmentée
Modélisation Et Animation D'objets 2D/3D Et Réalité Augmentée
Modélisation Et Animation D'objets 2D/3D Et Réalité Augmentée
Ce TP combine théorie et pratique pour préparer les étudiants à utiliser les outils essentiels dans la réalité augmentée.
Contenu
1. Introduction à OpenCV
OpenCV est une bibliothèque open-source essentielle pour la vision par ordinateur,
l’apprentissage automatique et le traitement d’images. Elle permet de traiter des images et
vidéos en temps réel pour reconnaître des objets, des visages ou du texte manuscrit. En
combinant OpenCV avec NumPy, Python peut analyser efficacement les données d’images
grâce à des opérations sur l’espace vectoriel.
Lancée sous licence BSD avec la version 1.0, OpenCV est gratuite pour des usages
académiques et commerciaux. Elle prend en charge plusieurs langages (C++, Python, Java) et
systèmes d’exploitation (Windows, Linux, Mac OS, iOS, Android). Conçue pour les applications
en temps réel, elle est optimisée pour tirer parti des traitements multicœurs, avec du code en
C/C++.
2. Installation d’OpenCV pour Python sur Windows
Suivre le tutorial https://www.geeksforgeeks.org/how-to-install-opencv-for-python-in-
windows/
3. Traitement de l’image
Qu’est-ce qu’une image ? – D’une manière générale : perception, par un capteur, d’un signal
continu – Dans la vision humaine
▪ Les capteurs sont les cellules photosensibles de l’œil
▪ Le signal correspond à la lumière réfléchie par les objets de l’environnement en direction de
l’œil – Une image : représentation 2D continue du signal perçu
𝑓 (𝑥, 𝑦 )∶ ℝ × ℝ → ℝ
Qu’est-ce qu’une image numérique ? – Une image numérique est une image échantillonnée
▪ Discrétisation spatiale de 𝑓 (𝑥, 𝑦)
▪ À chaque zone 𝑅 (𝑥, 𝑦) , on associe une unique valeur 𝐼 (𝑥, y)
1
Effets de l’échantillonnage spatial
Qu’est-ce qu’une image numérique ? – Une image numérique est une image quantifiée
▪ Discrétisation tonale de 𝑓
▪ À chaque plage de valeur de 𝑓, on associe une unique valeur I
– Effets de la quantification
2
4. Travailler avec des images
- Lire des images
Pour lire les images, on utilise la méthode cv2.imread(). Cette méthode charge une image à
partir du fichier spécifié. Si l’image ne peut pas être lue (à cause d’un fichier manquant, de
permissions incorrectes, d’un format non supporté ou invalide), cette méthode renvoie une
matrice vide.
Syntaxe : cv2.imread(path,flag)
Paramètres :
path : Une chaine de caractère contenant le chemin de l’image à lire
flag : Il spécifie la manière dont l’image doit être lue. Sa valeur par défaut
est cv2.IMREAD_COLOR. cv2.IMREAD_COLOR : Il spécifie de charger une image en couleur.
Toute transparence de l’image sera négligée. C’est l’indicateur par défaut. Alternativement,
nous pouvons passer la valeur entière 1 pour ce drapeau. cv2.IMREAD_GRAYSCALE : Il
spécifie de charger une image en mode niveaux de gris. Alternativement, nous pouvons passer
la valeur entière 0 pour ce drapeau. cv2.IMREAD_UNCHANGED : Il spécifie de charger une
image telle quelle, y compris le canal alpha. Alternativement, nous pouvons passer la valeur
entière -1 pour ce drapeau.
Retourne : la méthode retourne une image chargée depuis le fichier spécifique
- Afficher une image
La méthode cv2.imshow() est utilisée pour afficher une image dans une fenêtre. La fenêtre
s’adapte automatiquement à la taille de l’image.
Syntaxe : cv2.imshow(window_name, image)
Paramètres :
window_name : Une chaîne représentant le nom de la fenêtre dans laquelle l’image doit être
affichée.
image : C’est l’image qui doit être affichée.
Retourne : Cette méthode ne retourne rien
- Sauver une image
La méthode cv2.imwrite() est utilisée pour enregistrer une image sur un périphérique de
stockage quelconque. Cette méthode enregistre l’image selon le format spécifié dans le
répertoire de travail actuel.
Syntaxe : cv2.imwrite(filename, image)
Paramètres :
filename : Une chaîne représentant le nom du fichier. Le nom de fichier doit inclure le format
d’image comme .jpg, .png, etc.
image : C’est l’image qui doit être sauvegardée.
Exemple 1 : introduction l’image en Python
# importing cv2
import cv2
# path
path = '~/image.png'
# Reading an image in default mode
3
image = cv2.imread(path)
# Window name in which image is displayed
window_name = 'image'
# Using cv2.imshow() method
# Displaying the image
cv2.imshow(window_name, image)
#waits for user to press any key
#(this is necessary to avoid Python kernel form crashing)
cv2.waitKey(0)
# Using cv2.imwrite() method
# Saving the image
cv2.imwrite(filename, image)
#closing all open windows
cv2.destroyAllWindows()
- Image en nuance de gris
Pour convertir une image couleur en une image en nuance de gris, utilisez la
fonction cvtColor() de cv2 qui prend l'image originale et l'attribut COLOR_RGB2GRAY en
paramètres. Le script est le suivant :
Syntaxe:
grey_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
cv2.imshow(“image en gray”,grey_image)
4
marker_corners, marker_IDs, reject = aruco.detectMarkers(
gray_frame, marker_dict, parameters=param_markers)
if marker_corners:
for ids, corners in zip(marker_IDs, marker_corners):
cv2.polylines(
frame, [corners.astype(np.int32)], True, (0, 255, 255), 4, cv2.LINE_AA )
corners = corners.reshape(4, 2)
corners = corners.astype(int)
top_right = corners[0].ravel()
top_left = corners[1].ravel()
bottom_right = corners[2].ravel()
bottom_left = corners[3].ravel()
cv2.putText(frame, f"id: {ids[0]}", top_right, cv2.FONT_HERSHEY_PLAIN,
1.3, (200, 100, 0), 2,
cv2.LINE_AA,
)
# print(ids, " ", corners)
cv2.imshow("frame",frame)
key=cv2.waitKey(1)
if key==ord('q'):
break
cap.release()
cv2.destroyAllWindows()
Description
marker_dict = aruco.getPredefinedDictionary(aruco.DICT_4X4_50) :
Cette ligne de code crée un dictionnaire de marqueurs ArUco prédéfini. Les marqueurs
ArUco sont des motifs carrés spécifiques utilisés pour la détection et le suivi dans des
applications de vision par ordinateur.
Ici, le dictionnaire utilisé est DICT_4X4_50, qui représente un ensemble de marqueurs
ArUco ayant une grille de 4x4 bits (16 cases) et comprenant 50 marqueurs uniques. Ce
dictionnaire contient donc 50 marqueurs ArUco différents, chacun codé sous forme
d'un motif de 4x4.
param_markers = aruco.DetectorParameters() :
Cette ligne crée un objet DetectorParameters, qui contient tous les paramètres
nécessaires pour ajuster la détection des marqueurs ArUco.
Ces paramètres permettent de configurer et d'affiner l'algorithme de détection des
marqueurs, comme les seuils pour la binarisation, la sensibilité de détection, ou les
filtres de rejet des faux positifs. Par défaut, cet objet contient des valeurs
préconfigurées, mais elles peuvent être modifiées pour mieux s'adapter aux conditions
spécifiques d’une application.
5
marker_corners, marker_IDs, reject = aruco.detectMarkers(gray_frame, marker_dict,
parameters=param_markers) :
Cette ligne utilise la fonction detectMarkers d'OpenCV pour détecter les marqueurs ArUco
dans une image, en fournissant les informations nécessaires pour l’identification et la
localisation des marqueurs. Voici le détail des différents éléments :
1. gray_frame :
o Il s'agit de l'image dans laquelle les marqueurs doivent être détectés. Cette image
est en niveaux de gris (échelle de gris) car le traitement d'images pour la
détection de marqueurs fonctionne plus efficacement en l'absence de couleur.
2. marker_dict :
o C'est le dictionnaire de marqueurs ArUco prédéfini (par exemple, DICT_4X4_50)
utilisé pour identifier quels types de marqueurs rechercher dans l'image. Ce
dictionnaire a été créé auparavant avec la ligne marker_dict =
aruco.getPredefinedDictionary(aruco.DICT_4X4_50).
3. parameters=param_markers :
o Cet argument correspond à l'objet DetectorParameters qui contient les réglages
et paramètres utilisés pour ajuster le processus de détection, comme la
binarisation ou le contrôle de qualité des marqueurs détectés.
4. Retour des résultats :
o marker_corners : Liste contenant les coordonnées des coins de chaque
marqueur détecté dans l'image. Chaque marqueur est représenté par quatre
coins (puisqu'il s'agit d'une forme carrée), donc cette variable contient une liste
de tableaux (4 points par marqueur).
o marker_IDs : Tableau contenant les identifiants (IDs) des marqueurs ArUco
détectés. Ces IDs correspondent à ceux définis dans le dictionnaire choisi
(marker_dict). Cela permet d’identifier chaque marqueur de manière unique dans
la scène.
o reject : Liste de contours des marqueurs candidats rejetés par l'algorithme. Ce
sont des motifs qui ressemblent à des marqueurs mais qui n'ont pas été validés
après l'analyse (souvent à cause de la mauvaise qualité du motif ou de la
détection).
Cette ligne de code utilise la fonction cv2.polylines d'OpenCV pour dessiner des polygones
(dans ce cas, les contours des marqueurs ArUco détectés) sur une image.
1. frame :
o C'est l'image sur laquelle les polygones (les contours des marqueurs) seront
dessinés. C'est généralement l'image en couleur ou en niveaux de gris dans
laquelle les marqueurs ont été détectés. Le dessin sera effectué directement sur
cette image.
2. [corners.astype(np.int32)] :
o Il s'agit des coordonnées des coins des marqueurs ArUco détectés, converties en
entiers de type int32 à l'aide de la méthode astype(np.int32). Les coordonnées
6
doivent être des entiers pour le dessin, car les pixels sur une image sont
toujours positionnés par des coordonnées entières. Ces coins sont fournis sous
forme de tableau contenant quatre points qui représentent les coins du polygone
à dessiner.
o Les coins de chaque marqueur sont inclus dans une liste (dans ce cas, il y a une
seule liste) qui est passée à la fonction pour dessiner les polygones.
3. True :
o Ce paramètre booléen indique si le polygone doit être fermé. Ici, la valeur True
signifie que le dernier point de chaque polygone doit être relié au premier point
pour former une forme fermée (un carré ou un rectangle dans le cas des
marqueurs ArUco).
4. (0, 255, 255) :
o Il s'agit de la couleur utilisée pour dessiner les polygones. La couleur est
exprimée sous la forme (B, G, R) en utilisant l'échelle de couleur BGR (Bleu,
Vert, Rouge) propre à OpenCV.
o (0, 255, 255) correspond à la couleur jaune (0 pour le bleu, 255 pour le vert, et
255 pour le rouge).
5. 4:
o Ce paramètre représente l'épaisseur de la ligne du polygone en pixels. Ici, les
contours des polygones seront dessinés avec une épaisseur de 4 pixels.
6. cv2.LINE_AA :
o Il s'agit du type de ligne à utiliser pour dessiner le polygone. cv2.LINE_AA
indique que la ligne doit être dessinée avec une antialiasing (lissage), ce qui
signifie que les bords du polygone seront adoucis pour éviter un aspect trop
pixellisé ou rugueux.
Résumé : Cette ligne de code dessine des contours (sous forme de polygones) autour des
marqueurs détectés dans l'image, en reliant leurs coins. Les polygones sont dessinés en
jaune avec une épaisseur de 4 pixels, et un lissage des lignes est appliqué pour rendre les
contours plus nets et agréables visuellement.
Cette ligne de code utilise la fonction cv2.putText d'OpenCV pour afficher du texte sur une
image. Dans ce cas, il s'agit d'afficher l'ID du marqueur détecté à une position donnée sur
l'image.
1. frame :
o Il s'agit de l'image sur laquelle le texte sera écrit. Cela peut être une image
capturée ou un flux vidéo sur lequel sont affichés les résultats de détection (par
exemple, les marqueurs ArUco détectés).
2. f"id: {ids[0]}" :
o Cette chaîne de caractères formatée affiche l'ID du marqueur. Ici, ids[0]
correspond au premier identifiant (ID) de la liste des marqueurs ArUco détectés.
Le texte affiché sera quelque chose comme "id: 23", où 23 est l'ID du marqueur.
Cela permet de visualiser directement l'ID du marqueur sur l'image ou la vidéo.
7
3. top_right :
o C'est la position (coordonnées x, y) dans l'image où le texte sera affiché.
top_right correspond à une variable qui définit l'emplacement en haut à droite
du marqueur ou à un point spécifique dans l'image.
4. cv2.FONT_HERSHEY_PLAIN :
o Il s'agit de la police utilisée pour le texte. Ici, la police FONT_HERSHEY_PLAIN
est une police simple, sans empattement, qui est souvent utilisée pour afficher
du texte clair et lisible.
5. 1.3 :
o Ce paramètre définit la taille ou l'échelle du texte. 1.3 signifie que le texte sera
affiché avec une échelle légèrement supérieure à sa taille par défaut. Cela ajuste
la grandeur des caractères à l'écran.
6. (200, 100, 0) :
o C'est la couleur du texte, exprimée sous forme de tuple (B, G, R), qui représente
les canaux Bleu, Vert et Rouge respectivement. (200, 100, 0) correspond à une
couleur spécifique qui se situe dans les teintes de bleu-orange.
7. 2 :
o Ce paramètre définit l'épaisseur du texte en pixels. Ici, l'épaisseur est de 2 pixels,
ce qui rend le texte plus visible et lisible.
8. cv2.LINE_AA :
o Ce paramètre définit le type de lissage à utiliser pour le texte. LINE_AA
(antialiasing) applique un lissage des bords pour rendre les contours des
caractères plus doux et éviter qu'ils paraissent pixellisés. Cela améliore la qualité
visuelle du texte.
Résumé : Cette ligne de code affiche le texte contenant l'ID du marqueur ArUco détecté, à
une position spécifique de l'image, avec une police simple et lisible. Le texte est affiché en
couleur bleu-orange avec une épaisseur de 2 pixels, et un lissage des contours est appliqué
pour garantir une meilleure qualité visuelle.