http://wikigeii.iut-troyes.univ-reims.fr//api.php?action=feedcontributions&feedformat=atom&user=FredmntroyesGEII - Contributions de l’utilisateur [fr]2026-05-06T23:41:06ZContributions de l’utilisateurMediaWiki 1.30.1http://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Elen4_TNS&diff=20964Cours:Elen4 TNS2026-05-04T14:56:09Z<p>Fredmn : /* Travaux Pratiques */</p>
<hr />
<div><center><br />
'''<big>S4 - ESE - Traitement numérique du signal</big>'''<br />
</center><br />
<br />
== Description générale ==<br />
<br />
=== Contenu (Programme National) ===<br />
<br />
Filtrage numérique :<br />
* Équation de récurrence, opérations élémentaires, fonction de transfert en Z, passage à un programme informatique;<br />
* Filtre numérique : filtres récursif et non récursif, réponses temporelles (impulsionnelle, indicielle, signal quelconque), réponse fréquentielle, stabilité;<br />
* Synthèse de filtres numériques simples (approximation d’Euler);<br />
* Utilisation d’outils de synthèse des filtres numériques RIF et RII (Matlab, Labview, GNU radio...) et comparaison des performances des filtres RIF et RII;<br />
* Présentation des différentes structures des filtres numériques (direct, cascade, parallèle);<br />
* Implantation d’un traitement numérique sur cible : filtrage numérique simple, asservissement numérique simple (robot mobile, drone...), traitement de données.<br />
<br />
=== Volumes horaire ===<br />
<br />
* CM : 4 séances d'1,5h<br />
* TD : 6 séances d'1,5h + une évaluation d'1,5h<br />
* TP : 6 séances de 3h + une évaluation de 2h<br />
<br />
=== Évaluations ===<br />
<br />
* une évaluation sur table (derniere séance de CM/TD - 1,5h)<br />
* une évaluation pratique (dernière séance de TP - 2h)<br />
<br />
== Cours Magistraux ==<br />
<br />
Contenu :<br />
* Signaux et systèmes numériques<br />
* Filtres numériques<br />
* Quelques filtres RIF<br />
* Synthèse de filtres numériques<br />
* PID numérique <br />
* Élements sur le traitement des images numériques<br />
* Élements sur le temps-fréquence<br />
<br />
<br /><br />
Documents :<br />
* [[Media:TNS-Support.pdf|Support de cours en pdf]]<br />
* [[Media:TNS-diapos.pdf|Diapositives de cours en pdf]]<br />
<br />
== Travaux Dirigés ==<br />
<br />
Textes en pdf :<br />
<br />
* [[Media:TNS-td1.FxTransfert.pdf|TD1 : Fonctions de transfert]]<br />
* [[Media:TNS-td2.Stabilité.pdf|TD2 : Causabilité et stabilité]]<br />
* [[Media:TNS-td3.RepFreq.pdf|TD3 : Réponses fréquentielles]]<br />
* [[Media:TNS-td4.Facteurs1et2.pdf|TD4 : Facteurs du premier et du second ordre]]<br />
* [[Media:TNS-td5-Structures.pdf|TD5 : Structures de réalisation]]<br />
* [[Media:TNS-td6-ConceptionFiltresRII.pdf|TD6 : Conception de filtres récursifs]]<br />
* Évaluation<br />
<br />
== Travaux Pratiques ==<br />
<br />
Les TP utiliserons principalement :<br />
* Gnuradio (cf premier TP)<br />
* Matlab, que vous pourrez utiliser en ligne avec votre compte universitaire : [https://fr.mathworks.com/products/matlab-online.html Matlab online]<br />
* Python, que nous utiliserons en installation locale avec [https://pixi.prefix.dev/ Pixi]<br />
* et occasionnellement des cartes Arduinio ou Rpi Pico.<br />
<br/><br />
* Guide de travail avec Python<br />
<br/><br />
Liste des TP :<br />
* [[Cours:Elen4_TNS_TP_Gnuradio|TP1 - Fondamentaux Gnuradio]]<br />
* [[Cours:Elen4_TNS_TP_FxTransfertStabilité|TP2 - Fonction de transfert et stabilité]]<br />
* [[Cours:Elen4_TNS_TP_Implementations|TP3 - Implémentations de filtres]]<br />
* [[Cours:Elen4_TNS_TP_TraitImage|TP4 - Traitements d'images numériques]]<br />
* [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation| TP5 - Traitements audio et démodulation]]<br />
* [[Cours:Elen4_TNS_TP_ TpsReel |TP6 - Temps réel - Codage d'un bloc en Python]]<br />
* Évaluation<br />
<br />
== Évaluation de Travaux Pratiques ==<br />
<br />
Énoncés :<br />
* [[Cours:Elen4_TNS_TP_eval1|Sujet n°1]]<br />
<br />
Documents autorisés :<br />
* accès au wiki<br />
* documents de cours<br />
* notes personnelles</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Elen4_TNS_TP_TpsReel&diff=20963Cours:Elen4 TNS TP TpsReel2026-05-04T14:53:44Z<p>Fredmn : </p>
<hr />
<div>[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]<br />
<br />
<center><br />
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation </big>'''<br />
</center><br />
<br />
'''EN COURS DE RÉÉCRITURE (C++ vers Python)'''<br />
<br />
<br />
Le but de ce TP est de réaliser l'implémentation temps-réel en C++ de filtres IIR. Cette implémentation sera réalisée en créant un bloc Gnuradio qui execute un traitement codé en C++<br />
<br />
=== Codage de bloc Gnuradio en c++ ===<br />
<br />
Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :<br />
<br />
Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.<br />
<br />
'''Suivez bien toutes les étapes, sans aller trop rapidement'''<br />
<br />
* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.<br />
<br />
==== Création d'un module externe ====<br />
<br />
Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.<br />
<br />
* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :<br />
<source><br />
$ cd $HOME<br />
</source><br />
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :<br />
<source><br />
$ mkdir gnuradio<br />
$ cd gnuradio<br />
</source><br />
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code><br />
<source><br />
$ gr_modtool newmod monModule<br />
</source><br />
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :<br />
<source><br />
$ cd gr-monModule<br />
</source><br />
* Vous pouvez afficher le contenu de ce dossier par<br />
<source><br />
$ ls<br />
</source><br />
<br />
==== Création d'un bloc dans ce module ====<br />
<br />
* Ajoutez un nouveau bloc nommé <code>passetout</code> :<br />
<source><br />
$ gr_modtool add passetout<br />
</source><br />
* Quelques questions permettent alors de spécifier le type de bloc<br />
<source><br />
GNU Radio module name identified: passetout<br />
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')<br />
</source><br />
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.<br />
<source><br />
Enter block type: sync<br />
</source><br />
* Spécifiez <code>cpp</code> comme langage :<br />
<source><br />
Language (python/cpp): cpp<br />
Language: C++<br />
Block/code identifier: passetout<br />
</source><br />
* Spécifiez un nom pour le copyright :<br />
<source><br />
Please specify the copyright holder: Bibi<br />
</source><br />
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :<br />
<source><br />
Enter valid argument list, including default arguments: <br />
</source><br />
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :<br />
<source><br />
Add Python QA code? [Y/n] n<br />
Add C++ QA code? [Y/n] n<br />
</source><br />
* Plusieurs fichers sont alors crées :<br />
<source><br />
Adding file 'lib/passetout_impl.h'...<br />
Adding file 'lib/passetout_impl.cc'...<br />
Adding file 'include/gnuradio/monModule/passetout.h'...<br />
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...<br />
Adding file 'python/monModule/bindings/passetout_python.cc'...<br />
Adding file 'grc/monModule_passetout.block.yml'...<br />
Editing grc/CMakeLists.txt...<br />
</source><br />
<br />
Quelques indications :<br />
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc<br />
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc<br />
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio<br />
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.<br />
<br />
==== Fichier <code>passetout_impl.h</code> ====<br />
<br />
Le code utile généré est le suivant :<br />
<source lang=cpp><br />
class passetout_impl : public passetout<br />
{<br />
private:<br />
// Nothing to declare in this block.<br />
<br />
public:<br />
passetout_impl();<br />
~passetout_impl();<br />
<br />
// Where all the action really happens<br />
int work(int noutput_items,<br />
gr_vector_const_void_star& input_items,<br />
gr_vector_void_star& output_items);<br />
};<br />
</source><br />
<br />
Pour se réveiller les neurones sur la POO, qu'est-ce que sont<br />
* <code>passetout_impl()</code>,<br />
* <code>~passetout_impl()</code>,<br />
* <code>private</code>, <code>public</code> ?<br />
<br />
Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.<br />
<br />
==== Fichier <code>passetout_impl.cc</code> ====<br />
<br />
Le code utile généré est le suivant :<br />
<br />
{{boîte déroulante/début|titre=passetout_impl.cc}}<br />
<source lang=cpp><br />
namespace monModule {<br />
<br />
#pragma message("set the following appropriately and remove this warning")<br />
using input_type = float;<br />
#pragma message("set the following appropriately and remove this warning")<br />
using output_type = float;<br />
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }<br />
<br />
<br />
/*<br />
* The private constructor<br />
*/<br />
passetout_impl::passetout_impl()<br />
: gr::sync_block("passetout",<br />
gr::io_signature::make(<br />
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),<br />
gr::io_signature::make(<br />
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))<br />
{<br />
}<br />
<br />
/*<br />
* Our virtual destructor.<br />
*/<br />
passetout_impl::~passetout_impl() {}<br />
<br />
int passetout_impl::work(int noutput_items,<br />
gr_vector_const_void_star& input_items,<br />
gr_vector_void_star& output_items)<br />
{<br />
auto in = static_cast<const input_type*>(input_items[0]);<br />
auto out = static_cast<output_type*>(output_items[0]);<br />
<br />
#pragma message("Implement the signal processing in your block and remove this warning")<br />
// Do <+signal processing+><br />
<br />
// Tell runtime system how many output items we produced.<br />
return noutput_items;<br />
}<br />
<br />
} /* namespace monModule */<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
Détaillons :<br />
<source lang=cpp><br />
#pragma message("set the following appropriately and remove this warning")<br />
using input_type = float;<br />
#pragma message("set the following appropriately and remove this warning")<br />
using output_type = float;<br />
</source><br />
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}<br />
<br />
<source lang=cpp><br />
passetout_impl::passetout_impl()<br />
: gr::sync_block("passetout",<br />
gr::io_signature::make(<br />
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),<br />
gr::io_signature::make(<br />
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))<br />
{<br />
}<br />
</source><br />
<br />
{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}<br />
<br />
{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}<br />
<br />
<source lang=cpp><br />
int passetout_impl::work(int noutput_items,<br />
gr_vector_const_void_star& input_items,<br />
gr_vector_void_star& output_items)<br />
{<br />
auto in = static_cast<const input_type*>(input_items[0]);<br />
auto out = static_cast<output_type*>(output_items[0]);<br />
<br />
#pragma message("Implement the signal processing in your block and remove this warning")<br />
// Do <+signal processing+><br />
<br />
// Tell runtime system how many output items we produced.<br />
return noutput_items;<br />
}<br />
</source><br />
Cette méthode <code>work()</code> implémente véritablement le filtrage.<br />
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code><br />
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.<br />
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code><br />
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}<br />
# Enlever la ligne <code>#pragma</code><br />
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)<br />
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).<br />
<br />
==== Fichier <code>monModule_passetout.block.yml</code> ====<br />
<br />
Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.<br />
<br />
{{boîte déroulante/début|titre=monModule_passetout.block.yml}}<br />
<source lang=yaml><br />
id: monModule_passetout<br />
label: passetout<br />
category: '[monModule]'<br />
<br />
templates:<br />
imports: from gnuradio import monModule<br />
make: monModule.passetout()<br />
<br />
# Make one 'parameters' list entry for every parameter you want settable from the GUI.<br />
# Keys include:<br />
# * id (makes the value accessible as keyname, e.g. in the make entry)<br />
# * label (label shown in the GUI)<br />
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)<br />
# * default<br />
parameters:<br />
- id: parametername_replace_me<br />
label: FIX ME:<br />
dtype: string<br />
default: You need to fill in your grc/monModule_passetout.block.yaml<br />
#- id: ...<br />
# label: ...<br />
# dtype: ...<br />
<br />
# Make one 'inputs' list entry per input and one 'outputs' list entry per output.<br />
# Keys include:<br />
# * label (an identifier for the GUI)<br />
# * domain (optional - stream or message. Default is stream)<br />
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)<br />
# * vlen (optional - data stream vector length. Default is 1)<br />
# * optional (optional - set to 1 for optional inputs. Default is 0)<br />
inputs:<br />
#- label: ...<br />
# domain: ...<br />
# dtype: ...<br />
# vlen: ...<br />
# optional: ...<br />
<br />
outputs:<br />
#- label: ...<br />
# domain: ...<br />
# dtype: ...<br />
# vlen: ...<br />
# optional: ...<br />
<br />
# 'file_format' specifies the version of the GRC yml format used in the file<br />
# and should usually not be changed.<br />
file_format: 1<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}<br />
<br />
<source lang=yaml><br />
#parameters:<br />
#- id: parametername_replace_me<br />
# label: FIX ME:<br />
# dtype: string<br />
# default: You need to fill in your grc/customModule_testMod.block.yaml<br />
</source><br />
<br />
{{Todos| Mettre à jour la section <code>inputs</code> :}}<br />
<br />
<source lang=yaml><br />
inputs:<br />
- label: in<br />
domain: stream<br />
dtype: float<br />
</source><br />
<br />
{{Todos| Mettre à jour la section <code>output</code> :}}<br />
<br />
<source lang=yaml><br />
outputs:<br />
- label: out<br />
domain: stream<br />
dtype: float<br />
</source><br />
<br />
==== Compilation et installation ====<br />
<br />
Voici les étapes :<br />
<source lang=bash><br />
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule<br />
$ mkdir build<br />
$ cd build<br />
$ cmake ..<br />
$ make<br />
$ make install<br />
</source><br />
<br />
* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation<br />
* <code>make</code> lance la compilation<br />
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)<br />
<br />
{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}<br />
<br />
{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :<br />
<source><br />
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH<br />
$ gnuradio-companion &<br />
</source><br />
<br />
==== Utilisation du bloc et test ====<br />
<br />
* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')<br />
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code><br />
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.<br />
<br />
=== Démodulation ===<br />
<br />
En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :<br />
<br />
* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.<br />
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :<br />
** de type <code>sync</code><br />
** une entrée en <code>float</code><br />
** une sortie en <code>float</code><br />
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :<br />
** ''x(n)'' est donné par <code>in0[0]</code><br />
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.<br />
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.<br />
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.<br />
<br />
{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}<br />
<br />
{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Elen4_TNS_TP_TpsReel&diff=20962Cours:Elen4 TNS TP TpsReel2026-05-04T14:52:12Z<p>Fredmn : </p>
<hr />
<div>[[Cours:Elen4_TNS|{{Rouge|'''Retour à la page du cours'''}}]]<br />
<br />
<center><br />
'''<big>TP6 : Temps réel : Codage d'un bloc en Python / démodulation </big>'''<br />
</center><br />
<br />
Le but de ce TP est de réaliser l'implémentation temps-réel en C++ de filtres IIR. Cette implémentation sera réalisée en créant un bloc Gnuradio qui execute un traitement codé en C++<br />
<br />
=== Codage de bloc Gnuradio en c++ ===<br />
<br />
Ce guide est inspirée du guide [https://wiki.gnuradio.org/index.php?title=Creating_C%2B%2B_OOT_with_gr-modtool Creating an OOT (C++ block example)] en l'adaptant pour nos besoins :<br />
<br />
Nous allons créer un simple bloc qui recopie son entrée (en <code>float</code>) sur sa sortie. Donc le filtre caractérisé par ''y(n)'' = ''x(n)'' ou encore ''H(z)''=1. Il s'agit donc d'une sorte de filtre passe-tout.<br />
<br />
'''Suivez bien toutes les étapes, sans aller trop rapidement'''<br />
<br />
* Vous pourrez utiliser <code>gedit</code> pour éditer les divers fichiers.<br />
<br />
==== Création d'un module externe ====<br />
<br />
Dans les lignes qui suivent, le <code>$</code> indique que l'on saisi une commande dans un terminal. Le <code>$</code> n'est pas à saisir.<br />
<br />
* Ouvrez un terminal et placez-vous à la racine de votre dossier personnel :<br />
<source><br />
$ cd $HOME<br />
</source><br />
* Créez un dossier de travail dédié à gnuradio et déplacez-vous à l'intérieur :<br />
<source><br />
$ mkdir gnuradio<br />
$ cd gnuradio<br />
</source><br />
* GNU Radio est livré avec gr_modtool, un utilitaire qui permet de créer des modules externes (OOT). Créons un module <code>monModule</code><br />
<source><br />
$ gr_modtool newmod monModule<br />
</source><br />
* Le dossier <code>gr-monModule</code> est créé et contient tout le code squelette d'un module OOT, mais il n'a pas encore de blocs. Déplacez-vous dans <code>gr-monModule</code> :<br />
<source><br />
$ cd gr-monModule<br />
</source><br />
* Vous pouvez afficher le contenu de ce dossier par<br />
<source><br />
$ ls<br />
</source><br />
<br />
==== Création d'un bloc dans ce module ====<br />
<br />
* Ajoutez un nouveau bloc nommé <code>passetout</code> :<br />
<source><br />
$ gr_modtool add passetout<br />
</source><br />
* Quelques questions permettent alors de spécifier le type de bloc<br />
<source><br />
GNU Radio module name identified: passetout<br />
('sink', 'source', 'sync', 'decimator', 'interpolator', 'general', 'tagged_stream', 'hier', 'noblock')<br />
</source><br />
Saisissez <code>sync</code> comme type de bloc, car le bloc que nous écrivons produira le même nombre d'échantillons en sortie que le nombre d'échantillons consommés depuis l'entrée.<br />
<source><br />
Enter block type: sync<br />
</source><br />
* Spécifiez <code>cpp</code> comme langage :<br />
<source><br />
Language (python/cpp): cpp<br />
Language: C++<br />
Block/code identifier: passetout<br />
</source><br />
* Spécifiez un nom pour le copyright :<br />
<source><br />
Please specify the copyright holder: Bibi<br />
</source><br />
* Il est possible de spécifier des paramètres d'entrée qui peuvent permettre de régler le fonctionnement du bloc. Ce ne sera pas notre cas, ne rien saisir sur cette question :<br />
<source><br />
Enter valid argument list, including default arguments: <br />
</source><br />
* De même, on ne donnera pas de code permettant de tester le bon fonctionnement :<br />
<source><br />
Add Python QA code? [Y/n] n<br />
Add C++ QA code? [Y/n] n<br />
</source><br />
* Plusieurs fichers sont alors crées :<br />
<source><br />
Adding file 'lib/passetout_impl.h'...<br />
Adding file 'lib/passetout_impl.cc'...<br />
Adding file 'include/gnuradio/monModule/passetout.h'...<br />
Adding file 'python/monModule/bindings/docstrings/passetout_pydoc_template.h'...<br />
Adding file 'python/monModule/bindings/passetout_python.cc'...<br />
Adding file 'grc/monModule_passetout.block.yml'...<br />
Editing grc/CMakeLists.txt...<br />
</source><br />
<br />
Quelques indications :<br />
* le fichier <code>passetout_impl.h</code> contient l'entête de la classe de notre bloc<br />
* le fichier <code>passetout_impl.cc</code> contient l'implémentation de la classe de notre bloc<br />
* le fichier <code>monModule_passetout.block.yml</code> va contenir des informations faisant le lien entre notre code c++ et le code python utilisé en interne par Gnuradio<br />
* Le tout sera compilé par un <code>Makefile</code> généré par <code>cmake</code>.<br />
<br />
==== Fichier <code>passetout_impl.h</code> ====<br />
<br />
Le code utile généré est le suivant :<br />
<source lang=cpp><br />
class passetout_impl : public passetout<br />
{<br />
private:<br />
// Nothing to declare in this block.<br />
<br />
public:<br />
passetout_impl();<br />
~passetout_impl();<br />
<br />
// Where all the action really happens<br />
int work(int noutput_items,<br />
gr_vector_const_void_star& input_items,<br />
gr_vector_void_star& output_items);<br />
};<br />
</source><br />
<br />
Pour se réveiller les neurones sur la POO, qu'est-ce que sont<br />
* <code>passetout_impl()</code>,<br />
* <code>~passetout_impl()</code>,<br />
* <code>private</code>, <code>public</code> ?<br />
<br />
Le travail sera réalisé dans la méthode <code>work()</code>, mais nous n'avons pas de modification à apporter dans les déclarations par défaut.<br />
<br />
==== Fichier <code>passetout_impl.cc</code> ====<br />
<br />
Le code utile généré est le suivant :<br />
<br />
{{boîte déroulante/début|titre=passetout_impl.cc}}<br />
<source lang=cpp><br />
namespace monModule {<br />
<br />
#pragma message("set the following appropriately and remove this warning")<br />
using input_type = float;<br />
#pragma message("set the following appropriately and remove this warning")<br />
using output_type = float;<br />
passetout::sptr passetout::make() { return gnuradio::make_block_sptr<passetout_impl>(); }<br />
<br />
<br />
/*<br />
* The private constructor<br />
*/<br />
passetout_impl::passetout_impl()<br />
: gr::sync_block("passetout",<br />
gr::io_signature::make(<br />
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),<br />
gr::io_signature::make(<br />
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))<br />
{<br />
}<br />
<br />
/*<br />
* Our virtual destructor.<br />
*/<br />
passetout_impl::~passetout_impl() {}<br />
<br />
int passetout_impl::work(int noutput_items,<br />
gr_vector_const_void_star& input_items,<br />
gr_vector_void_star& output_items)<br />
{<br />
auto in = static_cast<const input_type*>(input_items[0]);<br />
auto out = static_cast<output_type*>(output_items[0]);<br />
<br />
#pragma message("Implement the signal processing in your block and remove this warning")<br />
// Do <+signal processing+><br />
<br />
// Tell runtime system how many output items we produced.<br />
return noutput_items;<br />
}<br />
<br />
} /* namespace monModule */<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
Détaillons :<br />
<source lang=cpp><br />
#pragma message("set the following appropriately and remove this warning")<br />
using input_type = float;<br />
#pragma message("set the following appropriately and remove this warning")<br />
using output_type = float;<br />
</source><br />
{{Todos| On spécifie ici le type des données d'entrée et de sortie. Pas de modification à apporter, il suffit de supprimer les deux <code>#pragma</code>}}<br />
<br />
<source lang=cpp><br />
passetout_impl::passetout_impl()<br />
: gr::sync_block("passetout",<br />
gr::io_signature::make(<br />
1 /* min inputs */, 1 /* max inputs */, sizeof(input_type)),<br />
gr::io_signature::make(<br />
1 /* min outputs */, 1 /*max outputs */, sizeof(output_type)))<br />
{<br />
}<br />
</source><br />
<br />
{{Todos| On spécifie ici le nombre d'entrées (1) et le nombre de sorties (1). Pas de modification non plus.}}<br />
<br />
{{Todos| Expliquez la syntaxe <code>passetout_impl::passetout_impl() : gr::sync_block(...)"</code> }}<br />
<br />
<source lang=cpp><br />
int passetout_impl::work(int noutput_items,<br />
gr_vector_const_void_star& input_items,<br />
gr_vector_void_star& output_items)<br />
{<br />
auto in = static_cast<const input_type*>(input_items[0]);<br />
auto out = static_cast<output_type*>(output_items[0]);<br />
<br />
#pragma message("Implement the signal processing in your block and remove this warning")<br />
// Do <+signal processing+><br />
<br />
// Tell runtime system how many output items we produced.<br />
return noutput_items;<br />
}<br />
</source><br />
Cette méthode <code>work()</code> implémente véritablement le filtrage.<br />
* Les tableaux <code>in</code> et <code>out</code> contiennent respectivement les données en entrée et les données en sortie. Il faut donc calculer <code>out</code> en fonction de <code>in</code><br />
* Les données d'entrée arrivent par paquets dans un buffer. La variable <code>noutput_items</code> contient le nombre de données disponibles en entrées.<br />
* à la fin de la méthode, on renvoie le nombre de données en sortie que l'on a calculé (entre 1 et <code>noutput_items</code>). Les données d'entrées éventuellement non consommées seront conservées dans le buffer pour le prochain appel de <code>work()</code><br />
{{Todos| On souhaite ici seulement recopier l'entrée sur la sortie, donc }}<br />
# Enlever la ligne <code>#pragma</code><br />
# ajouter le code <code> out[0] = in[0];</code> (on recopie le premier échantillon disponible en entrée)<br />
# changer <code>return noutput_items;</code> en <code>return 1;</code> (un seul échantillon a été consommé).<br />
<br />
==== Fichier <code>monModule_passetout.block.yml</code> ====<br />
<br />
Ce fichier au format YAML (''yet another markup language'') fait le lien entre le code c++ et le code python utilisé en interne par GnuRadio.<br />
<br />
{{boîte déroulante/début|titre=monModule_passetout.block.yml}}<br />
<source lang=yaml><br />
id: monModule_passetout<br />
label: passetout<br />
category: '[monModule]'<br />
<br />
templates:<br />
imports: from gnuradio import monModule<br />
make: monModule.passetout()<br />
<br />
# Make one 'parameters' list entry for every parameter you want settable from the GUI.<br />
# Keys include:<br />
# * id (makes the value accessible as keyname, e.g. in the make entry)<br />
# * label (label shown in the GUI)<br />
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)<br />
# * default<br />
parameters:<br />
- id: parametername_replace_me<br />
label: FIX ME:<br />
dtype: string<br />
default: You need to fill in your grc/monModule_passetout.block.yaml<br />
#- id: ...<br />
# label: ...<br />
# dtype: ...<br />
<br />
# Make one 'inputs' list entry per input and one 'outputs' list entry per output.<br />
# Keys include:<br />
# * label (an identifier for the GUI)<br />
# * domain (optional - stream or message. Default is stream)<br />
# * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)<br />
# * vlen (optional - data stream vector length. Default is 1)<br />
# * optional (optional - set to 1 for optional inputs. Default is 0)<br />
inputs:<br />
#- label: ...<br />
# domain: ...<br />
# dtype: ...<br />
# vlen: ...<br />
# optional: ...<br />
<br />
outputs:<br />
#- label: ...<br />
# domain: ...<br />
# dtype: ...<br />
# vlen: ...<br />
# optional: ...<br />
<br />
# 'file_format' specifies the version of the GRC yml format used in the file<br />
# and should usually not be changed.<br />
file_format: 1<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
{{Todos| Mettre à jour la section <code>parameters</code> (pas de paramètres, on commente) :}}<br />
<br />
<source lang=yaml><br />
#parameters:<br />
#- id: parametername_replace_me<br />
# label: FIX ME:<br />
# dtype: string<br />
# default: You need to fill in your grc/customModule_testMod.block.yaml<br />
</source><br />
<br />
{{Todos| Mettre à jour la section <code>inputs</code> :}}<br />
<br />
<source lang=yaml><br />
inputs:<br />
- label: in<br />
domain: stream<br />
dtype: float<br />
</source><br />
<br />
{{Todos| Mettre à jour la section <code>output</code> :}}<br />
<br />
<source lang=yaml><br />
outputs:<br />
- label: out<br />
domain: stream<br />
dtype: float<br />
</source><br />
<br />
==== Compilation et installation ====<br />
<br />
Voici les étapes :<br />
<source lang=bash><br />
$ cd CHEMIN-DE-VOTRE-DOSSIER/gr-monModule<br />
$ mkdir build<br />
$ cd build<br />
$ cmake ..<br />
$ make<br />
$ make install<br />
</source><br />
<br />
* <code>cmake ..</code> lance la création des fichiers <code>Makefile</code> qui permettent la compilation et l'installation<br />
* <code>make</code> lance la compilation<br />
* <code>make install</code> lance l'installation (copie des fichiers dans les dossiers gnuradio)<br />
<br />
{{Todos| Exécuter chacune de ces lignes, en contrôlant l'absence d'erreur. Dans le cas contraire, contrôler les fichiers <code>.h</code>, <code>.cc</code> et <code>.yaml</code>}}<br />
<br />
{{Todos| '''Après ces étapes, et avant de lancer gnuRadio, appeler l'enseignant qui va mettre à jours les bibliothèques partagées.'''}}. Sinon tenter :<br />
<source><br />
$ export LD_LIBRARY_PATH=/usr/local/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH<br />
$ gnuradio-companion &<br />
</source><br />
<br />
==== Utilisation du bloc et test ====<br />
<br />
* Dans Gnuradio, rafraichir la liste des bloc (bouton ''reload'')<br />
* le bloc <code>passetout</code> doit être présent dans la section <code>monModule</code><br />
* Tester le bon fonctionnement de ce bloc en lui envoyant une sinusoïde que vous devez observer identique à la sortie du bloc. Vérifier avec des graphes.<br />
<br />
=== Démodulation ===<br />
<br />
En reprenant le signal modulé en amplitude et la fonction de transfert du filtre passe-bas du TP précédent :<br />
<br />
* Obtenir l'équation aux différence du filtre, ''ie'' écrire ''y(n)='' en fonction de ''x(n)'', ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.<br />
* Créer un nouveau bloc C++ (similaire au passe-tout précédent) dans le module <code>monModule</code> :<br />
** de type <code>sync</code><br />
** une entrée en <code>float</code><br />
** une sortie en <code>float</code><br />
* Écrire le code permettant d'obtenir ''y(n)'' dans la méthode <code>work()</code> :<br />
** ''x(n)'' est donné par <code>in0[0]</code><br />
** il sera nécessaire d'affecter <code>out0[0]</code> pour produire ''y(n)''.<br />
** il sera nécessaire de stocker dans des '''attributs''' les valeurs de <code>in[0]</code> afin de disposer de ''x(n-1)'', ''x(n-2)'', ''y(n-1)'' et ''y(n-2)''.<br />
** On rappelle que les attributs doivent être déclarées dans le fichier <code>.h</code> et initialisés dans le constructeur de la classe.<br />
<br />
{{Todos| Réaliser cette implémentation du passe-bas et contrôler que la démodulation est identique à celle obtenue au TP précédent}}<br />
<br />
{{Todos| Modifier votre code pour implémenter le filtre complet de démodulation}}</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Elen4_TNS&diff=20961Cours:Elen4 TNS2026-05-04T14:51:58Z<p>Fredmn : /* Travaux Pratiques */</p>
<hr />
<div><center><br />
'''<big>S4 - ESE - Traitement numérique du signal</big>'''<br />
</center><br />
<br />
== Description générale ==<br />
<br />
=== Contenu (Programme National) ===<br />
<br />
Filtrage numérique :<br />
* Équation de récurrence, opérations élémentaires, fonction de transfert en Z, passage à un programme informatique;<br />
* Filtre numérique : filtres récursif et non récursif, réponses temporelles (impulsionnelle, indicielle, signal quelconque), réponse fréquentielle, stabilité;<br />
* Synthèse de filtres numériques simples (approximation d’Euler);<br />
* Utilisation d’outils de synthèse des filtres numériques RIF et RII (Matlab, Labview, GNU radio...) et comparaison des performances des filtres RIF et RII;<br />
* Présentation des différentes structures des filtres numériques (direct, cascade, parallèle);<br />
* Implantation d’un traitement numérique sur cible : filtrage numérique simple, asservissement numérique simple (robot mobile, drone...), traitement de données.<br />
<br />
=== Volumes horaire ===<br />
<br />
* CM : 4 séances d'1,5h<br />
* TD : 6 séances d'1,5h + une évaluation d'1,5h<br />
* TP : 6 séances de 3h + une évaluation de 2h<br />
<br />
=== Évaluations ===<br />
<br />
* une évaluation sur table (derniere séance de CM/TD - 1,5h)<br />
* une évaluation pratique (dernière séance de TP - 2h)<br />
<br />
== Cours Magistraux ==<br />
<br />
Contenu :<br />
* Signaux et systèmes numériques<br />
* Filtres numériques<br />
* Quelques filtres RIF<br />
* Synthèse de filtres numériques<br />
* PID numérique <br />
* Élements sur le traitement des images numériques<br />
* Élements sur le temps-fréquence<br />
<br />
<br /><br />
Documents :<br />
* [[Media:TNS-Support.pdf|Support de cours en pdf]]<br />
* [[Media:TNS-diapos.pdf|Diapositives de cours en pdf]]<br />
<br />
== Travaux Dirigés ==<br />
<br />
Textes en pdf :<br />
<br />
* [[Media:TNS-td1.FxTransfert.pdf|TD1 : Fonctions de transfert]]<br />
* [[Media:TNS-td2.Stabilité.pdf|TD2 : Causabilité et stabilité]]<br />
* [[Media:TNS-td3.RepFreq.pdf|TD3 : Réponses fréquentielles]]<br />
* [[Media:TNS-td4.Facteurs1et2.pdf|TD4 : Facteurs du premier et du second ordre]]<br />
* [[Media:TNS-td5-Structures.pdf|TD5 : Structures de réalisation]]<br />
* [[Media:TNS-td6-ConceptionFiltresRII.pdf|TD6 : Conception de filtres récursifs]]<br />
* Évaluation<br />
<br />
== Travaux Pratiques ==<br />
<br />
Les TP utiliserons principalement :<br />
* Gnuradio (cf premier TP)<br />
* Matlab, que vous pourrez utiliser en ligne avec votre compte universitaire : [https://fr.mathworks.com/products/matlab-online.html Matlab online]<br />
* et occasionnellement des cartes Arduinio ou Rpi Pico.<br />
<br />
<br /><br />
Liste des TP :<br />
* [[Cours:Elen4_TNS_TP_Gnuradio|TP1 - Fondamentaux Gnuradio]]<br />
* [[Cours:Elen4_TNS_TP_FxTransfertStabilité|TP2 - Fonction de transfert et stabilité]]<br />
* [[Cours:Elen4_TNS_TP_Implementations|TP3 - Implémentations de filtres]]<br />
* [[Cours:Elen4_TNS_TP_TraitImage|TP4 - Traitements d'images numériques]]<br />
* [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation| TP5 - Traitements audio et démodulation]]<br />
* [[Cours:Elen4_TNS_TP_ TpsReel |TP6 - Temps réel - Codage d'un bloc en Python]]<br />
* Évaluation<br />
<br />
== Évaluation de Travaux Pratiques ==<br />
<br />
Énoncés :<br />
* [[Cours:Elen4_TNS_TP_eval1|Sujet n°1]]<br />
<br />
Documents autorisés :<br />
* accès au wiki<br />
* documents de cours<br />
* notes personnelles</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Elen4_TNS&diff=20960Cours:Elen4 TNS2026-05-04T14:51:50Z<p>Fredmn : /* Travaux Pratiques */</p>
<hr />
<div><center><br />
'''<big>S4 - ESE - Traitement numérique du signal</big>'''<br />
</center><br />
<br />
== Description générale ==<br />
<br />
=== Contenu (Programme National) ===<br />
<br />
Filtrage numérique :<br />
* Équation de récurrence, opérations élémentaires, fonction de transfert en Z, passage à un programme informatique;<br />
* Filtre numérique : filtres récursif et non récursif, réponses temporelles (impulsionnelle, indicielle, signal quelconque), réponse fréquentielle, stabilité;<br />
* Synthèse de filtres numériques simples (approximation d’Euler);<br />
* Utilisation d’outils de synthèse des filtres numériques RIF et RII (Matlab, Labview, GNU radio...) et comparaison des performances des filtres RIF et RII;<br />
* Présentation des différentes structures des filtres numériques (direct, cascade, parallèle);<br />
* Implantation d’un traitement numérique sur cible : filtrage numérique simple, asservissement numérique simple (robot mobile, drone...), traitement de données.<br />
<br />
=== Volumes horaire ===<br />
<br />
* CM : 4 séances d'1,5h<br />
* TD : 6 séances d'1,5h + une évaluation d'1,5h<br />
* TP : 6 séances de 3h + une évaluation de 2h<br />
<br />
=== Évaluations ===<br />
<br />
* une évaluation sur table (derniere séance de CM/TD - 1,5h)<br />
* une évaluation pratique (dernière séance de TP - 2h)<br />
<br />
== Cours Magistraux ==<br />
<br />
Contenu :<br />
* Signaux et systèmes numériques<br />
* Filtres numériques<br />
* Quelques filtres RIF<br />
* Synthèse de filtres numériques<br />
* PID numérique <br />
* Élements sur le traitement des images numériques<br />
* Élements sur le temps-fréquence<br />
<br />
<br /><br />
Documents :<br />
* [[Media:TNS-Support.pdf|Support de cours en pdf]]<br />
* [[Media:TNS-diapos.pdf|Diapositives de cours en pdf]]<br />
<br />
== Travaux Dirigés ==<br />
<br />
Textes en pdf :<br />
<br />
* [[Media:TNS-td1.FxTransfert.pdf|TD1 : Fonctions de transfert]]<br />
* [[Media:TNS-td2.Stabilité.pdf|TD2 : Causabilité et stabilité]]<br />
* [[Media:TNS-td3.RepFreq.pdf|TD3 : Réponses fréquentielles]]<br />
* [[Media:TNS-td4.Facteurs1et2.pdf|TD4 : Facteurs du premier et du second ordre]]<br />
* [[Media:TNS-td5-Structures.pdf|TD5 : Structures de réalisation]]<br />
* [[Media:TNS-td6-ConceptionFiltresRII.pdf|TD6 : Conception de filtres récursifs]]<br />
* Évaluation<br />
<br />
== Travaux Pratiques ==<br />
<br />
Les TP utiliserons principalement :<br />
* Gnuradio (cf premier TP)<br />
* Matlab, que vous pourrez utiliser en ligne avec votre compte universitaire : [https://fr.mathworks.com/products/matlab-online.html Matlab online]<br />
* et occasionnellement des cartes Arduinio ou Rpi Pico.<br />
<br />
<br /><br />
Liste des TP :<br />
* [[Cours:Elen4_TNS_TP_Gnuradio|TP1 - Fondamentaux Gnuradio]]<br />
* [[Cours:Elen4_TNS_TP_FxTransfertStabilité|TP2 - Fonction de transfert et stabilité]]<br />
* [[Cours:Elen4_TNS_TP_Implementations|TP3 - Implémentations de filtres]]<br />
* [[Cours:Elen4_TNS_TP_TraitImage|TP4 - Traitements d'images numériques]]<br />
* [[Cours:Elen4_TNS_TP_TraitAudioEtDemodulation| TP5 - Traitements audio et démodulation]]<br />
* [[Cours:Elen4_TNS_TP_ TpsReel |TP6 - Temps réel - Codage d'un bloc en Python]] --><br />
* Évaluation<br />
<br />
== Évaluation de Travaux Pratiques ==<br />
<br />
Énoncés :<br />
* [[Cours:Elen4_TNS_TP_eval1|Sujet n°1]]<br />
<br />
Documents autorisés :<br />
* accès au wiki<br />
* documents de cours<br />
* notes personnelles</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20959Cours:SaeFusionDecision2026-04-29T14:39:51Z<p>Fredmn : /* Avec estimation de confiance ET hiérarchie */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux modules founissent un angle qui indique le cap à suivre<br />
* il s'agit donc de fusionner la décision de ces deux modules, pour calculer un angle unique de cap à suivre.<br />
<br />
=== Cas simple : pondération générale ===<br />
<br />
On décide d'un poids général pour chacun des modules (pour les hiérarchiser), par exemple :<br />
* <code>poids_lidar = 0.6</code><br />
* <code>poids_pixi = 0.4</code><br />
Ici on décide de privilégier la décision du lidar par rapport à celle de la caméra.<br />
<br />
Il faut s'assurer que <code>poids_lidar + poids_pixi = 1</code><br />
<br />
La fusion est la somme pondérée des deux décisions (donc des deux angles). Soit<br />
<br />
*<code>score_lidar = poids_lidar</code><br />
*<code>score_pixi = poids_pixi</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
* On pourrait aussi décider que les poids changent en fonction de la situation. Par exemple :<br />
** distance faible (infériure à un seuil) => <code>score_lidar = 0.6</code> et <code>score_pixi = 0.4</code><br />
** distance élevée (supérieure au seuil) => <code>score_lidar = 0.3</code> et <code>score_pixi = 0.7</code><br />
<br />
=== Avec estimation de confiance ===<br />
<br />
Si on arrive à estimer une fiabilité de chaque mesure, chaque module donne un angle et une confiance (entre 0 et 1). Donc par exemple:<br />
* Lidar : <code>lidar.angle=10</code> et <code>lidar.confiance=0.7</code><br />
* Pixi : <code>pixi.angle=-5</code> et <code>pixi.confiance=0.3</code><br />
La confiance peut être estimée à partir de la distance, ou bien de la largeur de la réponse.<br />
<br />
On peut donc faire également la somme pondérée des deux angles. Il faut s'assurer que la somme des scores vaut 1. Donc :<br />
*<code>score_lidar = lidar.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>score_pixi = pixi.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
=== Avec estimation de confiance ET hiérarchie ===<br />
<br />
On peut évidemment combiner les deux. On aurait donc :<br />
* Une pondération générale des deux modules :<br />
** <code>poids_lidar = 0.6</code><br />
** <code>poids_pixi = 0.4</code><br />
* Une confiance pour chaque mesures :<br />
** <code>lidar.confiance=0.7</code><br />
** <code>pixi.confiance=0.3</code><br />
* Et évidemment nos deux mesures :<br />
** <code>lidar.angle=10</code> <br />
** <code>pixi.angle=-5</code><br />
<br />
Il suffit alors de calculer des score en multipliant les poids (et en s'assurant que la somme des scores vaut 1) :<br />
* <code>score_lidar = lidar.confiance*poids_lidar/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>score_pixi = pixi.confiance*poids_pixi/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
La feuille de calcul suivante illustre cette fusion, vous pouvez la télécharger pour tester : https://docs.google.com/spreadsheets/d/16FwxqFmsJsAHjfXUKSS-HSLFPvuHmSxn/edit?usp=sharing&ouid=103791012157110322336&rtpof=true&sd=true</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20958Cours:SaeFusionDecision2026-04-29T14:37:44Z<p>Fredmn : /* Avec estimation de confiance ET hiérarchie */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux modules founissent un angle qui indique le cap à suivre<br />
* il s'agit donc de fusionner la décision de ces deux modules, pour calculer un angle unique de cap à suivre.<br />
<br />
=== Cas simple : pondération générale ===<br />
<br />
On décide d'un poids général pour chacun des modules (pour les hiérarchiser), par exemple :<br />
* <code>poids_lidar = 0.6</code><br />
* <code>poids_pixi = 0.4</code><br />
Ici on décide de privilégier la décision du lidar par rapport à celle de la caméra.<br />
<br />
Il faut s'assurer que <code>poids_lidar + poids_pixi = 1</code><br />
<br />
La fusion est la somme pondérée des deux décisions (donc des deux angles). Soit<br />
<br />
*<code>score_lidar = poids_lidar</code><br />
*<code>score_pixi = poids_pixi</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
* On pourrait aussi décider que les poids changent en fonction de la situation. Par exemple :<br />
** distance faible (infériure à un seuil) => <code>score_lidar = 0.6</code> et <code>score_pixi = 0.4</code><br />
** distance élevée (supérieure au seuil) => <code>score_lidar = 0.3</code> et <code>score_pixi = 0.7</code><br />
<br />
=== Avec estimation de confiance ===<br />
<br />
Si on arrive à estimer une fiabilité de chaque mesure, chaque module donne un angle et une confiance (entre 0 et 1). Donc par exemple:<br />
* Lidar : <code>lidar.angle=10</code> et <code>lidar.confiance=0.7</code><br />
* Pixi : <code>pixi.angle=-5</code> et <code>pixi.confiance=0.3</code><br />
La confiance peut être estimée à partir de la distance, ou bien de la largeur de la réponse.<br />
<br />
On peut donc faire également la somme pondérée des deux angles. Il faut s'assurer que la somme des scores vaut 1. Donc :<br />
*<code>score_lidar = lidar.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>score_pixi = pixi.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
=== Avec estimation de confiance ET hiérarchie ===<br />
<br />
On peut évidemment combiner les deux. On aurait donc :<br />
* Une pondération générale des deux modules :<br />
** <code>poids_lidar = 0.6</code><br />
** <code>poids_pixi = 0.4</code><br />
* Une confiance pour chaque mesures :<br />
* <code>lidar.confiance=0.7</code><br />
* <code>pixi.confiance=0.3</code><br />
* Et évidemment nos deux mesures :<br />
* <code>lidar.angle=10</code> <br />
* <code>pixi.angle=-5</code><br />
<br />
Il suffit alors de calculer des score en multipliant les poids (et en s'assurant que la somme des scores vaut 1) :<br />
* <code>score_lidar = lidar.confiance*poids_lidar/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>score_pixi = pixi.confiance*poids_pixi/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
La feuille de calcul suivante illustre cette fusion, vous pouvez la télécharger pour tester : https://docs.google.com/spreadsheets/d/16FwxqFmsJsAHjfXUKSS-HSLFPvuHmSxn/edit?usp=sharing&ouid=103791012157110322336&rtpof=true&sd=true</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20957Cours:SaeFusionDecision2026-04-29T14:36:19Z<p>Fredmn : /* Avec estimation de confiance ET hiérarchie */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux modules founissent un angle qui indique le cap à suivre<br />
* il s'agit donc de fusionner la décision de ces deux modules, pour calculer un angle unique de cap à suivre.<br />
<br />
=== Cas simple : pondération générale ===<br />
<br />
On décide d'un poids général pour chacun des modules (pour les hiérarchiser), par exemple :<br />
* <code>poids_lidar = 0.6</code><br />
* <code>poids_pixi = 0.4</code><br />
Ici on décide de privilégier la décision du lidar par rapport à celle de la caméra.<br />
<br />
Il faut s'assurer que <code>poids_lidar + poids_pixi = 1</code><br />
<br />
La fusion est la somme pondérée des deux décisions (donc des deux angles). Soit<br />
<br />
*<code>score_lidar = poids_lidar</code><br />
*<code>score_pixi = poids_pixi</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
* On pourrait aussi décider que les poids changent en fonction de la situation. Par exemple :<br />
** distance faible (infériure à un seuil) => <code>score_lidar = 0.6</code> et <code>score_pixi = 0.4</code><br />
** distance élevée (supérieure au seuil) => <code>score_lidar = 0.3</code> et <code>score_pixi = 0.7</code><br />
<br />
=== Avec estimation de confiance ===<br />
<br />
Si on arrive à estimer une fiabilité de chaque mesure, chaque module donne un angle et une confiance (entre 0 et 1). Donc par exemple:<br />
* Lidar : <code>lidar.angle=10</code> et <code>lidar.confiance=0.7</code><br />
* Pixi : <code>pixi.angle=-5</code> et <code>pixi.confiance=0.3</code><br />
La confiance peut être estimée à partir de la distance, ou bien de la largeur de la réponse.<br />
<br />
On peut donc faire également la somme pondérée des deux angles. Il faut s'assurer que la somme des scores vaut 1. Donc :<br />
*<code>score_lidar = lidar.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>score_pixi = pixi.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
=== Avec estimation de confiance ET hiérarchie ===<br />
<br />
On peut évidemment combiner les deux. On aurait donc :<br />
* Une pondération générale des deux modules :<br />
** <code>poids_lidar = 0.6</code><br />
** <code>poids_pixi = 0.4</code><br />
* Une confiance pour chaque mesures :<br />
* <code>lidar.confiance=0.7</code><br />
* <code>pixi.confiance=0.3</code><br />
* Et évidemment nos deux mesures :<br />
* <code>lidar.angle=10</code> <br />
* <code>pixi.angle=-5</code><br />
<br />
Il suffit alors de calculer des score en multipliant les poids (et en s'assurant que la somme des scores vaut 1) :<br />
* <code>score_lidar = lidar.confiance*poids_lidar/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>score_pixi = pixi.confiance*poids_pixi/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
La feuille de calcul suivante illustre cette fusion : https://docs.google.com/spreadsheets/d/16FwxqFmsJsAHjfXUKSS-HSLFPvuHmSxn/edit?usp=sharing&ouid=103791012157110322336&rtpof=true&sd=true</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20956Cours:SaeFusionDecision2026-04-29T14:36:06Z<p>Fredmn : /* Avec estimation de confiance ET hiérarchie = */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux modules founissent un angle qui indique le cap à suivre<br />
* il s'agit donc de fusionner la décision de ces deux modules, pour calculer un angle unique de cap à suivre.<br />
<br />
=== Cas simple : pondération générale ===<br />
<br />
On décide d'un poids général pour chacun des modules (pour les hiérarchiser), par exemple :<br />
* <code>poids_lidar = 0.6</code><br />
* <code>poids_pixi = 0.4</code><br />
Ici on décide de privilégier la décision du lidar par rapport à celle de la caméra.<br />
<br />
Il faut s'assurer que <code>poids_lidar + poids_pixi = 1</code><br />
<br />
La fusion est la somme pondérée des deux décisions (donc des deux angles). Soit<br />
<br />
*<code>score_lidar = poids_lidar</code><br />
*<code>score_pixi = poids_pixi</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
* On pourrait aussi décider que les poids changent en fonction de la situation. Par exemple :<br />
** distance faible (infériure à un seuil) => <code>score_lidar = 0.6</code> et <code>score_pixi = 0.4</code><br />
** distance élevée (supérieure au seuil) => <code>score_lidar = 0.3</code> et <code>score_pixi = 0.7</code><br />
<br />
=== Avec estimation de confiance ===<br />
<br />
Si on arrive à estimer une fiabilité de chaque mesure, chaque module donne un angle et une confiance (entre 0 et 1). Donc par exemple:<br />
* Lidar : <code>lidar.angle=10</code> et <code>lidar.confiance=0.7</code><br />
* Pixi : <code>pixi.angle=-5</code> et <code>pixi.confiance=0.3</code><br />
La confiance peut être estimée à partir de la distance, ou bien de la largeur de la réponse.<br />
<br />
On peut donc faire également la somme pondérée des deux angles. Il faut s'assurer que la somme des scores vaut 1. Donc :<br />
*<code>score_lidar = lidar.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>score_pixi = pixi.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
== Avec estimation de confiance ET hiérarchie ==<br />
<br />
On peut évidemment combiner les deux. On aurait donc :<br />
* Une pondération générale des deux modules :<br />
** <code>poids_lidar = 0.6</code><br />
** <code>poids_pixi = 0.4</code><br />
* Une confiance pour chaque mesures :<br />
* <code>lidar.confiance=0.7</code><br />
* <code>pixi.confiance=0.3</code><br />
* Et évidemment nos deux mesures :<br />
* <code>lidar.angle=10</code> <br />
* <code>pixi.angle=-5</code><br />
<br />
Il suffit alors de calculer des score en multipliant les poids (et en s'assurant que la somme des scores vaut 1) :<br />
* <code>score_lidar = lidar.confiance*poids_lidar/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>score_pixi = pixi.confiance*poids_pixi/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
La feuille de calcul suivante illustre cette fusion : https://docs.google.com/spreadsheets/d/16FwxqFmsJsAHjfXUKSS-HSLFPvuHmSxn/edit?usp=sharing&ouid=103791012157110322336&rtpof=true&sd=true</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20955Cours:SaeFusionDecision2026-04-29T14:30:23Z<p>Fredmn : /* Exemple concret */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux modules founissent un angle qui indique le cap à suivre<br />
* il s'agit donc de fusionner la décision de ces deux modules, pour calculer un angle unique de cap à suivre.<br />
<br />
=== Cas simple : pondération générale ===<br />
<br />
On décide d'un poids général pour chacun des modules (pour les hiérarchiser), par exemple :<br />
* <code>poids_lidar = 0.6</code><br />
* <code>poids_pixi = 0.4</code><br />
Ici on décide de privilégier la décision du lidar par rapport à celle de la caméra.<br />
<br />
Il faut s'assurer que <code>poids_lidar + poids_pixi = 1</code><br />
<br />
La fusion est la somme pondérée des deux décisions (donc des deux angles). Soit<br />
<br />
*<code>score_lidar = poids_lidar</code><br />
*<code>score_pixi = poids_pixi</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
* On pourrait aussi décider que les poids changent en fonction de la situation. Par exemple :<br />
** distance faible (infériure à un seuil) => <code>score_lidar = 0.6</code> et <code>score_pixi = 0.4</code><br />
** distance élevée (supérieure au seuil) => <code>score_lidar = 0.3</code> et <code>score_pixi = 0.7</code><br />
<br />
=== Avec estimation de confiance ===<br />
<br />
Si on arrive à estimer une fiabilité de chaque mesure, chaque module donne un angle et une confiance (entre 0 et 1). Donc par exemple:<br />
* Lidar : <code>lidar.angle=10</code> et <code>lidar.confiance=0.7</code><br />
* Pixi : <code>pixi.angle=-5</code> et <code>pixi.confiance=0.3</code><br />
La confiance peut être estimée à partir de la distance, ou bien de la largeur de la réponse.<br />
<br />
On peut donc faire également la somme pondérée des deux angles. Il faut s'assurer que la somme des scores vaut 1. Donc :<br />
*<code>score_lidar = lidar.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>score_pixi = pixi.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
== Avec estimation de confiance ET hiérarchie ===<br />
<br />
On peut évidemment combiner les deux. On aurait donc :<br />
* Une pondération générale des deux modules :<br />
** <code>poids_lidar = 0.6</code><br />
** <code>poids_pixi = 0.4</code><br />
* Une confiance pour chaque mesures :<br />
* <code>lidar.confiance=0.7</code><br />
* <code>pixi.confiance=0.3</code><br />
* Et évidemment nos deux mesures :<br />
* <code>lidar.angle=10</code> <br />
* <code>pixi.angle=-5</code><br />
<br />
Il suffit alors de calculer des score en multipliant les poids (et en s'assurant que la somme des scores vaut 1) :<br />
* <code>score_lidar = lidar.confiance*poids_lidar/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>score_pixi = pixi.confiance*poids_pixi/(lidar.confiance*poids_lidar + pixi.confiance*poids_pixi)</code><br />
* <code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code></div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20954Cours:SaeFusionDecision2026-04-29T14:14:03Z<p>Fredmn : /* Exemple concret */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux modules founissent un angle qui indique le cap à suivre<br />
* il s'agit donc de fusionner la décision de ces deux modules, pour calculer un angle unique de cap à suivre.<br />
<br />
=== Cas simple : pondération générale ===<br />
<br />
On décide d'un poids général pour chacun des modules, par exemple :<br />
* <code>score_lidar = 0.6</code><br />
* <code>score_pixi = 0.4</code><br />
Ici on décide de privilégier la décision du lidar par rapport à celle de la caméra.<br />
<br />
Il faut s'assurer que <code>score_lidar + score_pixi = 1</code><br />
<br />
La fusion est la somme pondérée des deux décisions (donc des deux angles). Soit<br />
<br />
<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
* On pourrait aussi décider que les poids changent en fonction de la situation. Par exemple :<br />
** distance faible (infériure à un seuil) => * <code>score_lidar = 0.6</code> et <code>score_pixi = 0.4</code><br />
** distance élevée (supérieure au seuil) => * <code>score_lidar = 0.3</code> et <code>score_pixi = 0.7</code><br />
<br />
=== Avec estimation de fiabilité ===<br />
<br />
Si on arrive à estimer une fiabilité de la mesure, chaque module donne un angle et une confiance (entre 0 et 1). Donc par exemple:<br />
* Lidar : <code>lidar.angle=10</code> et <code>lidar.confiance=0.7</code><br />
* Pixi : <code>pixi.angle=-5</code> et <code>pixi.confiance=0.3</code><br />
<br />
<br />
On peut donc faire également la somme pondérée des deux angles. Il faut s'assurer que la somme des scores vaut 1. Donc :<br />
*<code>score_lidar = lidar.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>score_pixi = pixi.confiance/(lidar.confiance + pixi.confiance)</code><br />
*<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code></div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20953Cours:SaeFusionDecision2026-04-29T14:07:47Z<p>Fredmn : /* Exemple concret */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux modules founissent un angle qui indique le cap à suivre<br />
* il s'agit donc de fusionner la décision de ces deux modules<br />
<br />
=== Cas simple : pondération générale ===<br />
<br />
On décide d'un poids général pour chacun des modules, par exemple :<br />
* <code>score_lidar = 0.6</code><br />
* <code>score_pixi = 0.4</code><br />
Ici on décide de privilégier la décision du lidar par rapport à celle de la caméra.<br />
<br />
Il faut s'assurer que <code>score_lidar + score_pixi = 1</code><br />
<br />
La fusion est la somme pondérée des deux décisions (donc des deux angles). Soit<br />
<br />
<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code><br />
<br />
* On pourrait aussi décider que les poids changent en fonction de la situation. Par exemple :<br />
** distance faible (infériure à un seuil) => * <code>score_lidar = 0.6</code> et <code>score_pixi = 0.4</code><br />
** distance élevée (supérieure au seuil) => * <code>score_lidar = 0.3</code> et <code>score_pixi = 0.7</code><br />
<br />
=== Avec estimation de fiabilité ===<br />
<br />
Si on arrive à estimer une fiabilité de la mesure, chaque module</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20952Cours:SaeFusionDecision2026-04-29T14:02:50Z<p>Fredmn : /* Exemple concret */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux modules founissent un angle qui indique le cap à suivre<br />
* il s'agit donc de fusionner la décision de ces deux modules<br />
<br />
=== Cas simple ===<br />
<br />
On décide d'un poids général pour chacun des modules, par exemple :<br />
* <code>score_lidar = 0.6</code><br />
* <code>score_pixi = 0.4</code><br />
Ici on décide de privilégier la décision du lidar par rapport à celle de la caméra.<br />
<br />
Il faut s'assurer que <code>score_lidar + score_pixi = 1</code><br />
<br />
La fusion est la somme pondérée des deux décisions (donc des deux angles). Soit<br />
<br />
<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code></div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20951Cours:SaeFusionDecision2026-04-29T14:01:55Z<p>Fredmn : /* Exemple concret */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux modules founissent un angle qui indique le cap à suivre<br />
* il s'agit donc de fusionner la décision de ces deux modules<br />
<br />
=== Cas simple ===<br />
<br />
On décide d'un poids général pour chacun des modules, par exemple :<br />
* score_lidar = 0.6<br />
* score_pixi = 0.4<br />
<br />
Il faut s'assurer que <code>score_lidar + score_pixi = 1</code><br />
<br />
La fusion est la somme pondérée des deux décisions (donc des deux angles). Soit<br />
<br />
<code>angle_final = lidar.angle * score_lidar + pixi.angle * score_pixi</code></div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20950Cours:SaeFusionDecision2026-04-29T13:58:35Z<p>Fredmn : /* Exemple concret */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==<br />
<br />
Prenons le Lidar et la caméra Pixi :<br />
* ces deux détecteurs founissent un angle</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20949Cours:SaeFusionDecision2026-04-29T13:56:57Z<p>Fredmn : </p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme général ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
=== Agrégation et Décision ===<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
=== Choix des poids ===<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
=== Point de vigilance ===<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.<br />
<br />
== Exemple concret ==</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20948Cours:SaeFusionDecision2026-04-29T09:40:29Z<p>Fredmn : /* Agrégation et Décision */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme du vote ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
== Agrégation et Décision ==<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ_i (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
== Choix des poids ==<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
== Point de vigilance ==<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20947Cours:SaeFusionDecision2026-04-28T06:24:39Z<p>Fredmn : /* Mécanisme du vote */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme du vote ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop, s_reculer]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
== Agrégation et Décision ==<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
== Choix des poids ==<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
== Point de vigilance ==<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20946Cours:SaeFusionDecision2026-04-28T06:24:17Z<p>Fredmn : /* Mécanisme du vote */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme du vote ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
== Agrégation et Décision ==<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
== Choix des poids ==<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
== Point de vigilance ==<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20945Cours:SaeFusionDecision2026-04-27T13:08:06Z<p>Fredmn : /* Mécanisme du vote */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme du vote ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop_Urgence</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple 2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
== Agrégation et Décision ==<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
== Choix des poids ==<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
== Point de vigilance ==<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20944Cours:SaeFusionDecision2026-04-27T13:07:58Z<p>Fredmn : /* Mécanisme du vote */</p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme du vote ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop_Urgence</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop]</code>.<br />
** Exemple 1 : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** Exemple2 : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
== Agrégation et Décision ==<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
== Choix des poids ==<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
== Point de vigilance ==<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20943Cours:SaeFusionDecision2026-04-27T13:07:19Z<p>Fredmn : </p>
<hr />
<div><center><br />
'''<big>Fusion de décision multicapteurs, par vote pondéré</big>'''<br />
</center><br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme du vote ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop_Urgence</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop]</code>.<br />
** ''Exemple'' : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** ''Exemple'' : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
== Agrégation et Décision ==<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
== Choix des poids ==<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
== Point de vigilance ==<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20942Cours:SaeFusionDecision2026-04-27T13:06:23Z<p>Fredmn : </p>
<hr />
<div>= Fusion de décision multicapteurs, par vote pondéré =<br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme du vote ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop_Urgence</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop]</code>.<br />
** ''Exemple'' : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** ''Exemple'' : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
== Agrégation et Décision ==<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
== Choix des poids ==<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
== Point de vigilance ==<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeFusionDecision&diff=20941Cours:SaeFusionDecision2026-04-27T13:06:07Z<p>Fredmn : Page créée avec « == Mécanisme du vote pondéré pour la fusion de décisions == = Fusion de décision multicapteurs, par vote pondéré = Le '''vote pondéré''' est particulièrement a... »</p>
<hr />
<div>== Mécanisme du vote pondéré pour la fusion de décisions ==<br />
<br />
= Fusion de décision multicapteurs, par vote pondéré =<br />
<br />
Le '''vote pondéré''' est particulièrement adapté à une architecture multi-capteurs car il permet de traduire une hiérarchie de fiabilité tout en restant déterministe et interprétable, en restant léger en calculs<br />
<br />
== Mécanisme du vote ==<br />
<br />
Chaque module de perception (issu d'un capteur) doit renvoyer plus qu'une donnée brute, mais plutôt un '''vecteur de décision''' ou un score pour chaque action possible.<br />
<br />
Par exemple :<br />
* '''Actions possibles''' : <code>Avancer</code>, <code>Tourner_Gauche</code>, <code>Tourner_Droite</code>, <code>Stop_Urgence</code>, <code>Reculer</code>.<br />
* '''Sortie du capteur i''' : Un vecteur de scores <code>S_i = [s_avancer, s_gauche, s_droite, s_stop]</code>.<br />
** ''Exemple'' : Le LIDAR voit un mur à 2m devant : <code>Stop: 0.9</code>, <code>Gauche: 0.8</code>, <code>Droite: 0.1</code>, <code>Avancer: 0.0</code>.<br />
** ''Exemple'' : La caméra voit la voie libre : <code>Avancer: 0.9</code>, <code>Stop: 0.1</code>.<br />
<br />
== Agrégation et Décision ==<br />
<br />
Le score final pour chaque action est la somme pondérée :<br />
<br />
'''Score_final(action) = Σ (W_i × s_action)''' pour i allant de 1 à N (N = nb de capteurs).<br />
<br />
Décision :<br />
* L'action avec le score final le plus élevé est choisie, éventuellement à condition qu'elle dépasse un seuil de validité minimal (pour éviter de bouger si tous les capteurs sont incertains).<br />
* Il est possible de mettre en place une sécurité. Par exemple Si le score <code>Stop_Urgence</code> des capteurs de proximité (Ultrason/IR) dépasse un seuil critique (ex: 0.95), l'action <code>Stop</code> est exécutée immédiatement, quel que soit le vote des autres.<br />
<br />
Filtrage :<br />
* Pour éviter les oscillations (zigzag) si les scores sont proches, appliquez un lissage temporel<br />
<br />
== Choix des poids ==<br />
<br />
Les poids '''W_i''' peuvent être dynamiques et dépendre du contexte. Par exemple :<br />
<br />
'''W_i = C_base × F_contexte × F_confiance'''<br />
<br />
* '''C_base (Hiérarchie statique)''' : Priorité intrinsèque à décider en amont. Par exemple :<br />
** ''Ultrason/IR'' : Poids très élevé pour l'action <code>Stop</code> (sécurité physique prioritaire).<br />
** ''LIDAR'' : Poids élevé pour la navigation globale.<br />
** ''Caméra'' : Poids moyen (sensible à la lumière).<br />
* '''F_contexte (Fiabilité environnementale)''' : Priorité qui peut dépendre de l'environnement, d'autres capteurs, ... Par exemple<br />
** Si luminosité < seuil → Poids Caméra ≈ 0.<br />
** Si surface absorbante (tapis noir) → Poids Ultrason/IR réduit.<br />
** Si brouillard/poussière → Poids LIDAR/Caméra réduit.<br />
* '''F_confiance (Auto-évaluation)''' : <br />
** Chaque élément de détection peut renvoyer son propre score de confiance (ex: probabilité de la détection d'obstacle). Par exemple si la détection de la caméra est incertainte (confiance 0.4), son vote est automatiquement pondéré à la baisse.<br />
<br />
== Point de vigilance ==<br />
<br />
Il faut prévoir un cas par défaut si le vote est parfaitement équilibré ou si le score maximal est trop faible (incertitude globale trop haute). La décision par défaut doit être conservative : '''Arrêt sécurisé''' ou '''Recul prudent'''.</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:SaeEvitementObstacles&diff=20940Cours:SaeEvitementObstacles2026-04-27T12:48:31Z<p>Fredmn : /* Fonctions */</p>
<hr />
<div>https://docs.google.com/document/d/1lLrXOisqDBmTie8lAPcVor_al1TS7HhtI7Or8wFLcsg/edit?tab=t.0<br />
<br />
<br />
support de présentation :<br />
https://docs.google.com/presentation/d/1r9tSETGUbYgtk2Ip78lNhEWxcHYtDbIx4epwVoeI2hs/edit?slide=id.p#slide=id.p<br />
<br />
fonctions :<br />
https://docs.google.com/spreadsheets/d/1GX3zPpdC4umtqc4B8hLjQZWTMNHfw7GfKqrpxW5ORzc/edit?usp=sharing<br />
<br />
https://www.festivalrobotiquecachan.fr/<br />
<br />
https://www.festivalrobotiquecachan.fr/wp-content/uploads/Reglement_rencontres_de_robotique_GEII_BUT-1-2-3.pdf<br />
<br />
=Découpage fonctionnel=<br />
<br />
[[Media:DecoupageFcts2026.pdf]]<br />
<br />
<br />
=Travail à réaliser=<br />
<br />
==1ère partie (2 semaines)==<br />
*travail individuel<br />
**travail à réaliser pour fin de la 2ème semaine<br />
**évaluation à la fin de la 2ème semaine (schéma/routage)<br />
**sélection de la meilleure carte pour fabrication<br />
***finalisation des pcbs pour le {{Rouge|jeudi 3/04 matin}}<br />
*cartes :<br />
**balise émettrice<br />
***choix de la fréquence<br />
**balise de réglage<br />
***à l'opposé du terrain<br />
***permet de régler l'élévation de la balise émettrice<br />
***affiche le niveau de puissance<br />
**carte réceptrice IR (filtre)<br />
**carte filtrage (se plug sur la carte réceptrice IR)<br />
***on change de carte pour changer la fréquence<br />
**carte µc<br />
***connectique pour e/s<br />
***driver moteurs<br />
***fourni alim symétrique<br />
**banc test pour la carte filtre<br />
**banc test pour la carte réceptrice complète<br />
<br />
==2ème partie (xx jours)==<br />
<br />
*Travail individuel<br />
*montage des cartes<br />
*vérification du fonctionnement<br />
*réalisation programme : fonction à réaliser selon cdc<br />
<br />
==3ème partie (xx jours)==<br />
<br />
*travail en binôme ?<br />
*programmation d'un robot<br />
<br />
<br />
=Modalités d'évaluation=<br />
<br />
==1 soutenance==<br />
*Vendredi 17/05 matin<br />
**20 minutes de présentation<br />
**10 minutes de questions<br />
*Présentation(introduction) de chaque "partie" en anglais<br />
<br />
==1 dossier==<br />
*Analyse fonctionnelle<br />
*Nomenclature<br />
*Chiffrage<br />
*Etude détaillée de chaque fonction<br />
*Schémas électriques/algorithmes/simulations/courbes caractéristiques/fonctions de transfert ...<br />
<br />
==Démonstration(s)==<br />
<br />
* Démonstration du fonctionnement le 12/05 à 12h<br />
* Participation au festival de robotique à Cachan<br />
<br />
==Note de résultat - Evaluation travaux de SAE==<br />
*Groupe : accomplissement du projet<br />
*Individuelle : en fonction de <br />
**Difficulté technique<br />
**Quantité de travail<br />
**Qualité de la réalisation<br />
**Investissement : <big>évalué chaque jour</big><br />
<br />
==Réalisation d'une vidéo==<br />
Vidéo à réaliser pour le concours EEA :<br />
https://clubeea.com/concours-mon-projet-en-5-minutes/<br />
<br />
=Fonctions=<br />
[[Cours:SaeEvitementObstaclesFonctions]]<br />
<br />
[[Cours:SaeFusionDecision]]<br />
<br />
=Pages indispensables du wiki=<br />
<br />
*[[Cours:Oscillogbf|Utilisation de python et Qt pour la réalisation d'un banc de test]]<br />
*[[Cours:PiPico|Programmation de la carte pico rp2040]]<br />
*[[Cours:Esp01|Utilisation d'un esp-01 pour faire de la supervision]]<br />
<br />
=Ressources informatique=<br />
<br />
*[[Cours:pixyUartArduino|Pixy]]<br />
*https://www.waveshare.com/wiki/RPLIDAR_C1<br />
<br />
=Ressources=<br />
<br />
*https://www.eeweb.com/level-shifting-techniques-in-i2c-bus-design/<br />
*https://github.com/drankinatty/pico-mpu9250<br />
<br />
*vérifier la "programmabilité" du µcontroleur :<br />
**dans un terminal<br />
**avrdude -c usbasp -p nomDuMicro<br />
**ex : avrdude -c usbasp -p t2313<br />
**ex : avrdude -c usbasp -p m328p<br />
<br />
*modification des fusibles pour choisir fréquence d'horloge:<br />
**pour les atmega328p, dans le logiciel graver le bootloader<br />
**pour les attiny (utiliser '''arduino v1''' !! ) :<br />
***installer attinycore : https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/Installation.md<br />
***choisir le bon microcontroleur et la bonne source d'horloge<br />
***graver la séquence d'initialisation<br />
**pour les atmega2560, attention il faut modifier les fusibles par rapport au bootloader arduino :<br />
***dans un terminal<br />
***avrdude -v -patmega2560 -cusbasp -e -Ulock:w:0x3F:m -Uefuse:w:0xFD:m -Uhfuse:w:0xD9:m -Ulfuse:w:0xFF:m<br />
<br />
<br />
<br />
<br />
*http://raphael.candelier.fr/?blog=XL_320<br />
<br />
<br />
=contraintes de fabrication=<br />
<br />
==carte alimentation==<br />
<br />
==carte principale==<br />
<br />
*dimension maximum : 8cm x 13cm</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:PiPico&diff=20938Cours:PiPico2026-04-09T08:20:42Z<p>Fredmn : /* Pico C++ SDK */</p>
<hr />
<div>= Brochage =<br />
<br />
https://datasheets.raspberrypi.com/pico/Pico-R3-A4-Pinout.pdf<br />
<br />
=utilisation de l'ide arduino=<br />
<br />
https://github.com/earlephilhower/arduino-pico<br />
<br />
<br />
=non recommandé : QtCreator=<br />
<br />
== Création assistée d'un projet ==<br />
<br />
À l'aide de ''pico_project.py'' :<br />
* ''git clone https://github.com/raspberrypi/pico-project-generator.git''<br />
* ''./pico_project.py --gui''<br />
* ne pas cocher "create VSCode project"<br />
<br />
Attention, ne pas oublier de spécifier le chemin vers le SDK :<br />
* ''export PICO_SDK_PATH=../../pico-sdk'' en remplaçant ''../../pico-sdk'' par le chemin vers le SDK.<br />
<br />
== Ouverture avec QTCreator ==<br />
<br />
QtCreator est capable de lire et interpréter le fichier ''CMakeLists.txt'' comme descripteur de projet, il suffit donc<br />
* d'ouvrir (comme projet) le fichier ''CMakeLists.txt''<br />
<br />
=VsCode=<br />
<br />
*installer VsCode<br />
**https://doc.ubuntu-fr.org/visual_studio_code<br />
*ajouter le plugin pi pico<br />
**https://github.com/raspberrypi/pico-vscode<br />
**https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf<br />
<br />
=Registres=<br />
<br />
==gpio==<br />
<source lang=cpp><br />
#include "pico/stdlib.h"<br />
#include "hardware/regs/addressmap.h"<br />
<br />
unsigned int& gpioOUT = *(unsigned int*) (SIO_BASE + 0x10);<br />
unsigned int& gpioOE = *(unsigned int*) (SIO_BASE + 0x20);<br />
<br />
unsigned int& gpioCtrl0 = *(unsigned int *) (IO_BANK0_BASE+0x4);<br />
//facultatif<br />
unsigned int& padsBank0_GPIO0 = *(unsigned int *) (PADS_BANK0_BASE+0x4);<br />
<br />
<br />
int main() {<br />
// facultatif<br />
padsBank0_GPIO0|=(1<<6); // input enable<br />
padsBank0_GPIO0&=~(1<<7); // output disable<br />
// piloter la broche avec fonction SIO<br />
gpioCtrl0=5;<br />
// sortie enable<br />
gpioOE=1<<0;<br />
while (true)<br />
{<br />
gpioOUT&=~(1<<0);<br />
sleep_ms(200);<br />
gpioOUT|=(1<<0);<br />
sleep_ms(10);<br />
}<br />
}<br />
</source><br />
<br />
=usage des périphériques au travers du sdk=<br />
<br />
== Référence en PDF du Pico C++ SDK ==<br />
<br />
[https://pip-assets.raspberrypi.com/categories/609-microcontroller-boards/documents/RP-009085-KB-1-raspberry-pi-pico-c-sdk.pdf Raspberry Pi Pico-series C/C++ SDK Libraries and tools for C/C++ development on Raspberry Pi microcontrollers]<br />
<br />
==GPIO==<br />
<br />
https://www.raspberrypi.com/documentation/pico-sdk/hardware.html#hardware_gpio<br />
<br />
==IO==<br />
<br />
{| class="wikitable"<br />
|-<br />
! Syntaxe<br />
||void gpio_init(uint gpio)<br />
|-<br />
! Paramètres<br />
||<br />
{| class="wikitable"<br />
|-<br />
| gpio || numéro de gpio<br />
|}<br />
|}<br />
*gpio_put(LED_PIN, 1);<br />
*gpio_set_dir(LED_PIN, GPIO_OUT);<br />
*gpio_set_pulls (uint gpio, bool up, bool down)<br />
<br />
==interrupt==<br />
<br />
Il n'y a pas d'interruption dédiée à une broche particulière. Toutes les gpio déclenchent la même interruption. Il convient ensuite de regarder lesquelles ont déclenchées l'interruption :<br />
<br />
<br />
<source lang=cpp><br />
<br />
void my_raw_interrupt_handler()<br />
{<br />
const int32_t gpio;<br />
if (gpio_get_irq_event_mask(gpio) & (GPIO_IRQ_EDGE_RISE|GPIO_IRQ_EDGE_FALL))<br />
{<br />
if (gpio_get_irq_event_mask(gpio) & (GPIO_IRQ_EDGE_RISE)) // Front Montant<br />
{<br />
<br />
} <br />
else<br />
{<br />
}<br />
gpio_acknowledge_irq(gpio, GPIO_IRQ_EDGE_RISE|GPIO_IRQ_EDGE_FALL);<br />
}<br />
}<br />
<br />
...<br />
gpio_set_irq_enabled(2, GPIO_IRQ_EDGE_FALL | GPIO_IRQ_EDGE_RISE, true);<br />
...<br />
</source><br />
<br />
==Pwm==<br />
<br />
https://raspberry-pi.developpez.com/actu/344283/Raspberry-Pi-Pico-moins-Apprendre-a-generer-des-signaux-PWM-un-billet-blog-de-f-leb/<br />
<br />
Fmli = Fcpu / ( wrap * clkdiv ) // sur pi pico, Fcpu=125MHz<br />
<br />
*clkdiv:<br />
**Le registre qui stocke le diviseur de fréquence comprend 8 bits pour la partie entière, et 4 bits pour la partie fractionnaire<br />
**valeur max de clkdiv : 255 + 15/16<br />
**ex : pwm_set_clkdiv_int_frac (slice, 38, 3); // diviseur de fréquence = 38 + 3/16 <br />
<br />
*gpio_set_function(PICO_DEFAULT_LED_PIN, GPIO_FUNC_PWM);<br />
*uint slice_num = pwm_gpio_to_slice_num(PICO_DEFAULT_LED_PIN);<br />
*pwm_config config = pwm_get_default_config();<br />
*pwm_config_set_clkdiv(&config, 4.f);<br />
*pwm_init(slice_num, &config, true);<br />
*pwm_set_gpio_level(PICO_DEFAULT_LED_PIN, fade * fade); // rapport cyclique 16 bits<br />
<br />
==I2C==<br />
<br />
==configuration cmake==<br />
ajouter dans la liste target_link_libraries<br />
<source lang=cpp><br />
target_link_libraries( <br />
....<br />
hardware_i2c<br />
....<br />
)<br />
</source><br />
<br />
===i2c scanner===<br />
<br />
<source lang=cpp><br />
#include <stdio.h><br />
#include "pico/stdlib.h"<br />
#include "hardware/i2c.h"<br />
#include "hardware/timer.h"<br />
#include "hardware/clocks.h"<br />
#include "pico/binary_info.h"<br />
<br />
<br />
int64_t alarm_callback(alarm_id_t id, void *user_data) {<br />
// Put your timeout handler code in here<br />
return 0;<br />
}<br />
<br />
<br />
<br />
bool reserved_addr(uint8_t addr) {<br />
return (addr & 0x78) == 0 || (addr & 0x78) == 0x78;<br />
}<br />
int main()<br />
{<br />
stdio_init_all();<br />
<br />
// I2C Initialisation. Using it at 400Khz.<br />
i2c_init(i2c0, 100*1000);<br />
<br />
gpio_set_function(PICO_DEFAULT_I2C_SDA_PIN, GPIO_FUNC_I2C);<br />
gpio_set_function(PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C);<br />
gpio_pull_up(PICO_DEFAULT_I2C_SDA_PIN);<br />
gpio_pull_up(PICO_DEFAULT_I2C_SCL_PIN);<br />
// For more examples of I2C use see https://github.com/raspberrypi/pico-examples/tree/master/i2c<br />
bi_decl(bi_2pins_with_func(PICO_DEFAULT_I2C_SDA_PIN, PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C));<br />
<br />
// Timer example code - This example fires off the callback after 2000ms<br />
add_alarm_in_ms(2000, alarm_callback, NULL, false);<br />
// For more examples of timer use see https://github.com/raspberrypi/pico-examples/tree/master/timer<br />
<br />
printf("System Clock Frequency is %d Hz\n", clock_get_hz(clk_sys));<br />
printf("USB Clock Frequency is %d Hz\n", clock_get_hz(clk_usb));<br />
// For more examples of clocks use see https://github.com/raspberrypi/pico-examples/tree/master/clocks<br />
<br />
while (true) {<br />
printf("\nI2C Bus Scan\n");<br />
printf(" 0 1 2 3 4 5 6 7 8 9 A B C D E F\n");<br />
<br />
for (int addr = 0; addr < (1 << 7); ++addr) {<br />
if (addr % 16 == 0) {<br />
printf("%02x ", addr);<br />
}<br />
<br />
// Perform a 1-byte dummy read from the probe address. If a slave<br />
// acknowledges this address, the function returns the number of bytes<br />
// transferred. If the address byte is ignored, the function returns<br />
// -1.<br />
<br />
// Skip over any reserved addresses.<br />
int ret;<br />
uint8_t rxdata;<br />
if (reserved_addr(addr))<br />
ret = PICO_ERROR_GENERIC;<br />
else<br />
ret = i2c_read_blocking(i2c_default, addr, &rxdata, 1, false);<br />
<br />
printf(ret < 0 ? "." : "@");<br />
printf(addr % 16 == 15 ? "\n" : " ");<br />
}<br />
printf("Done.\n");<br />
<br />
sleep_ms(1000);<br />
}<br />
}<br />
<br />
</source><br />
<br />
===read/write register===<br />
<br />
<source lang=cpp><br />
void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)<br />
{<br />
uint8_t data[2]={regAddress,regValue};<br />
i2c_write_blocking(i2c0,targetAddress,data,2,false);<br />
}<br />
<br />
uint8_t readI2cReg(uint8_t targetAddress, uint8_t regAddress)<br />
{<br />
i2c_write_blocking(i2c0,targetAddress,&regAddress,1,true);<br />
uint8_t regValue;<br />
i2c_read_blocking(i2c0,targetAddress,&regValue,1,false);<br />
return regValue;<br />
}<br />
</source><br />
<br />
==adc==<br />
<br />
==uart==<br />
*https://www.raspberrypi.com/documentation/pico-sdk/hardware.html#group_hardware_uart<br />
<br />
==pio==<br />
<br />
===ws2812===<br />
https://github.com/ForsakenNGS/PicoLED<br />
<br />
=liens=<br />
*https://www.gibbard.me/using_the_raspberry_pi_pico_on_ubuntu/<br />
*https://tutoduino.fr/en/pico-platformio/<br />
*visual studio code :<br />
**https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf partie 7.1<br />
**https://www.electronicshub.org/program-raspberry-pi-pico-with-visual-studio-code/<br />
*https://github.com/raspberrypi/picotool</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:PiPico&diff=20936Cours:PiPico2026-04-09T08:13:04Z<p>Fredmn : /* usage des périphériques au travers du sdk */</p>
<hr />
<div>= Brochage =<br />
<br />
https://datasheets.raspberrypi.com/pico/Pico-R3-A4-Pinout.pdf<br />
<br />
=utilisation de l'ide arduino=<br />
<br />
https://github.com/earlephilhower/arduino-pico<br />
<br />
<br />
=non recommandé : QtCreator=<br />
<br />
== Création assistée d'un projet ==<br />
<br />
À l'aide de ''pico_project.py'' :<br />
* ''git clone https://github.com/raspberrypi/pico-project-generator.git''<br />
* ''./pico_project.py --gui''<br />
* ne pas cocher "create VSCode project"<br />
<br />
Attention, ne pas oublier de spécifier le chemin vers le SDK :<br />
* ''export PICO_SDK_PATH=../../pico-sdk'' en remplaçant ''../../pico-sdk'' par le chemin vers le SDK.<br />
<br />
== Ouverture avec QTCreator ==<br />
<br />
QtCreator est capable de lire et interpréter le fichier ''CMakeLists.txt'' comme descripteur de projet, il suffit donc<br />
* d'ouvrir (comme projet) le fichier ''CMakeLists.txt''<br />
<br />
=VsCode=<br />
<br />
*installer VsCode<br />
**https://doc.ubuntu-fr.org/visual_studio_code<br />
*ajouter le plugin pi pico<br />
**https://github.com/raspberrypi/pico-vscode<br />
**https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf<br />
<br />
=Registres=<br />
<br />
==gpio==<br />
<source lang=cpp><br />
#include "pico/stdlib.h"<br />
#include "hardware/regs/addressmap.h"<br />
<br />
unsigned int& gpioOUT = *(unsigned int*) (SIO_BASE + 0x10);<br />
unsigned int& gpioOE = *(unsigned int*) (SIO_BASE + 0x20);<br />
<br />
unsigned int& gpioCtrl0 = *(unsigned int *) (IO_BANK0_BASE+0x4);<br />
//facultatif<br />
unsigned int& padsBank0_GPIO0 = *(unsigned int *) (PADS_BANK0_BASE+0x4);<br />
<br />
<br />
int main() {<br />
// facultatif<br />
padsBank0_GPIO0|=(1<<6); // input enable<br />
padsBank0_GPIO0&=~(1<<7); // output disable<br />
// piloter la broche avec fonction SIO<br />
gpioCtrl0=5;<br />
// sortie enable<br />
gpioOE=1<<0;<br />
while (true)<br />
{<br />
gpioOUT&=~(1<<0);<br />
sleep_ms(200);<br />
gpioOUT|=(1<<0);<br />
sleep_ms(10);<br />
}<br />
}<br />
</source><br />
<br />
=usage des périphériques au travers du sdk=<br />
<br />
== Pico C++ SDK ==<br />
<br />
Raspberry Pi Pico-series C/C++ SDK<br />
Libraries and tools for C/C++ development on Raspberry Pi<br />
microcontrollers : <br />
https://pip-assets.raspberrypi.com/categories/609-microcontroller-boards/documents/RP-009085-KB-1-raspberry-pi-pico-c-sdk.pdf<br />
<br />
==GPIO==<br />
<br />
https://www.raspberrypi.com/documentation/pico-sdk/hardware.html#hardware_gpio<br />
<br />
==IO==<br />
<br />
{| class="wikitable"<br />
|-<br />
! Syntaxe<br />
||void gpio_init(uint gpio)<br />
|-<br />
! Paramètres<br />
||<br />
{| class="wikitable"<br />
|-<br />
| gpio || numéro de gpio<br />
|}<br />
|}<br />
*gpio_put(LED_PIN, 1);<br />
*gpio_set_dir(LED_PIN, GPIO_OUT);<br />
*gpio_set_pulls (uint gpio, bool up, bool down)<br />
<br />
==interrupt==<br />
<br />
Il n'y a pas d'interruption dédiée à une broche particulière. Toutes les gpio déclenchent la même interruption. Il convient ensuite de regarder lesquelles ont déclenchées l'interruption :<br />
<br />
<br />
<source lang=cpp><br />
<br />
void my_raw_interrupt_handler()<br />
{<br />
const int32_t gpio;<br />
if (gpio_get_irq_event_mask(gpio) & (GPIO_IRQ_EDGE_RISE|GPIO_IRQ_EDGE_FALL))<br />
{<br />
if (gpio_get_irq_event_mask(gpio) & (GPIO_IRQ_EDGE_RISE)) // Front Montant<br />
{<br />
<br />
} <br />
else<br />
{<br />
}<br />
gpio_acknowledge_irq(gpio, GPIO_IRQ_EDGE_RISE|GPIO_IRQ_EDGE_FALL);<br />
}<br />
}<br />
<br />
...<br />
gpio_set_irq_enabled(2, GPIO_IRQ_EDGE_FALL | GPIO_IRQ_EDGE_RISE, true);<br />
...<br />
</source><br />
<br />
==Pwm==<br />
<br />
https://raspberry-pi.developpez.com/actu/344283/Raspberry-Pi-Pico-moins-Apprendre-a-generer-des-signaux-PWM-un-billet-blog-de-f-leb/<br />
<br />
Fmli = Fcpu / ( wrap * clkdiv ) // sur pi pico, Fcpu=125MHz<br />
<br />
*clkdiv:<br />
**Le registre qui stocke le diviseur de fréquence comprend 8 bits pour la partie entière, et 4 bits pour la partie fractionnaire<br />
**valeur max de clkdiv : 255 + 15/16<br />
**ex : pwm_set_clkdiv_int_frac (slice, 38, 3); // diviseur de fréquence = 38 + 3/16 <br />
<br />
*gpio_set_function(PICO_DEFAULT_LED_PIN, GPIO_FUNC_PWM);<br />
*uint slice_num = pwm_gpio_to_slice_num(PICO_DEFAULT_LED_PIN);<br />
*pwm_config config = pwm_get_default_config();<br />
*pwm_config_set_clkdiv(&config, 4.f);<br />
*pwm_init(slice_num, &config, true);<br />
*pwm_set_gpio_level(PICO_DEFAULT_LED_PIN, fade * fade); // rapport cyclique 16 bits<br />
<br />
==I2C==<br />
<br />
===i2c scanner===<br />
<br />
<source lang=cpp><br />
#include <stdio.h><br />
#include "pico/stdlib.h"<br />
#include "hardware/i2c.h"<br />
#include "hardware/timer.h"<br />
#include "hardware/clocks.h"<br />
#include "pico/binary_info.h"<br />
<br />
<br />
int64_t alarm_callback(alarm_id_t id, void *user_data) {<br />
// Put your timeout handler code in here<br />
return 0;<br />
}<br />
<br />
<br />
<br />
bool reserved_addr(uint8_t addr) {<br />
return (addr & 0x78) == 0 || (addr & 0x78) == 0x78;<br />
}<br />
int main()<br />
{<br />
stdio_init_all();<br />
<br />
// I2C Initialisation. Using it at 400Khz.<br />
i2c_init(i2c0, 100*1000);<br />
<br />
gpio_set_function(PICO_DEFAULT_I2C_SDA_PIN, GPIO_FUNC_I2C);<br />
gpio_set_function(PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C);<br />
gpio_pull_up(PICO_DEFAULT_I2C_SDA_PIN);<br />
gpio_pull_up(PICO_DEFAULT_I2C_SCL_PIN);<br />
// For more examples of I2C use see https://github.com/raspberrypi/pico-examples/tree/master/i2c<br />
bi_decl(bi_2pins_with_func(PICO_DEFAULT_I2C_SDA_PIN, PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C));<br />
<br />
// Timer example code - This example fires off the callback after 2000ms<br />
add_alarm_in_ms(2000, alarm_callback, NULL, false);<br />
// For more examples of timer use see https://github.com/raspberrypi/pico-examples/tree/master/timer<br />
<br />
printf("System Clock Frequency is %d Hz\n", clock_get_hz(clk_sys));<br />
printf("USB Clock Frequency is %d Hz\n", clock_get_hz(clk_usb));<br />
// For more examples of clocks use see https://github.com/raspberrypi/pico-examples/tree/master/clocks<br />
<br />
while (true) {<br />
printf("\nI2C Bus Scan\n");<br />
printf(" 0 1 2 3 4 5 6 7 8 9 A B C D E F\n");<br />
<br />
for (int addr = 0; addr < (1 << 7); ++addr) {<br />
if (addr % 16 == 0) {<br />
printf("%02x ", addr);<br />
}<br />
<br />
// Perform a 1-byte dummy read from the probe address. If a slave<br />
// acknowledges this address, the function returns the number of bytes<br />
// transferred. If the address byte is ignored, the function returns<br />
// -1.<br />
<br />
// Skip over any reserved addresses.<br />
int ret;<br />
uint8_t rxdata;<br />
if (reserved_addr(addr))<br />
ret = PICO_ERROR_GENERIC;<br />
else<br />
ret = i2c_read_blocking(i2c_default, addr, &rxdata, 1, false);<br />
<br />
printf(ret < 0 ? "." : "@");<br />
printf(addr % 16 == 15 ? "\n" : " ");<br />
}<br />
printf("Done.\n");<br />
<br />
sleep_ms(1000);<br />
}<br />
}<br />
<br />
</source><br />
<br />
===read/write register===<br />
<br />
<source lang=cpp><br />
void writeI2cReg(uint8_t targetAddress, uint8_t regAddress, uint8_t regValue)<br />
{<br />
uint8_t data[2]={regAddress,regValue};<br />
i2c_write_blocking(i2c0,targetAddress,data,2,false);<br />
}<br />
<br />
uint8_t readI2cReg(uint8_t targetAddress, uint8_t regAddress)<br />
{<br />
i2c_write_blocking(i2c0,targetAddress,&regAddress,1,true);<br />
uint8_t regValue;<br />
i2c_read_blocking(i2c0,targetAddress,&regValue,1,false);<br />
return regValue;<br />
}<br />
</source><br />
<br />
==adc==<br />
<br />
==uart==<br />
*https://www.raspberrypi.com/documentation/pico-sdk/hardware.html#group_hardware_uart<br />
<br />
==pio==<br />
<br />
===ws2812===<br />
https://github.com/ForsakenNGS/PicoLED<br />
<br />
=liens=<br />
*https://www.gibbard.me/using_the_raspberry_pi_pico_on_ubuntu/<br />
*https://tutoduino.fr/en/pico-platformio/<br />
*visual studio code :<br />
**https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf partie 7.1<br />
**https://www.electronicshub.org/program-raspberry-pi-pico-with-visual-studio-code/<br />
*https://github.com/raspberrypi/picotool</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Acces:Prof&diff=20935Acces:Prof2026-04-08T14:47:20Z<p>Fredmn : </p>
<hr />
<div>*bjacquot<br />
*AgnesD<br />
*f.sisternas<br />
*sl<br />
*bernar03<br />
*Gmillon<br />
*Remy02<br />
*Woznyrob<br />
*penant<br />
*fredmn<br />
*vuille01<br />
*nawal<br />
*Tarek<br />
*Abuzlukov</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Acces:Prof&diff=20934Acces:Prof2026-04-08T14:06:23Z<p>Fredmn : </p>
<hr />
<div>*bjacquot<br />
*AgnesD<br />
*f.sisternas<br />
*sl<br />
*bernar03<br />
*Gmillon<br />
*Remy02<br />
*Woznyrob<br />
*penant<br />
*fredmn<br />
*vuille01<br />
*nawal<br />
*Tarek<br />
*abuzlukov</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=LLM&diff=20902LLM2026-03-17T13:50:06Z<p>Fredmn : /* Guide pour un usage raisonnable et raisonné des LLM en programmation */</p>
<hr />
<div>== Guide pour un usage raisonnable et raisonné des LLM en programmation ==<br />
<br />
* Rappel LLM vs IA<br />
** Fonctionnement d'un LLM<br />
** "IA" ou IA<br />
* Ollama : LLM en cloud ou local<br />
* Aide à la programmation<br />
** LLM en mode question/réponse<br />
** Utiliser un agent<br />
*** Claude Code<br />
*** OpenCode<br />
*** mode planification<br />
* Quels modèles de LLM ?</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=LLM&diff=20877LLM2026-03-08T07:44:43Z<p>Fredmn : Page créée avec « == Guide pour un usage raisonnable et raisonné des LLM en programmation == * Rappel LLM vs IA ** Fonctionnement d'un LLM ** "IA" ou IA * Ollama : LLM en cloud ou local *... »</p>
<hr />
<div>== Guide pour un usage raisonnable et raisonné des LLM en programmation ==<br />
<br />
* Rappel LLM vs IA<br />
** Fonctionnement d'un LLM<br />
** "IA" ou IA<br />
* Ollama : LLM en cloud ou local<br />
* Aide à la programmation<br />
** LLM en mode question/réponse<br />
** Claude Code<br />
*** mode planification<br />
* Quels modèles de LLM ?</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:XR207_tp_digicode&diff=20843Cours:XR207 tp digicode2026-02-12T08:46:34Z<p>Fredmn : /* Indice de ligne */</p>
<hr />
<div> <big>{{Rouge|******************************************}}</big><br />
<big>{{Rouge|*** Apporter la malette d'informatique ***}}</big><br />
<big>{{Rouge|******************************************}}</big><br />
<br />
[[Cours:CoursM2103|{{Rouge|<big>'''Fiche résumé'''</big>}}]]<br />
<br />
[[Cours:TPs_2103|{{Bleu|<big>'''Retour à la liste des Tps'''</big>}}]]<br />
<br />
[[Cours:TPS_2103_tp3_corrige|{{Vert|<big>'''Éléments de correction'''</big>}}]]<br />
<br />
[[Fichier:Arduino-nano-pinout.png|600px|droite]]<br />
<br />
Vous allez développer un système de digicode architecturé autour d'un atmega328p (le µcontrôleur présent sur les cartes arduino).<br />
<br />
<big>'''Pour ce TP, nous utilisons une carte arduino {{Rouge|sans le shieldinfo}}'''</big><br />
<br />
<br />
=objectifs=<br />
*numération binaire (affichage avec des leds de la valeur d'un entier signé ou non )<br />
*e/s + pullup<br />
*utilisation de fonctions<br />
*déclaration de fonctions<br />
*algorithme simple et implémentation<br />
<br />
=Matériel=<br />
<br />
Nous utiliserons :<br />
*1 carte arduino NANO<br />
*1 plaque à essais<br />
*8 leds pour afficher une valeur<br />
*1 résistance de 330Ω par led<br />
*1 clavier matriciel<br />
*fils M-M<br />
*fils M-F<br />
<br />
=Informations lumineuses=<br />
<br />
==Câblage==<br />
<br />
{{Todo|Câbler sur une plaque à essais les 8 leds :}}<br />
*utiliser des résistances de 330Ω pour régler l'intensité lumineuse<br />
*PD0 à PD7<br />
*mettre les leds dans "l'ordre" des broches<br />
*montage dit "cathodes communes"<br />
<br />
==Utilisation des 8 leds==<br />
<br />
Nous utiliserons dans nos programmes [[Cours:CoursM2103#Fixed_width_integer_types|les types de variable dont la taille est explicitement donnée]]<br />
<br />
Le {{Rouge|débogage}} d'un programme est fondamental, il existe différentes façons de le faire. Ici nous nous contenterons {{Rouge|d'utiliser des leds}} pour afficher des informations sur l'exécution du programme.<br />
<br />
Principe :<br />
<br />
<source lang=c><br />
#include <avr/io.h><br />
#include <util/delay.h><br />
<br />
void clignote()<br />
{<br />
PORTD=0;<br />
for (uint8_t i=0;i<5;i++)<br />
{<br />
PORTD ^= 0xFF;<br />
_delay_ms(50);<br />
}<br />
}<br />
<br />
int main()<br />
{<br />
// config des sorties<br />
DDRD = 0xFF; // les 8 broches des leds en sortie<br />
<br />
// qques variables<br />
uint8_t val1 = 0;<br />
int8_t val2 = -1;<br />
uint8_t val3 = 255;<br />
uint16_t val4 = 256;<br />
<br />
while(1)<br />
{<br />
PORTD = val1;<br />
_delay_ms(2000);<br />
clignote();<br />
PORTD = val2;<br />
_delay_ms(2000);<br />
clignote();<br />
PORTD = val3;<br />
_delay_ms(2000);<br />
clignote();<br />
PORTD = val4;<br />
_delay_ms(2000);<br />
for (int i=0;i<10;i++) clignote();<br />
}<br />
}<br />
</source><br />
<br />
{{Question|Indiquer l'affichage réalisé par chacune des lignes}} PORTD=valx<br />
<br />
Les nombres négatifs sont représentés pas la méthodes des compléments à deux : https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_deux ]<br />
<br />
=Decodage d'un clavier=<br />
<br />
==Câblage==<br />
<br />
Le tableau suivant résume la disposition physique du clavier avec la position physique sur le connecteur des lignes (L0 à L3) et colonnes (C0 à C2) en vue de dessus :<br />
{|align="center" border="1" cellpadding="20" cellspacing="0"<br />
|-<br />
| <br />
{|cellpadding="0" cellspacing="0"<br />
|-<br />
| <br />
{|align="center" border="1" cellpadding="3" cellspacing="0"<br />
|-<br />
| PC2 || PC3 || PC4 || PC5 || PB0 || PB1 || PB2<br />
|-<br />
| L0 || L1 || L2 || L3 || C0 || C1 || C2<br />
|}<br />
|-<br />
| <br />
[[Fichier:ArduinoClavier.png]]<br />
|}<br />
||<br />
{| class="wikitable"<br />
|-<br />
! L/C !! C0 !! C1 !! C2<br />
|-<br />
! L0 || 1 || 2 || 3<br />
|-<br />
! L1 || 4 || 5 || 6<br />
|-<br />
! L2 || 7 || 8 || 9<br />
|-<br />
! L3 || * || 0 || #<br />
|}<br />
||<br />
[[Fichier:ClavierMatricielPrincipe.png|200px]]<br />
|}<br />
<br />
{{Todo|Câbler sur une plaque à essais le clavier 12 touches que l'on vous donne. Les {{Rouge|colonnes}} seront reliées sur le port {{Rouge|B}} et les {{Vert|lignes}} sur le port {{Vert|C}} (cf indications ci dessus)}}<br />
<br />
'''Remarque :''' On ne câblera aucune résistance de tirage, on utilisera les résistances internes au µcontrôleur.<br />
<br />
{{Aide|pullUp}}<br />
<br />
<br />
2 étapes sont nécessaires pour activer une résistance de pullUp sur une broche :<br />
*Configurer la broche en entrée<br />
**pour une seule broche : DDRB &=~ (1<<PB1);<br />
**pour un groupe : DDRB &=~ ((1<<PB1)|(1<<PB2)|(1<<PB3) ...);<br />
*Activer ensuite la/les résistance(s) de pullUp<br />
**pour une seule broche : PORTB |= (1<<PB1);<br />
**pour un groupe : PORTB |= (1<<PB1)|(1<<PB2)|(1<<PB3) ...;<br />
{{finAide}}<br />
<br />
=={{Bleu|Principe de décodage}}==<br />
<br />
En utilisant un clavier matriciel, chaque touche n'est pas associé à une broche du µcontrôleur. Dans le cas présent, on passe de :<br />
*12 entrées nécessaires si chaque touche était connectée directement<br />
*7 broches nécessaires avec le clavier matriciel<br />
<br />
L'intérêt évident est donc une {{Rouge|réduction du nombre de broches}} nécessaires à l'utilisation du clavier.<br />
<br />
L'inconvénient qui en résulte est la {{Rouge|complexité relative du code}} pour trouver quelle touche est appuyée.<br />
<br />
Le principe de décodage est {{Rouge|symétrique}} entre lignes et colonnes. Détaillons donc le fonctionnement pour trouver sur quelle ligne une touche est appuyée :<br />
<br />
*On configure les broches {{Rouge|colonnes en sortie}}.<br />
*On configure ces sorties à {{Rouge|l'état 0}}<br />
*Les broches {{Rouge|lignes sont en entrée}}<br />
*l'état des lignes dépend de l'appui sur un bouton :<br />
**si {{Rouge|aucun bouton}} appuyé, les résistances de tirage donnent {{Rouge|un état 1}} sur les lignes<br />
**si on appui sur un bouton de {{Rouge|la ligne0}} (key 1/2/3), alors l'entrée ligne PC2 passe à {{Rouge|l'état 0}}.<br />
**la valeur change suivant la ligne sur laquelle un bouton est appuyé<br />
*il suffit donc d'observer les 4 bits PC5..PC2 (que l'on note ici etat), et ainsi :<br />
**si PC5..PC2 = 1111 , pas de touche<br />
**si PC5..PC2 = 1110 , au moins une touche parmi 1/2/3<br />
**si PC5..PC2 = 1101 , au moins une touche parmi 4/5/6<br />
**...<br />
<br />
==Indice de ligne==<br />
<br />
{{Question|Compléter et vérifier le programme lecture_ligne() qui renvoie le numéro de ligne sur laquelle un bouton est appuyé}}<br />
*La validation se fera en utilisant des leds connectées sur le port C :<br />
**On utilisera les 8 leds du PORTD pour afficher le résultat<br />
**par ex : PORTD = lecture_ligne();<br />
<br />
<source lang=cpp><br />
int8_t lectureLigne()<br />
{<br />
int8_t etatEntrees;<br />
DDRB |= ( (1<<PB2)|(1<<PB1)|(1<<PB0) ) ; // commençons par lister les sorties sur le port B<br />
DDRC &=~ ( (1<<PC5)|(1<<PC4)|(1<<PC3)|(1<<PC2) ) ; // puis les entrées sur le port C<br />
PORTB &=~ ( (1<<PB2)|(1<<PB1)|(1<<PB0) ) ; // on place les sortie à l'état 0<br />
PORTC |= ( (1<<PC5)|(1<<PC4)|(1<<PC3)|(1<<PC2) ) ; // on active les résistances de pull-up sur les entrées<br />
<br />
_delay_ms(1); // un délai est nécessaire pour l'activation des pull-ups<br />
<br />
etatEntrees = PINC & 0b00111100; // on récupère ensuite l'état des entrées en cachant les bits non utiles<br />
switch (etatEntrees)<br />
{<br />
// PPPPPPPP<br />
// CCCCCCCC<br />
// ..5432..<br />
case 0b00111000 : return 0; // L0 (appui sur l'une des touches 1/2/3 => {{Rouge|entrée PC2 à 0}} )<br />
case 0b00110100 : return 1; // L1 => {{Rouge|entrée PC3 à 0}} <br />
case : return 2; // L2<br />
case : return 3; // L3<br />
// si autre cas, pas de touches deux touches ou autre<br />
default : return -1;<br />
}<br />
}<br />
</source><br />
<br />
=={{Bleu|Indice de colonne}}==<br />
<br />
<br />
{{Question|De la même façon, écrire et tester la fonction lecture_colonne() qui permettra d'obtenir le numéro de colonne sur laquelle un bouton est appuyé.}}<br />
<br />
<br />
==Touche appuyée==<br />
Nous souhaitons maintenant écrire une fonction qui renverra une valeur tel que décrit ci dessous :<br />
<br />
{| class="wikitable"<br />
|-<br />
| <source lang=c><br />
const int8_t touches[4][3] = { // tableau de int8_t à 2 dimensions<br />
{ 1, 2, 3},<br />
{ 4, 5, 6},<br />
{ 7, 8, 9},<br />
{10, 0,11}<br />
};<br />
<br />
int8_t getTouche();<br />
</source><br />
|| La valeur retournée sera :<br />
* -1 si pas de touches (ou plusieurs) appuyées<br />
* la valeur correspondant à la touche pour les chiffres<br />
* 11 pour le #<br />
* 10 pour l' *<br />
|}<br />
<br />
{{Question|Écrire cette fonction en vous servant bien évidemment des 2 fonctions précédentes et pourquoi pas du tableau "touches" :}}<br />
<br />
*c'est un tableau de 4 lignes et 3 colonnes<br />
*la valeur dans la case [0,0] correspond à la valeur de la touche pour ligne=0 et colonne=0 => 1<br />
*la valeur dans la case [1,2] correspond à la valeur de la touche pour ligne=1 et colonne=2 => 6<br />
<br />
<source lang=c><br />
int8_t getTouche()<br />
{<br />
....<br />
}<br />
</source><br />
<br />
=réalisation d'un digicode=<br />
<br />
Nous allons utiliser la fonction {{Rouge|getTouche()}} pour réaliser un programme de digicode.<br />
<br />
==contraintes==<br />
Commençons pour définir les contraintes :<br />
<br />
*On appuie sur la touche '*' pour démarrer la saisie du code => la led rouge s'allume brièvement<br />
*L'utilisateur doit alors saisir le code sur 4 chiffres<br />
*On valide le code par la touche '#'<br />
*Si le code est bon une led verte s'allume pendant 10s, sinon une led rouge clignote pendant 10s<br />
<br />
<br />
==codez !==<br />
<br />
{{Question|Ecrire un programme répondant au cahier des charges}}<br />
<br />
*vous pouvez vous servir d'un LLM<br />
**https://claude.ai/new<br />
**[https://gemini.google.com/app?utm_source=deepmind.google&utm_medium=referral&utm_campaign=gdm&utm_content= gemini]<br />
*il suffit de mémoriser les 6 dernières touches appuyées<br />
**déclarer un tableau<br />
**faire un décalage du tableau<br />
**rentrer la nouvelle valeur<br />
**comparer le tableau par rapport au code<br />
<br />
==Améliorations==<br />
<br />
{{Question|Ajouter une procédure de changement du code.}}<br />
<br />
<br />
{{Question|Faire en sorte que le temps maximum de saisie du code soit de 4s}}</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20839Cours:Classif2026-02-05T08:23:43Z<p>Fredmn : /* Livrable et évaluation */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Il semble nécessaire de désactiver l'écran tactile pour éviter les pertes de connexion avec la caméra : <code>rmmod edt_ft5x06</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer deux classes d'objets (jeton long, jeton rond)<br />
* Réaliser une série d'acquisition / description<br />
* Caractériser les performances du systèmes par une courbe ROC. En fixant un taux de faux positifs, choisir un point de fonctionnement et donner la matrice de confusion liée.<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>c2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source lang=python><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Livrable et évaluation ===<br />
<br />
* En fin de période : démonstration de l'état d'avancement<br />
* Un envoi par mail pour le 20/02/2026 (23h59), contenant :<br />
** une archive de votre projet (fonctionnel, doit pouvoir être testé), incluant un fichier README.TXT décrivant l'utilisation du code<br />
** un compte rendu en pdf :<br />
*** description des problèmes traités<br />
*** description des solutions implémentées : approche méthodologique, implémentation pratique<br />
*** description des performancess obtenues (pour chaque solution)<br />
*** conclusion sur ces performances et sur le système<br />
** pas de contrainte de nombre de pages, mais raisonnablement entre 5 et 15.<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Source d'inspiration :<br />
* [https://github.com/360er0/awesome-lego-machine-learning ''Awesome LEGO Machine Learning'']<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20838Cours:Classif2026-02-05T08:22:18Z<p>Fredmn : /* Livrable et évaluation */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Il semble nécessaire de désactiver l'écran tactile pour éviter les pertes de connexion avec la caméra : <code>rmmod edt_ft5x06</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer deux classes d'objets (jeton long, jeton rond)<br />
* Réaliser une série d'acquisition / description<br />
* Caractériser les performances du systèmes par une courbe ROC. En fixant un taux de faux positifs, choisir un point de fonctionnement et donner la matrice de confusion liée.<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>c2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source lang=python><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Livrable et évaluation ===<br />
<br />
* En fin de période : démonstration de l'état d'avancement<br />
* Un envoi par mail pour le 20/02/2026 (23h59), contenant :<br />
** une archive de votre projet (fonctionnel, doit pouvoir être testé), incluant un fichier README.TXT décrivant l'utilisation du code<br />
** un compte rendu en pdf :<br />
*** description du problème traité<br />
*** description de la solution implémentée : approche méthodologique, implémentation pratique<br />
*** description des performances obtenue<br />
*** conclusion sur ces performances et sur le système<br />
** pas de contrainte de nombre de pages, mais raisonnablement entre 5 et 15.<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Source d'inspiration :<br />
* [https://github.com/360er0/awesome-lego-machine-learning ''Awesome LEGO Machine Learning'']<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20837Cours:Classif2026-02-05T08:21:23Z<p>Fredmn : /* Livrable */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Il semble nécessaire de désactiver l'écran tactile pour éviter les pertes de connexion avec la caméra : <code>rmmod edt_ft5x06</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer deux classes d'objets (jeton long, jeton rond)<br />
* Réaliser une série d'acquisition / description<br />
* Caractériser les performances du systèmes par une courbe ROC. En fixant un taux de faux positifs, choisir un point de fonctionnement et donner la matrice de confusion liée.<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>c2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source lang=python><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Livrable et évaluation ===<br />
<br />
* En fin de période : démonstration de l'état d'avancement<br />
* un envoir par mail pour le 20/02/2026 (23h59), contenant :<br />
** une archive de votre projet (fonctionnel, doit pouvoir être testé), incluant un fichier README.TXT décrivant l'utilisation du code<br />
** un compte rendu en pdf :<br />
*** description du problème traité<br />
*** description de la solution implémentée (méthodologiquement et pratiquement)<br />
*** description des performances obtenue<br />
*** conclusion sur ces performances et sur le système<br />
** pas de contrainte de nombre de pages, mais raisonnablement entre 5 et 15.<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Source d'inspiration :<br />
* [https://github.com/360er0/awesome-lego-machine-learning ''Awesome LEGO Machine Learning'']<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20836Cours:Classif2026-02-05T08:21:09Z<p>Fredmn : </p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Il semble nécessaire de désactiver l'écran tactile pour éviter les pertes de connexion avec la caméra : <code>rmmod edt_ft5x06</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer deux classes d'objets (jeton long, jeton rond)<br />
* Réaliser une série d'acquisition / description<br />
* Caractériser les performances du systèmes par une courbe ROC. En fixant un taux de faux positifs, choisir un point de fonctionnement et donner la matrice de confusion liée.<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>c2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source lang=python><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Livrable ===<br />
<br />
* En fin de période : démonstration de l'état d'avancement<br />
* un envoir par mail pour le 20/02/2026 (23h59), contenant :<br />
** une archive de votre projet (fonctionnel, doit pouvoir être testé), incluant un fichier README.TXT décrivant l'utilisation du code<br />
** un compte rendu en pdf :<br />
*** description du problème traité<br />
*** description de la solution implémentée (méthodologiquement et pratiquement)<br />
*** description des performances obtenue<br />
*** conclusion sur ces performances et sur le système<br />
** pas de contrainte de nombre de pages, mais raisonnablement entre 5 et 15.<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Source d'inspiration :<br />
* [https://github.com/360er0/awesome-lego-machine-learning ''Awesome LEGO Machine Learning'']<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20835Cours:Classif2026-02-05T07:40:16Z<p>Fredmn : /* Descripteur et Classifieur plus évolué */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Il semble nécessaire de désactiver l'écran tactile pour éviter les pertes de connexion avec la caméra : <code>rmmod edt_ft5x06</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer deux classes d'objets (jeton long, jeton rond)<br />
* Réaliser une série d'acquisition / description<br />
* Caractériser les performances du systèmes par une courbe ROC. En fixant un taux de faux positifs, choisir un point de fonctionnement et donner la matrice de confusion liée.<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>c2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source lang=python><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Source d'inspiration :<br />
* [https://github.com/360er0/awesome-lego-machine-learning ''Awesome LEGO Machine Learning'']<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20834Cours:Classif2026-02-05T07:39:36Z<p>Fredmn : /* Références */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Il semble nécessaire de désactiver l'écran tactile pour éviter les pertes de connexion avec la caméra : <code>rmmod edt_ft5x06</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer deux classes d'objets (jeton long, jeton rond)<br />
* Réaliser une série d'acquisition / description<br />
* Caractériser les performances du systèmes par une courbe ROC. En fixant un taux de faux positifs, choisir un point de fonctionnement et donner la matrice de confusion liée.<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source lang=python><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Source d'inspiration :<br />
* [https://github.com/360er0/awesome-lego-machine-learning ''Awesome LEGO Machine Learning'']<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20833Cours:Classif2026-02-04T15:52:13Z<p>Fredmn : /* Connexion à la Rpi et test d'acquisition en ligne de commande */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Il semble nécessaire de désactiver l'écran tactile pour éviter les pertes de connexion avec la caméra : <code>rmmod edt_ft5x06</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer deux classes d'objets (jeton long, jeton rond)<br />
* Réaliser une série d'acquisition / description<br />
* Caractériser les performances du systèmes par une courbe ROC. En fixant un taux de faux positifs, choisir un point de fonctionnement et donner la matrice de confusion liée.<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source lang=python><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20832Cours:Classif2026-02-04T13:55:09Z<p>Fredmn : /* Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer deux classes d'objets (jeton long, jeton rond)<br />
* Réaliser une série d'acquisition / description<br />
* Caractériser les performances du systèmes par une courbe ROC. En fixant un taux de faux positifs, choisir un point de fonctionnement et donner la matrice de confusion liée.<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source lang=python><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20811Cours:Classif2026-02-02T14:19:31Z<p>Fredmn : /* Descripteur et Classifieur plus évolué */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source lang=python><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20810Cours:Classif2026-02-02T14:18:10Z<p>Fredmn : /* Bouts de code Python */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|capture_image.py]]}}<br />
<source lang=python><br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
</source><br />
{{boîte déroulante/fin}}<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20809Cours:Classif2026-02-02T14:17:14Z<p>Fredmn : /* Bouts de code Python */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|Media:capture_image.py]]}}<br />
import time<br />
from picamera2 import Picamera2<br />
<br />
def capture_image_with_retries(<br />
max_attempts: int = 5,<br />
warmup_s: float = 0.3,<br />
retry_delay_s: float = 0.5,<br />
):<br />
"""<br />
Initialise Picamera2 + capture une image.<br />
Si échec, réessaie en recréant complètement la caméra.<br />
Retourne un numpy array (image) ou lève RuntimeError après max_attempts.<br />
"""<br />
last_err = None<br />
<br />
for attempt in range(1, max_attempts + 1):<br />
picam = None<br />
try:<br />
picam = Picamera2()<br />
<br />
# Optionnel mais souvent utile: choisir explicitement une config "preview"<br />
config = picam.create_preview_configuration(main={"size": (1280, 720)})<br />
picam.configure(config)<br />
<br />
picam.start()<br />
<br />
# Laisse le temps à l'auto-exposition/auto-gain de se stabiliser<br />
time.sleep(warmup_s)<br />
<br />
# Capture (guillemet manquant corrigé)<br />
img = picam.capture_array("main")<br />
<br />
# Vérifs basiques pour détecter une "non acquisition"<br />
if img is None:<br />
raise RuntimeError("capture_array a renvoyé None")<br />
if getattr(img, "size", 0) == 0:<br />
raise RuntimeError("image vide (size=0)")<br />
if len(getattr(img, "shape", ())) < 2:<br />
raise RuntimeError(f"shape invalide: {getattr(img, 'shape', None)}")<br />
<br />
# Succès<br />
return img<br />
<br />
except Exception as e:<br />
last_err = e<br />
print(f"[Tentative {attempt}/{max_attempts}] Échec acquisition: {e}")<br />
<br />
finally:<br />
# Nettoyage propre pour pouvoir repartir clean<br />
try:<br />
if picam is not None:<br />
picam.stop()<br />
except Exception:<br />
pass<br />
try:<br />
if picam is not None:<br />
picam.close()<br />
except Exception:<br />
pass<br />
<br />
time.sleep(retry_delay_s)<br />
<br />
raise RuntimeError(f"Impossible de capturer une image après {max_attempts} tentatives. Dernière erreur: {last_err}")<br />
<br />
<br />
if __name__ == "__main__":<br />
img = capture_image_with_retries(max_attempts=10)<br />
print("Capture OK:", img.shape, img.dtype)<br />
{{boîte déroulante/fin}}<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20808Cours:Classif2026-02-02T14:16:55Z<p>Fredmn : /* Bouts de code Python */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
* Acquisition d'image en recommançant en cas d'échec :<br />
<br />
{{boîte déroulante/début|titre=[[Media:capture_image.py|Media:capture_image.py]]}}<br />
test<br />
{{boîte déroulante/fin}}<br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20805Cours:Classif2026-02-02T09:54:57Z<p>Fredmn : /* Descripteur et Classifieur plus évolué */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs de Fourier<br />
** On transforme le contour d’un objet (suite de points) en un signal périodique, puis on le décompose en harmoniques avec la transformée de Fourier. Les premiers coefficients décrivent la forme globale et, une fois normalisés, ils permettent de comparer/reconnaître des formes indépendamment de la position, de la taille et de la rotation.<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20804Cours:Classif2026-02-02T09:52:25Z<p>Fredmn : /* Descripteur et Classifieur plus évolué */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
# Descripteurs de Fourier<br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20803Cours:Classif2026-02-02T09:52:07Z<p>Fredmn : /* Descripteur et Classifieur plus évolué */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
** Exemple :<br />
<source lang=python><br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
<source><br />
# Normalisation<br />
fd = np.squeeze(fd)<br />
<br />
# Assure forme (nbFD, 2)<br />
if fd.ndim == 1 and fd.shape[0] == 2*nbFD:<br />
fd = fd.reshape(nbFD, 2)<br />
<br />
re = fd[:, 0].astype(np.float32)<br />
im = fd[:, 1].astype(np.float32)<br />
<br />
mag = np.sqrt(re*re + im*im) # rotation-invariant<br />
mag[0] = 0.0 # enlève la composante continue (liée à la translation)<br />
<br />
# normalisation d'échelle (et normalisation globale)<br />
norm = np.linalg.norm(mag) + 1e-12<br />
feat = mag / norm<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20802Cours:Classif2026-02-02T09:49:18Z<p>Fredmn : /* Descripteur et Classifieur plus évolué */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Exemple :<br />
<source lang=python><br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
** Il sera nécessaire de normaliser ces descripteurs : https://dsp.stackexchange.com/questions/19982/fourier-descriptors-trying-to-classify-objects<br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20801Cours:Classif2026-02-02T09:41:11Z<p>Fredmn : /* Classifieur plus évolué */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Descripteur et Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Exemple :<br />
<source lang=python><br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmnhttp://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Classif&diff=20800Cours:Classif2026-02-02T09:40:39Z<p>Fredmn : /* Classifieur plus évolué */</p>
<hr />
<div><center><br />
'''<big>TP Classification : détection d'objet en temps réel par vision</big>'''<br />
</center><br />
<br />
Le travail de cette étape va consister à <br />
* analyser des images acquises en "temps réel" afin de détecter et identifier des objets<br />
* les objets seront<br />
** dans un premier temps des jetons de nain jaune<br />
** dans un second temps des briques lego.<br />
<br />
=== Technos matérielles et logicielles ===<br />
<br />
Vous utiliserez :<br />
* Une Rpi 4 que vous programmerez depuis des postes utilisés en terminaux connectés par <code>ssh</code>, avec redirection graphique (option <code>- X</code>).<br />
* Une camera PiCam Wide (grand angle)<br />
* Le langage Python accompagné de <br />
** la librairie libcamera pour les acquisitions :<br />
*** https://github.com/raspberrypi/libcamera<br />
*** https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline<br />
** PIL et numpy pour les traitements bas niveaux<br />
** les librairies opencv et dlib pour la classification et la reconnaissance :<br />
*** https://docs.opencv.org/4.5.1/index.html<br />
*** https://docs.opencv.org/4.5.1/d6/d00/tutorial_py_root.html<br />
*** https://dlib.net/<br />
<br />
Étapes :<br />
* Connexion à la Rpi et test d'acquisition en ligne de commande<br />
* Capture d'image et affichage en temps réel, avec Python<br />
* Prétraitement<br />
* Reconnaissance simple d'un seul objet, avec descripteurs géométriques<br />
* Classifieur plus évolué (knn, svm)<br />
* Plusieurs objets<br />
<br />
=== Connexion à la Rpi et test d'acquisition en ligne de commande ===<br />
<br />
* Connecter (si cela n'est pas fait) la PiCam à la Rpi4<br />
* Dans un terminal, se connecter à la Rpi en ssh : <code>ssh -X root@10.98.33.XX</code><br />
* Tester la PiCam avec <code>libcamera-hello</code> (la capture en video doit s'afficher sur l'écran de la Rpi). Avec les informations affichées, identifier :<br />
** le modèle du capteur,<br />
** ses caractéristiques (résolution, format, cadence, etc ...).<br />
* Tester l'acquisition d'image avec l'éxecutable <code>libcamera-still</code><br />
** Explorer les options de cette application (<code>libcamera-still -h</code>), en particulier <code>-n</code>, <code>--immediate</code>, <code>--width</code>, <code>--height</code> et <code>-o</code><br />
** Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html<br />
<br />
=== Capture d'image et affichage en temps réel ===<br />
<br />
En exploitant la documentation [https://pip-assets.raspberrypi.com/categories/652-raspberry-pi-camera-module-2/documents/RP-008156-DS-2-picamera2-manual.pdf?disposition=inline Picamera2] (principalement section 6 - ''Capturing images and requests'')<br />
* Tester les deux exemples ''Capturing arrays'' et ''Capturing PIL images''<br />
** PIL fait référence à [https://www.pythonware.com/products/pil/ Python Imaging Library] : une bibliothèque Python de traitement d'images.<br />
* Écrire un script Python qui :<br />
** initialise la camera<br />
** affiche en continu son image<br />
** sur l'appui d'une touche, réalise une capture (dans un objet <code>array</code> ou <code>PIL</code>) et sauvegarde l'image dans un fichier<br />
<br />
En pratique :<br />
* Vous pouvez lancer un interpréteur Python dans le terminal pour tester des choses<br />
* Vous pouvez accéder aux dossiers de la Rpi depuis votre PC fixe, depuis le navigateur Dolphin avec comme url <code>sftp://root@10.98.33.83:22/</code>. Ce qui vous permettra par exemple d'éditer le fichier script depuis votre PC fixe.<br />
* Dans le terminal, <code>python monscript.py</code> pour executer votre script<br />
* On peut facilement attendre l'appui d'une touche avec <code>cv2.waitkey()</code><br />
* Référence Python :<br />
** [https://docs.python.org/fr/3/tutorial/ Le tutoriel Python]<br />
<br />
=== Prétraitement ===<br />
<br />
* Modification éventuelle de la zone de capture de la camera (''crop'').<br />
* Conversion en image niveaux de gris, sur 8 bits.<br />
* Binarisation (en mettant l'objet à 255, le fond à 0).<br />
<br />
=== Reconnaissance simple d'un seul objet, avec descripteurs géométriques élémentaires ===<br />
<br />
* En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur et largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments (calcul de ''l'' et ''w'')<br />
* Construire une décision idoine à l'aide de la largeur et de la longueur de l'ellipse englobante, afin de discrimer trois classes d'objets (par exemple : jeton court, jeton long, jeton rond)<br />
<br />
<br />
Exemple de calcul de <code>l</code> et <code>w</code> à partir d'une image binaire représentée dans un tableau <code>numpy</code> (<code>arr</code> de type <code>ndarray</code>) :<br />
<source lang=python><br />
img = arr.astype(np.float64, copy=False)<br />
H, W = img.shape<br />
yy, xx = np.indices((H, W))<br />
<br />
M00 = float(np.sum(img))<br />
M10 = float(np.sum(xx * img))<br />
M01 = float(np.sum(yy * img))<br />
M11 = float(np.sum(xx * yy * img))<br />
M20 = float(np.sum((xx * xx) * img))<br />
M02 = float(np.sum((yy * yy) * img))<br />
<br />
xm = int(M10 / M00)<br />
ym = int(M01 / M00)<br />
<br />
mu20 = M20 / M00 - xm * xm<br />
mu02 = M02 / M00 - ym * ym<br />
mu11 = M11 / M00 - xm * ym<br />
<br />
t = math.sqrt(4.0 * mu11 * mu11 + (mu20 - mu02) * (mu20 - mu02))<br />
l = int(math.sqrt(8.0 * (mu20 + mu02 + t)))<br />
w = int(math.sqrt(8.0 * (mu20 + mu02 - t)))<br />
</source><br />
<br />
=== Classifieur plus évolué ===<br />
<br />
<br />
* Descripteurs<br />
** Méthodologie :<br />
*** image en niveau de gris (éventuellement binarisation) : <code>cv2.cvtColor()</code><br />
*** détection des contours : <code>cv2.Canny()</code> et <code>v2.findContours()</code> <br />
*** description des contours : <code>cv2.ximgproc.fourierDescriptor()</code><br />
** Références :<br />
*** https://docs.opencv.org/4.x/d4/d73/tutorial_py_contours_begin.html<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#gadf1ad6a0b82947fa1fe3c3d497f260e0<br />
*** https://docs.opencv.org/4.x/d3/dc0/group__imgproc__shape.html#ga819779b9857cc2f8601e6526a3a5bc71<br />
** Exemple :<br />
<source lang=python><br />
from picamera2 import Picamera2<br />
import numpy as np<br />
import cv2<br />
<br />
picam = Picamera2()<br />
picam.start()<br />
a = picam.capture_array("main")<br />
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<br />
edges = cv2.Canny(gray, 100, 200)<br />
contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)<br />
cnt = max(contours, key=cv2.contourArea)<br />
cnt = cnt.astype(np.float32)<br />
<br />
# Paramètres utiles :<br />
# nbElt = nombre de points ré-échantillonnés sur le contour<br />
# nbFD = nombre de descripteurs gardés<br />
fd = cv2.ximgproc.fourierDescriptor(cnt, nbElt=128, nbFD=16)<br />
<br />
print(fd.shape, fd.dtype)<br />
</source><br />
* KNN<br />
** https://docs.opencv.org/4.5.1/d5/d26/tutorial_py_knn_understanding.html<br />
* Redressement de la perspective<br />
** Détecteur de coin de Harris : https://docs.opencv.org/4.5.1/dc/d0d/tutorial_py_features_harris.html<br />
** <code>cv2.findHomography()</code> et <code>c2.warpPerspective()</code><br />
** ou https://docs.opencv.org/4.5.1/da/d6e/tutorial_py_geometric_transformations.html<br />
* SVM<br />
<br />
=== Plusieurs objets ===<br />
<br />
* Segmentation nécessaire pour séparer les objets.<br />
* Puis une labellisation pour les numéroter.<br />
<br />
=== Bouts de code Python ===<br />
<br />
* Convertir une image couleur img (4 canaux) en image OpenCV :<br />
<source lang=python><br />
import cv2<br />
im_cv = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)<br />
</source><br />
<br />
=== Références ===<br />
<br />
OpenCV :<br />
* [https://docs.opencv.org/4.x/d9/df8/tutorial_root.html ''OpenCV Tutorials''] <br />
* [https://docs.opencv.org/4.x/examples.html Exemples OpenCV en c++]<br />
* [https://docs.opencv.org/4.x/d0/d72/tutorial_py_knn_index.html ''K-Nearest Neighbour'']<br />
* [https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html ''Image Segmentation with Watershed Algorithm'']<br />
* [https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5 ''connected Components''] et son exemple en cpp : https://docs.opencv.org/3.4/de/d01/samples_2cpp_2connected_components_8cpp-example.html#a3<br />
* [https://docs.opencv.org/4.x/d1/d73/tutorial_introduction_to_svm.html ''Introduction to Support Vector Machines'']<br />
* [https://docs.opencv.org/3.4/dd/ddc/group__ximgproc__fourier.html ''Fourier Descriptors''], voir également [https://docs.opencv.org/3.4/da/d32/samples_2cpp_2contours2_8cpp-example.html ''Contours example''] pour obtenir les contours d'un objet.<br />
<br />
Archives de cette page :<br />
* [[Cours:Classif_archive]]</div>Fredmn