« Reconnaissance objet » : différence entre les versions

De Wiki TGE CSTwiki
Aller à la navigation Aller à la recherche
← Modification précédente
2182036 (discussion | contributions)
58 modifications
2182036 (discussion | contributions)
58 modifications
 
(47 versions intermédiaires par le même utilisateur non affichées)
Ligne 1 : Ligne 1 :
==Description du projet==
==Description du projet==
Le but final du projet est de détecter un lift dans une image de caméra de surveillance grâce à un modèle de reconnaissance d'objet pré-entrainé.
Le but du projet est de détecter un objet (dans notre cas, un chariot élévateur) dans une image provenant d'une caméra à l'aide d'un modèle de reconnaissance d'objets préentraîné. Lorsque le programme détecte un chariot élévateur, un gyrophare s'active afin d'avertir les travailleurs de sa présence. Le programme s'exécute sur un Raspberry Pi 5, un micro-ordinateur doté d'entrées et de sorties programmables. La caméra y est connectée directement par USB. Étant donné que les sorties du Raspberry Pi fonctionnent en 3,3 V CC, un relais est utilisé pour commander l'alimentation d'un gyrophare fonctionnant en 120 V CA.
Lorsque que le programme détectera un chariot élévateur, un gyrophare s'activera pour avertir les travailleurs.
Le programme se trouvera dans un Raspberry pi 5, un petit ordinateur avec des i/o programmables. La camera sera connectée dans celui-ci directement par USB.
:[[File:lift.png|800px]]
Comme les i/o du Raspberry pi fonctionne à 3.3v, nous utilisons un petit relais pour alimenter le gyrophare.


----
----
===Fonctionnement global===
===Fonctionnement global===
Le projet repose sur un seul fichier Python principal (main.py) qui gère simultanément la détection YOLO et le contrôle des sorties GPIO grâce à un système de thread séparé.
----
====Structure des fichiers====
Le dossier de projet est organisé en trois catégories selon leur utilisation.
:[[File:wikilayout.png|800px]]


Pour fonctionner, le projet a trois grande étapes


'''1. La programmation python.'''
:Le script Python utilise YOLO (You Only Look Once) de Ultralytics pour détecter des objets en temps réel à partir d’une image, d’un dossier, d’une vidéo ou d’une caméra USB.
{| class="wikitable"
:Il charge un modèle .pt, applique l’inférence sur chaque frame, affiche les boîtes englobantes avec le niveau de confiance et calcule le nombre d'image par seconde moyen.
! Fichier !! Rôle !! Catégorie
:Il permet aussi d’enregistrer la vidéo traitée et de compter le nombre d’objets détectés à chaque image.
|-
:Ce n'est pas ce programme qui est entrainé a reconnaitre un lift. Il fait seulement le paramétrer (afficher les boites, le degré de confiance et le nombre d'objet détecté.)
| main.py || Fichier principal — lance la détection YOLO et contrôle les GPIO || Exécution
|-
| modelv1_ncnn_model/ || Modèle YOLO converti au format NCNN (dossier) || Exécution
|-
| record.py || Enregistre une vidéo depuis la caméra USB || Création du dataset
|-
| extract_frames.py || Extrait des images d'une vidéo pour créer un dataset || Création du dataset
|-
| convert_ncnn.py || Convertit un modèle .pt au format NCNN || Conversion
|-
| modelv1.pt || Modèle YOLO original (format PyTorch) || Conversion
|}
----


'''2. Le fichier .pt (Pré-entrainée)'''
====Fichier Python principal (main.py)====
:Le modèle pré-entrainé c'est comme le cerveau du projet. Un modèle YOLO déjà entraîné (.pt) est une intelligence artificielle qui a déjà appris à reconnaître certains objets grâce à un entraînement préalable sur une grande quantité d’images.
 
Le fichier main.py gère l'image de la caméra en appliquant le modèle pré-entraîné sur chaque frame. Il affiche le nombre d'objets détectés, les FPS, le pourcentage de certitude et la boîte de détection de classe. La classe cible, le seuil de confiance et tous les paramètres sont configurables directement en haut du fichier.
'''3. Fichier de contrôle GPIO'''
:Le Raspberry pi 5 possède plusieurs pin programmable qui doivent être contrôler à l'aide d'un fichier. Les pins GPIO peuvent être soit une entrée ou une sortie. Le fichier fais aussi le liens entre les variables python et les pins.


Le programme supporte deux types de sources : une caméra USB ou un fichier vidéo, sélectionnable via la variable SOURCE en haut du fichier.
'''Paramètres configurables en haut du fichier :'''
{| class="wikitable"
! Paramètre !! Description !! Valeur par défaut
|-
| MODEL_PATH || Chemin vers le modèle YOLO (.pt ou dossier NCNN) || 'modelv1_ncnn_model'
|-
| SOURCE || Source vidéo — 'usb0' pour caméra, 'video.mp4' pour fichier || 'usb0'
|-
| CONFIANCE_MIN || Seuil de confiance minimum (0.0 à 1.0) || 0.5
|-
| CLASSE_CIBLE || Classe à détecter, ou 'any' pour toutes les classes || 'Forklift'
|-
| GPIO_PIN || Broche BCM de la sortie principale || 17
|-
| PIN_LUMIERE_DETECTION || Lumière qui suit le GPIO principal || 27
|-
| PIN_LUMIERE_STATUT || Lumière allumée au démarrage, éteinte à la fermeture || 22
|-
| DUREE_DETECTION || Secondes que la condition doit être maintenue avant activation || 2.0
|-
| DUREE_ACTIVATION || Secondes que le GPIO reste actif || 3.0
|-
| RESOLUTION || Résolution caméra et inférence || (640, 640)
|}
'''Note :''' La valeur de CLASSE_CIBLE est insensible à la casse. Écrire 'forklift', 'Forklift' ou 'FORKLIFT' donnera le même résultat.
----
----
====Création du modèle pre-trained====


Pour entraîner le modèle, il faut un dataset, c’est-à-dire une collection d’images déjà annotées.
====Contrôle GPIO====
Il existe deux options : le créer soi-même ou en utiliser un déjà disponible en ligne.
Voici la logique des entrées sorties pour notre projet a guise d'exemple.
Nous recommandons d’en prendre un déjà fait, car créer son propre dataset demande des milliers de photos et beaucoup de temps pour les annoter une par une.
La logique GPIO tourne dans un thread séparé en parallèle de la détection YOLO, ce qui évite tout ralentissement. Trois sorties sont disponibles :
:[[File:pin.jpg|800px]]


'''1. choisir le bon dataset'''
:Nous conseillons d'utiliser la plateforme RobotFlow sur internet pour trouver un dataset.
:Sur Roboflow, va dans l’onglet Universe (bibliothèque publique).
:Recherche avec des mots-clés précis (ex : “forklift”, “helmet detection”, etc.).
:Vérifie le nombre d’images, la diversité des photos et la qualité des annotations.
:Choisis un dataset avec plusieurs centaines ou milliers d’images bien étiquetées.
:Une fois le bon dataset trouvé, il reste juste à le télécharger en format zip.


'''2. Préparer le dataset à l'entrainnement.'''
:Une fois le fichier téléchargé, vous devez l'extraire à l'endroit de votre choix.
:Ensuite, vérifiez que le fichier contient les 3 élements  importants: data.yaml, train, valid.
:Si ces 3 éléments sont présents, tout est correct.


*'''GPIO principal (GPIO_PIN)''' — activé lorsque la classe cible est détectée pendant DUREE_DETECTION secondes.
*'''Lumière de détection (PIN_LUMIERE_DETECTION)''' — suit exactement le même comportement que le GPIO principal.
*'''Lumière de statut (PIN_LUMIERE_STATUT)''' — s'allume au démarrage du programme et s'éteint à la fermeture.
Si la condition est toujours vraie à la fin de DUREE_ACTIVATION, le GPIO se renouvelle automatiquement sans coupure. À la fermeture du programme (touche q ou Ctrl+C), toutes les sorties sont éteintes proprement.
----


'''3. Ajouter le yolo de base.'''
====Création du modèle pré-entraîné====
:Yolo (you only look once) possède des modèles de base pré entrainés généralisé et il est nécessaire d'ajouter une de ces version à notre dataset pour l’entrainement. Nous utilisons la version 11n qui est la version officielle la plus récente. Le n signifie nano. Il existe d'autres modèle plus performants, mais nous avons besoin de la version la plus lègerte pour fonctionner avec le Raspberry pi.  
pour l'ajouter au dataset, vous devez le télecharger à partir du site de yolo.
Un modèle YOLO pré-entraîné (.pt) est une intelligence artificielle qui a appris à reconnaître certains objets grâce à un entraînement préalable sur une grande quantité d'images. C'est le cerveau du projet.
Vous devez ensuite glisser le fichier téléchargé au meme endroit que les autres fichiers énumérés à l'étape 2.
'''1. Choisir le bon dataset'''
:Nous conseillons d'utiliser la plateforme Roboflow Universe pour trouver un dataset public.
:Rechercher avec des mots-clés précis (ex : "forklift", "helmet detection", etc.).
:Vérifier le nombre d'images, la diversité des photos et la qualité des annotations.
:Choisir un dataset avec plusieurs centaines ou milliers d'images bien étiquetées.
:Une fois le bon dataset trouvé, le télécharger en format ZIP.
'''Attention :''' Vérifier que le dataset contient des '''images nulles''' (images sans l'objet à détecter). Ces images sont essentielles pour éviter les faux positifs.
:Une fois extrait, vérifier que le dossier contient les 3 éléments importants : data.yaml, train/ et valid/.
'''2. Ajouter le modèle YOLO de base'''
:YOLO possède des modèles de base pré-entraînés. Nous utilisons la version '''yolo11n''' (nano), la plus légère pour fonctionner sur Raspberry Pi.
:Télécharger yolo11n.pt depuis le site officiel d'Ultralytics et le placer dans le même dossier que data.yaml.
:[[File:version_yolo.png|600px]]
:[[File:version_yolo.png|600px]]
'''3. Entraînement'''
:L'entraînement est recommandé sur un ordinateur Linux avec une carte graphique NVIDIA.
:Dans le terminal, entrer la commande :
: '''yolo detect train model=yolo11n.pt data=data.yaml epochs=100 imgsz=640 batch=16 patience=20'''
{| class="wikitable"
! Paramètre !! Description !! Valeur recommandée
|-
| model || Modèle de base pré-entraîné || yolo11n.pt
|-
| data || Fichier de configuration du dataset || data.yaml
|-
| epochs || Nombre de cycles d'apprentissage || 100
|-
| imgsz || Taille des images (maximum YOLO) || 640
|-
| batch || Images traitées simultanément (selon le GPU) || 16
|-
| patience || Arrête si plus d'amélioration || 20
|}
:Le modèle entraîné sera disponible dans runs/detect/train/weights/best.pt.
:Pour faire l'entraînement sur Windows, voici une vidéo de référence : https://www.youtube.com/watch?v=r0RspiLG260
'''Librairies requises pour l'entraînement :'''
*ultralytics
*torch et torchvision
*opencv-python
*python3
----
====Conversion NCNN (optimisation Raspberry Pi)====
Le format NCNN est optimisé pour les processeurs ARM comme celui du Raspberry Pi. La conversion du modèle .pt en format NCNN permet de passer de '''3 FPS à 12 FPS''' sur le Raspberry Pi 5. Cette étape est fortement recommandée.


'''4. Entrainnement'''
:Il est possible de faire l’entrainement sur Windows, mais comme nous on l'a fait sur Linux vous devrez faire vos recherches par vous-même pour le faire avec
: '''python3 convert_ncnn.py'''
:Windows.
:Le script génère un dossier modelv1_ncnn_model/ contenant tous les fichiers nécessaires.
:Dans main.py, changer MODEL_PATH pour pointer vers ce dossier au lieu du fichier .pt.


:https://www.youtube.com/watch?v=r0RspiLG260
'''Important :''' Effectuer la conversion sur le Raspberry Pi lui-même pour garantir la compatibilité.
----


 
====Créer son propre dataset personnalisé====
:Pour le faire sur Linux vous devez avoir téléchargé les librairies: ultralitics, pytorch, python3, pip, opencv.
:Maintenant, ouvres le terminal et entrez la commande: yolo detect train model=yolo11n.pt data=data.yaml epochs=X imgsz=X batch=X patience=x
Si le dataset public ne correspond pas suffisamment à l'environnement de production, il est possible d'améliorer le modèle en filmant sur place.
 
*model : modèle de base pré-entraîné utilisé pour commencer.
'''1.''' Filmer plusieurs courtes vidéos (5 à 15 minutes) dans différentes zones et conditions d'éclairage avec record.py.
 
*data : fichier qui indique où sont les images et les classes.
'''2.''' Extraire les frames automatiquement avec extract_frames.py — une image toutes les 3 secondes génère environ 200 à 300 images par vidéo.
 
*epochs : nombre de cycles d’apprentissage.
'''3.''' Annoter les images sur Roboflow en utilisant la fonction Auto-Label avec le modèle existant pour minimiser le travail manuel.
 
*imgsz : taille des images (640 si vous utiliser notre python).
'''4.''' Réentraîner le modèle avec le nouveau dataset.
 
*batch : nombre d’images traitées en même temps (selon le gpu).
'''Conseil :''' Filmer avec la même caméra USB que celle utilisée en production garantit que le modèle sera entraîné sur des images identiques à ce qu'il verra en temps réel.
 
*patience : arrête l’entraînement si le modèle n’améliore plus ses performances
----
 
 
====Installation des librairies====
:Faites vos recherches pour remplacer les x par les bonnes valeurs selon vos besoins ( Dépendement, de votre nombre d'images et votre application) .
 
'''Sur le Raspberry Pi 5 (exécution) :'''
 
 
: pip install torch torchvision --index-url <nowiki>https://download.pytorch.org/whl/cpu</nowiki> --break-system-packages --no-cache-dir
:Ensuite, vous exécutez la commande et votre ordinateur lance l’entraînement du modèle, ce qui peut prendre plusieurs heures selon la puissance de votre machine et la taille du dataset.Une erreur possible est que votre processeur ou votre environnement ne dispose pas des bibliothèques logicielles nécessaires pour exécuter l’entraînement. Ce :problème est plus fréquent sur des ordinateurs plus anciens ou lorsque certaines dépendances ne sont pas correctement installées.
: pip install ultralytics opencv-python lgpio ncnn pnnx --break-system-packages --no-cache-dir
'''Sur un ordinateur Linux (entraînement et conversion) :'''
: pip install ultralytics torch torchvision opencv-python ncnn pnnx
{| class="wikitable"
! Librairie !! Rôle !! Pi 5 !! PC Linux
|-
| ultralytics || Modèle YOLO || ✓ || ✓
|-
| torch / torchvision || Moteur d'apprentissage PyTorch || ✓ || ✓
|-
| opencv-python || Capture et affichage vidéo || ✓ || ✓
|-
| lgpio || Contrôle des broches GPIO || ✓ || ✗
|-
| ncnn / pnnx || Conversion et inférence NCNN || ✓ || ✓
|-
| numpy || Calculs mathématiques (inclus automatiquement) || ✓ || ✓
|}
----
====Liste de matériel====
*Raspberry Pi 5 (8 Go recommandé, 4 Go minimum)
*Carte microSD classe A2, 32 Go minimum (SanDisk ou Samsung Endurance recommandé)
*Câble d'alimentation USB-C 5V/5A (27W) — câble officiel Raspberry Pi 5 obligatoire
*Caméra USB type A
*Relais 5V (module 1 canal)
*Gyrophare 120V CA
*Câbles Dupont mâle-femelle (connexions GPIO)
*Câble micro HDMI (optionnel — pour connecter un écran)
'''Attention :''' Toujours éteindre le Raspberry Pi proprement avec la commande '''sudo shutdown -h now''' avant de couper l'alimentation. Une coupure brusque peut corrompre la carte microSD.

Dernière version du 29 mars 2026 à 21:45

Description du projet

Le but du projet est de détecter un objet (dans notre cas, un chariot élévateur) dans une image provenant d'une caméra à l'aide d'un modèle de reconnaissance d'objets préentraîné. Lorsque le programme détecte un chariot élévateur, un gyrophare s'active afin d'avertir les travailleurs de sa présence. Le programme s'exécute sur un Raspberry Pi 5, un micro-ordinateur doté d'entrées et de sorties programmables. La caméra y est connectée directement par USB. Étant donné que les sorties du Raspberry Pi fonctionnent en 3,3 V CC, un relais est utilisé pour commander l'alimentation d'un gyrophare fonctionnant en 120 V CA.

Fonctionnement global

Le projet repose sur un seul fichier Python principal (main.py) qui gère simultanément la détection YOLO et le contrôle des sorties GPIO grâce à un système de thread séparé.


Structure des fichiers

Le dossier de projet est organisé en trois catégories selon leur utilisation.


Fichier Rôle Catégorie
main.py Fichier principal — lance la détection YOLO et contrôle les GPIO Exécution
modelv1_ncnn_model/ Modèle YOLO converti au format NCNN (dossier) Exécution
record.py Enregistre une vidéo depuis la caméra USB Création du dataset
extract_frames.py Extrait des images d'une vidéo pour créer un dataset Création du dataset
convert_ncnn.py Convertit un modèle .pt au format NCNN Conversion
modelv1.pt Modèle YOLO original (format PyTorch) Conversion

Fichier Python principal (main.py)

Le fichier main.py gère l'image de la caméra en appliquant le modèle pré-entraîné sur chaque frame. Il affiche le nombre d'objets détectés, les FPS, le pourcentage de certitude et la boîte de détection de classe. La classe cible, le seuil de confiance et tous les paramètres sont configurables directement en haut du fichier.


Le programme supporte deux types de sources : une caméra USB ou un fichier vidéo, sélectionnable via la variable SOURCE en haut du fichier.

Paramètres configurables en haut du fichier :

Paramètre Description Valeur par défaut
MODEL_PATH Chemin vers le modèle YOLO (.pt ou dossier NCNN) 'modelv1_ncnn_model'
SOURCE Source vidéo — 'usb0' pour caméra, 'video.mp4' pour fichier 'usb0'
CONFIANCE_MIN Seuil de confiance minimum (0.0 à 1.0) 0.5
CLASSE_CIBLE Classe à détecter, ou 'any' pour toutes les classes 'Forklift'
GPIO_PIN Broche BCM de la sortie principale 17
PIN_LUMIERE_DETECTION Lumière qui suit le GPIO principal 27
PIN_LUMIERE_STATUT Lumière allumée au démarrage, éteinte à la fermeture 22
DUREE_DETECTION Secondes que la condition doit être maintenue avant activation 2.0
DUREE_ACTIVATION Secondes que le GPIO reste actif 3.0
RESOLUTION Résolution caméra et inférence (640, 640)

Note : La valeur de CLASSE_CIBLE est insensible à la casse. Écrire 'forklift', 'Forklift' ou 'FORKLIFT' donnera le même résultat.

Contrôle GPIO

Voici la logique des entrées sorties pour notre projet a guise d'exemple. La logique GPIO tourne dans un thread séparé en parallèle de la détection YOLO, ce qui évite tout ralentissement. Trois sorties sont disponibles :


  • GPIO principal (GPIO_PIN) — activé lorsque la classe cible est détectée pendant DUREE_DETECTION secondes.
  • Lumière de détection (PIN_LUMIERE_DETECTION) — suit exactement le même comportement que le GPIO principal.
  • Lumière de statut (PIN_LUMIERE_STATUT) — s'allume au démarrage du programme et s'éteint à la fermeture.

Si la condition est toujours vraie à la fin de DUREE_ACTIVATION, le GPIO se renouvelle automatiquement sans coupure. À la fermeture du programme (touche q ou Ctrl+C), toutes les sorties sont éteintes proprement.

Création du modèle pré-entraîné

Un modèle YOLO pré-entraîné (.pt) est une intelligence artificielle qui a appris à reconnaître certains objets grâce à un entraînement préalable sur une grande quantité d'images. C'est le cerveau du projet.

1. Choisir le bon dataset

Nous conseillons d'utiliser la plateforme Roboflow Universe pour trouver un dataset public.
Rechercher avec des mots-clés précis (ex : "forklift", "helmet detection", etc.).
Vérifier le nombre d'images, la diversité des photos et la qualité des annotations.
Choisir un dataset avec plusieurs centaines ou milliers d'images bien étiquetées.
Une fois le bon dataset trouvé, le télécharger en format ZIP.

Attention : Vérifier que le dataset contient des images nulles (images sans l'objet à détecter). Ces images sont essentielles pour éviter les faux positifs.

Une fois extrait, vérifier que le dossier contient les 3 éléments importants : data.yaml, train/ et valid/.

2. Ajouter le modèle YOLO de base

YOLO possède des modèles de base pré-entraînés. Nous utilisons la version yolo11n (nano), la plus légère pour fonctionner sur Raspberry Pi.
Télécharger yolo11n.pt depuis le site officiel d'Ultralytics et le placer dans le même dossier que data.yaml.

3. Entraînement

L'entraînement est recommandé sur un ordinateur Linux avec une carte graphique NVIDIA.
Dans le terminal, entrer la commande :
yolo detect train model=yolo11n.pt data=data.yaml epochs=100 imgsz=640 batch=16 patience=20
Paramètre Description Valeur recommandée
model Modèle de base pré-entraîné yolo11n.pt
data Fichier de configuration du dataset data.yaml
epochs Nombre de cycles d'apprentissage 100
imgsz Taille des images (maximum YOLO) 640
batch Images traitées simultanément (selon le GPU) 16
patience Arrête si plus d'amélioration 20
Le modèle entraîné sera disponible dans runs/detect/train/weights/best.pt.
Pour faire l'entraînement sur Windows, voici une vidéo de référence : https://www.youtube.com/watch?v=r0RspiLG260

Librairies requises pour l'entraînement :

  • ultralytics
  • torch et torchvision
  • opencv-python
  • python3

Conversion NCNN (optimisation Raspberry Pi)

Le format NCNN est optimisé pour les processeurs ARM comme celui du Raspberry Pi. La conversion du modèle .pt en format NCNN permet de passer de 3 FPS à 12 FPS sur le Raspberry Pi 5. Cette étape est fortement recommandée.


python3 convert_ncnn.py
Le script génère un dossier modelv1_ncnn_model/ contenant tous les fichiers nécessaires.
Dans main.py, changer MODEL_PATH pour pointer vers ce dossier au lieu du fichier .pt.


Important : Effectuer la conversion sur le Raspberry Pi lui-même pour garantir la compatibilité.

Créer son propre dataset personnalisé

Si le dataset public ne correspond pas suffisamment à l'environnement de production, il est possible d'améliorer le modèle en filmant sur place.

1. Filmer plusieurs courtes vidéos (5 à 15 minutes) dans différentes zones et conditions d'éclairage avec record.py.

2. Extraire les frames automatiquement avec extract_frames.py — une image toutes les 3 secondes génère environ 200 à 300 images par vidéo.

3. Annoter les images sur Roboflow en utilisant la fonction Auto-Label avec le modèle existant pour minimiser le travail manuel.

4. Réentraîner le modèle avec le nouveau dataset.

Conseil : Filmer avec la même caméra USB que celle utilisée en production garantit que le modèle sera entraîné sur des images identiques à ce qu'il verra en temps réel.

Installation des librairies

Sur le Raspberry Pi 5 (exécution) :

pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu --break-system-packages --no-cache-dir
pip install ultralytics opencv-python lgpio ncnn pnnx --break-system-packages --no-cache-dir

Sur un ordinateur Linux (entraînement et conversion) :

pip install ultralytics torch torchvision opencv-python ncnn pnnx
Librairie Rôle Pi 5 PC Linux
ultralytics Modèle YOLO ✓ ✓
torch / torchvision Moteur d'apprentissage PyTorch ✓ ✓
opencv-python Capture et affichage vidéo ✓ ✓
lgpio Contrôle des broches GPIO ✓ ✗
ncnn / pnnx Conversion et inférence NCNN ✓ ✓
numpy Calculs mathématiques (inclus automatiquement) ✓ ✓

Liste de matériel

  • Raspberry Pi 5 (8 Go recommandé, 4 Go minimum)
  • Carte microSD classe A2, 32 Go minimum (SanDisk ou Samsung Endurance recommandé)
  • Câble d'alimentation USB-C 5V/5A (27W) — câble officiel Raspberry Pi 5 obligatoire
  • Caméra USB type A
  • Relais 5V (module 1 canal)
  • Gyrophare 120V CA
  • Câbles Dupont mâle-femelle (connexions GPIO)
  • Câble micro HDMI (optionnel — pour connecter un écran)

Attention : Toujours éteindre le Raspberry Pi proprement avec la commande sudo shutdown -h now avant de couper l'alimentation. Une coupure brusque peut corrompre la carte microSD.

Récupérée de "https://wiki.tge.cegeplabs.qc.ca/index.php?title=Reconnaissance_objet&oldid=1042"