Cours:Classif

TP Classification : détection d'objet en temps réel

Le travail de cette étape va consister à

• analyser des images acquise en "temps réel" afin de détecter et identifier des objets
• les objets seront
  • dans un premier temps des jetons de nain jaune
  • dans un second temps des briques lego.

Technos matérielles et logicielles

Vous utiliserez :

• Une Rpi 4 que vous programmerez depuis vos postes linux (en cross-compilation)
• Une camera PiCam Wide (grand angle)
• la librairie CImg pour des traitements bas niveaux et affichages : https://cimg.eu/
• la librairie Dlib pour des traitements simples et la reconnaissance : http://dlib.net/

Vous travaillerez dans un dossier dit "DE TRAVAIL", qui contiendra

• les dossiers de vos projets QtCreator
• le code des librairies Dlib et CImg téléchargées

(dans mes exemples, c'est /home/nicoli01/tests)

Prise d'images en terminal

• Connecter (si cela n'est pas fait) la PiCam à la Rpi4
• Tester la PiCam avec libcamera-hello (la capture doit s'afficher sur l'écran de la Rpi)
• Tester l'acquisition d'image avec l'éxecutable libcamera-still
• Explorer les options de cette application (libcamera-still -h), en particulier -n, --immediate, --width, --height et -o

Voir la page suivante pour le détails des options possibles : https://www.raspberrypi.com/documentation/computers/camera_software.html

Mise en place de la librairie Dlib

Attention, l'affichage des images avec Dlib et CImg sera déporté sur votre PC en X11 forwarding (option "Forward to local display" dans QtCreator ou "ssh -X" pour la connection depuis un terminal)

Cette fonction exploite la librairie Dlib :

• Créer un projet dans QtCreator de type Non-Qt C++
• Télécharger la librairie depuis http://dlib.net, la décompresser et placer son dossier dlib au même niveau que votre dossier de projet
• Modifier votre fichier .pro de la façon suivante :

QMAKE_CXXFLAGS += -DDLIB_JPEG_SUPPORT
INCLUDEPATH += /home/nicoli01/tests # A REMPLACER PAR LE CHEMIN VERS VOTRE DOSSIER DE TRAVAIL
SOURCES += \
        /home/nicoli01/tests/dlib/all/source.cpp ## A REMPLACER DANS VOTRE CAS
LIBS += -ljpeg -lm -lX11 -lpthread

Ne pas oublier les deux lignes

target.path = /root
INSTALLS = target

• Pour le contenu de votre main.cpp, vous pourrez vous inspirer de l'exemple suivant http://dlib.net/image_ex.cpp.html (en remplaçant éventuellement la ligne load_image(img, argv[1]); par load_image(img, "image.png"); pour lire une image que vous aurez acquis avec libcamera). Par exemple :

#include <dlib/gui_widgets.h>
#include <dlib/image_io.h>
#include <dlib/image_transforms.h>
#include <fstream>


using namespace std;
using namespace dlib;

//  ----------------------------------------------------------------------------

int main()
{
    try
    {
        array2d<rgb_pixel> img;

        load_image(img, "/Users/frederic/work/docu/enseignements/GEIIBUT3Classif/tests/im.jpg");

        image_window win;
        win.set_image(img);
        win.wait_until_closed();
    }
    catch (exception& e)
    {
        cout << "exception thrown: " << e.what() << endl;
    }
}

Mise en place de la librairie CImg

La librairie CImg est constituée d'un unique ficher CImg.h

• Télécharger la librairie depuis https://cimg.eu/download.html, décompresser et copier le fichier CImg.h dans votre dossier de travail
• Faire un nouveau projet non Qt, avec le main.cpp suivant pour tester

#include <iostream>

#include "/home/nicoli01/tests/testcimg/CImg.h" // A REMPLACER DANS VOTRE CAS

using namespace cimg_library;

using namespace std;

int main()
{
    cout << "Hello World!" << endl;

    CImg<unsigned char> image("/root/im.png"); // A REMPLACER DANS VOTRE CAS
    image.display("hello");
    return 0;
}

• Votre fichier .pro est plus simple que pour Dlib, vous n'aurez qu'à rajouter la ligne suivante :

LIBS += -ljpeg -lm -lX11 -lpthread -pedantic -Dcimg_use_vt100 -Dcimg_display=1

Prise d'images en c++

Voici une fonction imcapture, qui renvoit une image RGB Dlib, que vous pourrez utiliser pour réaliser une acquisition d'image en c++

array2d<rgb_pixel> imcapture() {
	array2d<rgb_pixel> image;
    int pb = system("rm im.png 2>/dev/null; libcamera-still -n 1 --immediate --width 640 --height 480 -o im.png 2> /dev/null ");
	if (pb) {
		cout << "ERROR: no image acquisition" << endl;
		exit(1);
	} else {
		load_image(image, "im.png");
	}
	return image;		
}

• Utiliser cette fonction imcapture pour écrire un programme qui capture une image et l'affiche (avec Dlib)

Prétraitements et mesure de descripteurs

Cette partie est moins guidée, elle devra être incluse dans votre compte-rendu.

• Modification éventuelle de la zone de capture de la camera (option --roi de libcamera-still, voir https://www.raspberrypi.com/documentation/computers/camera_software.html)

1. Conversion en image niv. de gris (cf assign_image() dans Dlib)
2. Binarisation (cf threshold_image dans Dlib)
3. (si plusieurs objets) Segmentation (cf segment_image() dans Dlib)

Si besoin, conversion d'une image Dlib en une image CImg :

CImg<unsigned char> image(img_gray.nc(), img_gray.nr());
cimg_forXY(image,x,y) {
  image(x,y) = (unsigned char)bin_img[y][x];
}

• En ne plaçant qu'un seul objet dans le champ de la camera, calculer et afficher ses descripteurs de forme : longueur/largeur de l'objet, cf https://raphael.candelier.fr/?blog=Image%20Moments

• Fonction de calcul des descripteurs géométriques (longueur l, largeur w) d'un objet dans une image :

void compute_desc(CImg<> image) {
    long M00, M10, M01, M11, M20, M02;
    M00 = 0; M10 = 0; M01 = 0; M11 = 0; M20 = 0; M02 = 0;
    cimg_forXY(image,x,y) {
        M00 += image(x,y);
        M10 += x*image(x,y);
        M01 += y*image(x,y);
        M11 += x*y*image(x,y);
        M20 += x*x*image(x,y);
        M02 += y*y*image(x,y);
    }
    long xm = M10/M00;
    long ym = M01/M00;
    long mu20 = M20/M00 - xm*xm;
    long mu02 = M02/M00 - ym*ym;
    long mu11 = M11/M00 - xm*ym;
    long l = sqrt(8 * (mu20 + mu02 + sqrt(4*mu11*mu11 + (mu20-mu02)*(mu20-mu02))));
    long w = sqrt(8 * (mu20 + mu02 - sqrt(4*mu11*mu11 + (mu20-mu02)*(mu20-mu02))));
    cout << "l = " << l << endl;
    cout << "w = " << w << endl;
}

Identification par KNN

Cette partie est moins guidée, elle devra être incluse dans votre compte-rendu.

a) Dans un premier temps

• un seul plus proche voisin
• un seul échantillon de référence par classe
• viser une décision binaire (ex. "L'objet est-il de la classe ... ?").

Fonctions éventuellement utiles dans Dlib :

• serialize et deserialize pour sauvegarder et charger des données depuis des fichiers : http://dlib.net/other.html#serialize
• index_of_min pour la recherche du min
• remove_col ou remove_row pour extraire un élément d'un tableau Dlib.
• squared_euclidean_distance pour le calcul de la distance entre deux vecteurs.

b) Puis progressivement

• viser une décision multiclasse (ex. "Quelle est la classe de l'objet ?").
• augmenter le nb d'échantillons de référence par classe (réfléchir à la façon dont vous souhaitez stocker et manipuler cette information). Si vous avez du temps, il serait intéressant de tracer graphiquement la position de vos échantillons de références dans l'espace des descripteurs, par exemple en exportant vos coordonnées (dans cet espace) vers matlab.
• passer à 3 plus proches voisins

c) Ensuite - et seulement, ou si vous n'arrivez pas à coder a) et b) - vous pourrez comparer avec l'implémentation de Dlib :

• find_k_nearest_neighbors : http://dlib.net/graph_tools.html#find_k_nearest_neighbors

Identification par SVM

• En utilisant Dlib