UNIVERSITE DE LA ROCHELLE – MASTER IMA

1ère année - Vision par ordinateur 1

TP N °2 : OPENCV PRISE EN MAIN ET APPLICATION

Cahier Etudiant

1 PREAMBULE
L’objectif de ce TP est de vous apprendre à utiliser et à coder une application concrète sous
OpenCV.
Dans un premier temps , vous programmerez ouverture et l’affichage d’une image d’un format
quelconque. Par la suite, vous programmerez des traitements de bases sous la forme de fonctions
OpenCV préexistantes.
Enfin dans une dernière partie concernera la programmation d’une application concrète, vous
aurez à charge d’utiliser des fonctions existantes, mais aussi de coder vos propres algorithmes.

2 PRISE EN MAIN

2.1 Créer une application sous l’environnement Visual C++

L’application que l’on vous demande de créez ici est simplement une MFC Application de type
Dialog based (File/New/MFCApplication)

Lancez la compilation de votre projet une fenêtre du type suivant doit s’afficher.
 L’objectif de ce TP va être de modifier la fenêtre ci-dessus afin de permettre un certain nombre
de traitements. Le premier doit être l’ouverture d’une image et son affichage

Dans votre projet Visual, les classes dont le nom finit par Dlg, contiendront les fonctions qui
piloteront les interfaces et les commandes de la fenêtre.

2.2 Liaison Visual/OpenCV

Puisque nous sommes sensé utiliser OpenCV, incluez les fichiers suivants dans les chemins
concernant les fichiers include et librairy. (Tools/Options/Directories, concernant les include puis
Librairy)

Enfin, ajoutez les deux librairies suivantes à votre projet.

cv.lib highgui.lib
 2.3 Ouverture d’une image

Ajouter un bouton dans votre interface afin de permettre l’ouverture d’un certain nombre de fichier
en particulier les images.
Modifier ces propriétés afin d’afficher le texte « Ouvrir une image » plutôt que Button1.
Double cliquez sur ce bouton.
Vous devez normalement vous trouvez dans le corps d’une fonction rajoutez automatiquement par
Visual. Une fonction nommée :
void CTPVsionDlg::OnBnClickedButton1().

Ajouter le code suivant :

CFileDialog dlg(TRUE, _T("*.bmp"), "",

OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY,"image
files (*.bmp; *.jpg) |*.bmp;*.jpg|AVI files (*.avi) |*.avi|All
Files (*.*)|*.*||",NULL);
char title[]= {"Ouvrir image"};
dlg.m_ofn.lpstrTitle= title;
if (dlg.DoModal() == IDOK) {
CString path= dlg.GetPathName();
}

Commentez le.
Définissez maintenant un fichier TPVisionApp.h contenant le code ci-dessous.
Les lignes de codes permettant d’afficher l’image dont le nom est passé en paramètre ont été
enlevées. A vous de retrouver le bon code.

#if !defined IMAGEPROCESSOR

#define IMAGEPROCESSOR
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "cv.h” // include core library interface
#include "highgui.h" // include GUI library interface

class ImageProcessor
{
IplImage* img; // Declare IPL/OpenCV image pointer
public:
ImageProcessor(CString filename, bool display=true)
{
// Charger une image

if (display)
{
// Créer une fenêtre

//afficher l’image dans la fenêtre

}
}
~ImageProcessor()
{
cvReleaseImage( &img );
}
};
#endif
Modifiez esuite la fonction void CTPVsionDlg::OnBnClickedButton1() afin que
l’on puisse réaliser le code de la classe ImageProcessor

if (dlg.DoModal() == IDOK) {
CString path= dlg.GetPathName();
//creation d’un objet ImageProcessor pour l’affichage d’une
//image
}

Attention ne pas oubliez d’inclure #include "TPVisionapp.h" si vous voulez que

ça marche.

2.4 Application de fonction OpenCV

Ajoutons maintenant une fonction dans TPVisionApp.cpp qui permette de réaliser une érosion sur
l’image passé en paramêtre.

#include "stdafx.h"
#include "TPVisionApp.h"

//**************************
// A global variable
ImageProcessor *proc = 0;
//**************************

//**************************************
// the function that processes the image
void process(void* img)
{
IplImage* image = reinterpret_cast<IplImage*>(img);
//érosion de image

}
//**************************************

//******************************
void ImageProcessor::execute()
{
process(img);
}
//******************************

2.5 Création d’une image et accès aux valeurs des pixels

Les informations qui suivent permettent de créer d’accéder aux

pixels d’une image.

IplImage*
gray= iplCreateImageHeader(1,0,IPL_DEPTH_8U,"GRAY","G",IPL_DATA_ORD
ER_PIXEL,IPL_ORIGIN_TL,IPL_ALIGN_QWORD,width,height,NULL,NULL,NULL,
NULL);
iplAllocateImage(gray, 1, 0);

• Créer une image en couleur

IplImage* color = iplCreateImageHeader(3,0, IPL_DEPTH_8U, "RGB",
"BGR",IPL_DATA_ORDER_PIXEL, IPL_ORIGIN_TL, IPL_ALIGN_QWORD, width,
height, NULL,NULL,NULL,NULL);
iplAllocateImage(color, 1, 0);

• Une alternative plus simple est :

IplImage* color = cvCreate(cvSize(width,height), IPL_DEPTH_8U, 3);

• Pour désallouer : cvReleaseImage(&image).

• Pour récupérer les valeurs des pixels d’une image voici la précédure :

void process(void* img) {

IplImage* image = reinterpret_cast<IplImage*>(img);

int nl= image->height;
int nc= image->width * image->nChannels;

// because imageData is a signed char*

data=(unsigned char*)src_image->imageData;
for (i=0;i<src_image->width * src_image->height;i++)
{
if (data[i])</*seuil*/)
data[i]=0;
else
data[i]=255;
}
cvNamedWindow("image", 0);
cvShowImage( "image", src_image ); }

En vous aidant de ces informations et de l’aide d’Opencv, réalisez

une fonction qui permette de binariser une image avec un seuil
passé en paramètre.
3 APPLICATION
Lors de la dernière séance de TP nous avons travaillé sur des images de bonne qualité.
Malheureusement, les aléas de la chaîne de numérisation font que ce n'est pas toujours le cas.
Au travers d'une application réelle (binarisation d'images d'empreintes digitales) nous allons
voir quelques unes des techniques courantes qui permettent d'améliorer la qualité de l'image en vue
de traitements ultérieurs (segmentation, détection de contours...)
Dans notre cas nous allons nous attaquer à ce type de défauts:

image optimale image floue image bruitée

En vue d'une reconnaissance des empreintes, il vous ait demandé d'établir une méthode de
binarisation automatique la moins sensible possible au bruit présent dans les images que l'on vous
fourni ( i.e. binariser pour se rapprocher au maximum de l'image optimale)

3.1 Utiliser Open CV

Dans un premier temps vous allez utiliser UNIQUEMENT les fonctions proposées par la librairie
OpenCV. L’objectif de cette partie est de se familiariser avec les outils classiques de traitement
d’images présents dans OpenCV. Testez, observez, concluez…

Il y a plusieurs outils à votre disposition (mettre le nez dans l’aide):

1. Applications de filtres
2. Outils morphologiques
3. Outils de détection de contours

Ces méthodes sont paramétriques, vous êtes donc vivement encouragés à mettre en place une
application qui permette de faire varier les paramètres d’entrer de ces dernières.

Vous ferez figurer dans votre rapport les outils qui vous on semblé les plus appropriés, ainsi que
les procédures d’utilisation, paramètres entrées, sorties, type d’image en entrée, en sortie…

3.2 Implémentation d'un algorithme de binarisation automatique

Dans cette partie vous allez réaliser un programme qui permet d’obtenir la meilleure binarisation
possible d'empreintes digitales. Ce qui est détaillé ci-dessous s'inspire d'une méthode utilisée dans
l’article suivant :
“Fingerprint Image Enhancement using Filtering Techniques”, Shlomo Greenberg
et all., Electrical and Computer Engineering Department, Ben-Gurion University of
the Negev, Beer-Sheva, Israel, ICPR 2000
Il s'articule autour de 3 étapes:

• Rehaussement du contraste via égalisation de l’histogramme de niveau de gris

Le but de cette étape est d’améliorer la netteté de l’image. Pour cela on établi un mappage des
niveaux de gris. Le nouveau niveau de gris de chaque pixel ( S k ) est calculé de la manière suivante:

k nj
Sk = ∑ avec k=0,1,2…,255 (pour le nombre de niveaux de gris)
j =0 n

n j le nombre de pixels de niveau de gris j

n le nombre total de pixels

Ce rehaussement est à faire de manière locale c'est-à-dire que vous effectuez le calcul précèdent dans
une fenêtre de 11*11 pixels et que vous vous déplacez ensuite dans l’image pour recommencer le
calcul (cf. TP précédent).

• Filtrage du bruit

Ici l’objectif va être de diminuer le bruit présent dans l’image. Pour cela vous implémenterez le filtre
de Wiener.

Le filtre (w) est de taille 3*3 pixels et se calcule à partir de l’étude des niveaux de gris de la zone de
l’image étudiée :

σ 2 − v2
w( xi , y i ) = µ + ( I ( x, y) − µ ) avec i=1…3
σ2

v 2 la variance du bruit

σ 2 et µ la variance et la moyenne

I(x,y) l’intensité du pixel x,y

Le filtre est ensuite appliqué à la zone de l’image ou il a été calculé.

Vous pouvez chercher des informations sur le filtre de Wiener sur Internet et le développer cette
partie dans votre rapport.

• Binarisation

Dans cette dernière étape l’image est binarisée de manière locale. Sur une fenêtre 13*13 la moyenne
des niveaux de gris de la zone donne le seuil de binarisation.

I new ( xi , yi ) = 1 si I old ( x i , y i ) > moyenne _ locale 0 sinon

Dans votre rapport vous inclurez les copies d’écran des images binarisées que vous avez obtenu.

FIN