Introduction à OpenCV

Ce document présente les bases indispensables à l'utilisation d'OpenCV à travers son interface C++,

la documentation technique d'OpenCV peut être consultée en ligne. La cheat sheet c++ permet en

outre de trouver facilement une fonction ou un type de données.

Sommaire Introduction à OpenCV ............................................................................................................................ 1

Introduction ......................................................................................................................................... 2

Présentation d'OpenCV ................................................................................................................... 2

Convention de nommage ................................................................................................................ 2

Compilation ..................................................................................................................................... 3

Première exemple C++ : .................................................................................................................. 3

Structures de données de base ........................................................................................................... 4

Les points – Point_........................................................................................................................... 4

Dimension – Size_............................................................................................................................ 4

Rectangle – Rect_ ............................................................................................................................ 4

Vecteur - Vec ................................................................................................................................... 5

Image – Mat .................................................................................................................................... 6

Utilisation de la classe Mat .................................................................................................................. 6

Création d'une nouvelle image ........................................................................................................... 6

Accès aux pixels d'une image .............................................................................................................. 7

Image en niveau de gris ................................................................................................................... 7

Image multibande – couleur ........................................................................................................... 8

Affichage et enregistrement des images ............................................................................................. 9

Affichage d'une image ..................................................................................................................... 9

Enregistrement d'une image ......................................................................................................... 10

Introduction

Présentation d'OpenCV

OpenCV :

est une librairie open source de traitement et analyse d'images et vidéos avec des interfaces

pour les principaux langages de programmation C, C++, Java, C#, Python ...

est optimisée pour les applications temps réelles

fournit une API bas et haut niveau

fournit une interface pour le langage de programmation parallèle IPP

est utilisé aussi bien dans les laboratoires de recherche que dans l'industrie

Fonctions :

manipulation d'images (chargement, sauvegarde, copie, conversion...)

manipulation et acquisition de videos

manipulations de matrices et algèbre linéaire

structure de données utilitaires variées (listes, files, ensembles, graphes...)

traitement d'images (filtrage, détections de discontinuités, morphologie mathématique...)

analyse d'images (composantes connexes, ajustement de primitives, transformée de

distance...)

vision (calibration de caméra, stereovision, recherche d'association...)

reconnaissance de forme (modèles de markov, ACP...)

interface graphique (affichage d'images, de vidéos, gestion des évènements...)

Modules :

cv - Main OpenCV functions.

cvaux - Auxiliary (experimental) OpenCV functions.

cxcore - Data structures and linear algebra support.

highgui - GUI functions.

Convention de nommage

Nommage des fonctions :

cvActionTargetMod(...)

Action = the core functionality (e.g. set, create)

Target = the target image area (e.g. contour, polygon)

Mod = optional modifiers (e.g. argument type)

Type de données pour les matrices :

CV_<bit_depth>(S|U|F)C<number_of_channels>

S = Signed integer

U = Unsigned integer

F = Float

Exemple :

CV_8UC1 signifie une matrice dont les éléments sont des entiers non signés codés sur 8-bits

CV_32FC2 signifie une matrice possédant deux canaux (2 valeurs par position) dont les

éléments sont des nombres flottants codés sur 32-bit.

Header à inclure :

#include <cv.h>

#include <cvaux.h>

#include <highgui.h>

Compilation g++ source.cpp -o mon_programme `pkg-config --cflags opencv` `pkg-config -

-libs opencv`

Première exemple C++ :

////////////////////////////////////////////////////////////////////////

// inverse.cpp

//

// This is a simple, introductory OpenCV program. The program reads an

// image from a file, inverts it, and displays the result.

////////////////////////////////////////////////////////////////////////

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

#include <cv.h>

#include <highgui.h>

using namespace std;

using namespace cv;

int main(int argc, char *argv[])

{

// load an image

Mat img=imread("camera.png",0);

if(img.empty()){

printf("Could not load image file\n");

exit(0);

}

// get the image data

int height = img.rows;

int width = img.cols;

printf("Processing a %dx%d image\n",height,width);

// invert the image

for(int i=0;i<height;i++)

for(int j=0;j<width;j++)

img.at<uchar>(i,j)=255-img.at<uchar>(i,j);

// create a window

namedWindow("mainWin", CV_WINDOW_AUTOSIZE);

// show the image

imshow("mainWin", img );

// wait for a key

waitKey(0);

return 0;

}

Structures de données de base

Les points – Point_

Structure de données générique pour représenter des points dans espace de dimension 2.

template<typename _Tp> class Point_

{

public:

Point_();

Point_(_Tp _x, _Tp _y);

Point_(const Point_& pt);

...

_Tp x, y;

};

Pour les types courants : points à coordonnées entières, flottantes, simple ou double précision, on

dispose des alias suivants:

typedef Point_<int> Point2i;

typedef Point2i Point;

typedef Point_<float> Point2f;

typedef Point_<double> Point2d;

Exemple d'utilisation :

Point2f a(0.3f, 0.f), b(0.f, 0.4f);

Point pt = (a + b)*10.f;

cout << pt.x << ", " << pt.y << endl;

Dimension – Size_

Représente la taille d'un objet rectangulaire a 2 dimensions. Comme pour les points il s'agit d'une

structure générique.

template<typename _Tp> class Size_

{

public:

Size_();

Size_(_Tp _width, _Tp _height);

Size_(const Size_& sz);

_Tp area() const;

...

_Tp width, height;

};

Et on dispose des alias suivant :

typedef Size_<int> Size2i;

typedef Size2i Size;

typedef Size_<float> Size2f;

Rectangle – Rect_

Représente un rectangle. Un rectangle est la donnée d'un point (le coin supérieur gauche) et d'une

taille. C'est également une structure générique.

template<typename _Tp> class Rect_

{

public:

Rect_();

Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);

Rect_(const Rect_& r);

// (x, y) <- org, (width, height) <- sz

Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);

// (x, y) <- min(pt1, pt2), (width, height) <- max(pt1, pt2) - (x, y)

Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);

// returns Point_<_Tp>(x, y)

Point_<_Tp> tl() const;

// returns Point_<_Tp>(x+width, y+height)

Point_<_Tp> br() const;

// returns Size_<_Tp>(width, height)

Size_<_Tp> size() const;

// returns width*height

_Tp area() const;

// x <= pt.x && pt.x < x + width &&

// y <= pt.y && pt.y < y + height ? true : false

bool contains(const Point_<_Tp>& pt) const;

_Tp x, y, width, height;

};

Et on dispose de l'alias suivant :

typedef Rect_<int> Rect;

Vecteur - Vec

Représente un vecteur générique de faible dimension (<10). A ne pas confondre avec le type Vecteur

de la STL qui correspond à un tableau dynamique.

template<typename _Tp, int cn> class Vec

{

public:

// default constructor: all elements are set to 0

Vec();

// constructors taking up to 10 first elements as parameters

Vec(_Tp v0);

Vec(_Tp v0, _Tp v1);

...

Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9);

Vec(const Vec<_Tp, cn>& v);

// constructs vector with all the components set to alpha.

static Vec all(_Tp alpha);

...

//data

_Tp val[cn];

};

Et on dispose de l'alias suivant :

typedef Vec<uchar, 2> Vec2b;

typedef Vec<uchar, 3> Vec3b;

typedef Vec<uchar, 4> Vec4b;

typedef Vec<int, 2> Vec2i;

typedef Vec<int, 3> Vec3i;

typedef Vec<int, 4> Vec4i;

typedef Vec<float, 2> Vec2f;

typedef Vec<float, 3> Vec3f;

typedef Vec<float, 4> Vec4f;

typedef Vec<float, 6> Vec6f;

typedef Vec<double, 2> Vec2d;

typedef Vec<double, 3> Vec3d;

typedef Vec<double, 4> Vec4d;

typedef Vec<double, 6> Vec6d;

Image – Mat

C'est le type fondamental pour représenter toutes les sortes d'images. On peut noter que la

définition n'utilise pas la généricité. Les matrices disposent d'une gestion automatique de la

mémoire, il n'y a donc pas de free ou delete à ajouter manuellement.

class CV_EXPORTS Mat

{

public:

// ... a lot of methods ...

...

//! the array dimensionality, >= 2

int dims;

//! the number of rows and columns or (-1, -1) when the array has more than 2 dimensions

int rows, cols;

//! pointer to the data

uchar* data;

};

Utilisation de la classe Mat

Création d'une nouvelle image Lecture à partir d'un fichier :

Mat imread(const string& filename, int flags=1)

Paramètres :

filename – Name of file to be loaded.

flags – Specifies color type of the loaded image:

o >0 the loaded image is forced to be a 3-channel color image

o =0 the loaded image is forced to be grayscale

o <0 the loaded image will be loaded as-is.

Allocation par constructeur :

La classe Mat propose un nombre important de constructeur, viola ceux qui vous seront le plus utile :

Mat::Mat(int rows, int cols, int type)

Mat::Mat(Size size, int type)

Paramètres :

rows – Number of rows in a 2D array.

cols – Number of columns in a 2D array.

size – 2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the number of columns go in the reverse order.

type – Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices

Exemple : // allocate a matrix of 1024 rows by 768 columns with 32 bits floating precison and 3 channels

Mat im1(1024,768,CV_32FC3);

Size s(768,1024);

// allocate a matrix of 1024 rows by 768 columns with unsigned 8 bits integer precison and 1

channel

Mat im2(s,CV_8UC1);

Allocation par copie :

Il faut utiliser la méthode clone de la classe Mat

Exemple :

Mat m1 = imread("filename");

Mat m2 = m1.clone();

Accès aux pixels d'une image L'accès aux pixels d'une image sous OpenCV peut se faire de nombreuses façons différentes. Nous

nous concentrons ici sur les fonctions d'accès haut niveau qui sont plus agréables à manipuler que les

fonctions bas-niveau qui demandent à faire de l'arithmétique de pointeurs et donc de connaitre les

détails d'implémentation des structures de données.

Image en niveau de gris

Les images à niveau de gris ne possède qu'un canal ce qui facilite leur manipulation. Le type de

données stocké sera généralement des uchar (8 bit non signé) ou des float (32 bit)

La méthode générique at :

template<typename _Tp> _Tp& Mat::at(int i, int j)

template<typename _Tp> _Tp& Mat::at(Point pt)

Paramètres :

i – The row index (start at 0)

j – The column index (start at 0)

pt – The element position specified as Point(j,i)

Exemple :

Mat img(100, 100, CV_64FC1);

for(int i = 0; i < img.rows; i++)

for(int j = 0; j < img.cols; j++)

img.at<double>(i,j) = 1./(i+j+1);

Mat img2(100,100,CV_8UC1);

for(int i = 0; i < img2.rows; i++)

for(int j = 0; j < img2.cols; j++)

img.at<uchar>(i,j) = saturate_cast<uchar>(img.at<double>(i,j)*1000.0);

Remarque : saturate_cast<datatype> est une function qui convertit un argument numérique dans le

type numérique demandé mais réalise une saturation au lieu d'une troncature binaire lorsqu'un

débordement se produit.

ushort x = 257; // en binaire : 100000001b

uchar y = (uchar)x; // transtypage simple, on garde les 8 bits de droites : 00000001b = 1

uchar z = saturate_cast<uchar>(x); // transtypage avec saturation, on prend la plus grande

valeur représentable par uchar = 255

Image multibande – couleur

Première méthode avec at :

Approche similaire à la précédente mais cette fois at va nous donner un vecteur de dimension le

nombre de canaux dans l'image.

Exemple : on peut modifier le premier exemple qui inverse une image pour prendre en charge les

images couleurs en remplaçant les boucles par:

// invert the image

for(int i=0;i<height;i++)

for(int j=0;j<width;j++)

img.at<Vec3b>(i,j)=Vec3b(255,255,255)-img.at<Vec3b>(i,j);

On traite donc directement des triplets RGB représentés sous forme de Vec3b. On aurait également

pu écrire, sans utiliser les opérations vectorielles pré-définies:

// invert the image

for(int i=0;i<height;i++)

for(int j=0;j<width;j++)

{

Vec3b v = img.at<Vec3b>(i,j);

v[0] = 255 - v[0];

v[1] = 255 - v[1];

v[2] = 255 - v[2];

img.at<Vec3b>(i,j)=v;

}

Méthode par découpage en plan :

Cette approche consiste simplement à découper une image à n canaux en n image à 1 canal, traiter

chaque canal, puis les réassembler.

La séparation des canaux se fait grâce à fonction split, les canaux sont mis dans un vecteur (stl) de

Mat. La fonction merge assemble plusieurs images à 1 canal contenues dans un vecteur de Mat en

une unique image.

Exemple :

// split the image into separate color planes

vector<Mat> planes;

split(img, planes);

// invert the 3 planes

for(int c=0;c<planes.size();c++)

for(int i=0;i<height;i++)

for(int j=0;j<width;j++)

planes[c].at<uchar>(i,j)=255-planes[c].at<uchar>(i,j);

// now merge the results back

merge(planes, img);

Affichage et enregistrement des images

Affichage d'une image

L'affichage d'une image se realize en deux temps (+ un troisième optionnel):

1. Création d'une fenêtre nommée avec namedWindow

void namedWindow(const string& winname, int flags)

Paramètres :

name – Name of the window in the window caption that may be used as a window identifier.

flag – (QT-backend only) combined with a OR operation

o CV_WINDOW_NORMAL or CV_WINDOW_AUTOSIZE: CV_WINDOW_NORMAL let the user

resize the window, whereas CV_WINDOW_AUTOSIZE adjusts automatically the window’s size

and the user can not change the window size manually.

o CV_WINDOW_FREERATIO or CV_WINDOW_KEEPRATIO: CV_WINDOW_FREERATIO adjust the

image without respect the its ration, whereas CV_WINDOW_KEEPRATIO keep the image’s

ratio.

o CV_GUI_NORMAL or CV_GUI_EXPANDED: CV_GUI_NORMAL is the old way to draw the

window without statusbar and toolbar, whereas CV_GUI_EXPANDED is the new enhance GUI.

2. Affichage de l'image avec imshow

void imshow(const string& winname, const Mat& image)

Paramètres :

winname – Name of the window.

image – Image to be shown. o If the image is 8-bit unsigned, it is displayed as is.

o If the image is 16-bit unsigned or 32-bit integer, the pixels are divided by 256. That is, the

value range [0,255*256] is mapped to [0,255].

o If the image is 32-bit floating-point, the pixel values are multiplied by 255. That is, the

value range [0,1] is mapped to [0,255].

3. Un appel à waitKey pour éviter que le programme ne s'arrête immédiatement à fin de la fonction main.

Exemple :

// create a window

namedWindow("mainWin", CV_WINDOW_AUTOSIZE);

// show the image

imshow("mainWin", img );

// wait for a key

waitKey(0);

Enregistrement d'une image

L'enregistrement se fait avec imwrite

bool imwrite(const string& filename, const Mat& img, const vector<int>& params=vector<int>())

Paramètres :

filename – Name of the file, the extension determine the image format.

img – The image to be saved.

params (optional) – The format-specific save parameters, encoded as pairs paramId_1, paramValue_1,

paramId_2, paramValue_2, ... . The following parameters are currently supported:

o In the case of JPEG it can be a quality ( CV_IMWRITE_JPEG_QUALITY ), from 0 to 100 (the higher is

the better), 95 by default.

o In the case of PNG it can be the compression level ( CV_IMWRITE_PNG_COMPRESSION ), from 0 to

9 (the higher value means smaller size and longer compression time), 3 by default.

o In the case of PPM, PGM or PBM it can a binary format flag ( CV_IMWRITE_PXM_BINARY ), 0 or 1, 1

by default.