interface mathematica pour opencv - f-legrand.fr · interface mathematica pour opencv 7...

Interface Mathematica pour OpenCV

Frederic Legrand

2010

Table des matieres

I Fonctions de l’interface 3

1. Generalites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2. Fonctions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.a. Structures de donnees . . . . . . . . . . . . . . . . . . . . . . . 4

2.b. Operations sur les tableaux . . . . . . . . . . . . . . . . . . . . . 5

2.c. Structures dynamiques . . . . . . . . . . . . . . . . . . . . . . . 7

3. Traitement d’image et vision informatique . . . . . . . . . . . . . . . . . 8

3.a. Filtrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3.b. Traitements divers . . . . . . . . . . . . . . . . . . . . . . . . . 8

3.c. Histogrammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3.d. Detection d’elements . . . . . . . . . . . . . . . . . . . . . . . . 10

3.e. Analyse de structures et description de formes . . . . . . . . . . 11

4. Interface graphique et lecture-ecriture des fichiers . . . . . . . . . . . . . 12

4.a. Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . 12

4.b. Lecture-ecriture des images et video . . . . . . . . . . . . . . . . 14

II Lecture d’une image ou d’une video 15

1. Lecture d’une image . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2. Affichage d’une image . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3. Lecture d’une video . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4. Lecture d’une image d’une video . . . . . . . . . . . . . . . . . . . . . . 19

5. Deroulement d’une video . . . . . . . . . . . . . . . . . . . . . . . . . . 20

6. Fin de la session . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

III Reperage manuel de points 21

1. Releve de points sur une image . . . . . . . . . . . . . . . . . . . . . . . 22

2. Releve de rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3. Releve de points sur une video . . . . . . . . . . . . . . . . . . . . . . . 24

IV Niveaux de gris et couleurs 25

1. Niveaux de gris d’un image monochrome . . . . . . . . . . . . . . . . . . 26

1.a. Obtention d’une image monochrome . . . . . . . . . . . . . . . 26

1.b. Histogramme des niveaux de gris . . . . . . . . . . . . . . . . . . 26

1.c. Ajustement des niveaux de gris . . . . . . . . . . . . . . . . . . . 28

1.d. Seuillage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2. Images en couleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.a. Couches BGR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

1

Interface Mathematica pour OpenCV 2

2.b. Couches HSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2.c. Histogramme HS des couleurs . . . . . . . . . . . . . . . . . . . 32

V Extraction de contours 33

1. Obtention d’une image binaire . . . . . . . . . . . . . . . . . . . . . . . 34

2. Extraction des contours externes . . . . . . . . . . . . . . . . . . . . . . 34

3. Extraction de tous les contours . . . . . . . . . . . . . . . . . . . . . . . 36

3.a. Liste de contours . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.b. Structure a deux niveaux . . . . . . . . . . . . . . . . . . . . . . 36

3.c. Hierarchie complete . . . . . . . . . . . . . . . . . . . . . . . . . 38

4. Caracteristiques des contours . . . . . . . . . . . . . . . . . . . . . . . . 40

VI Filtrage par convolution et detection de bords 42

1. Filtrage par convolution . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

2. Application : operateurs de derivation . . . . . . . . . . . . . . . . . . . 44

2.a. Derivation simple . . . . . . . . . . . . . . . . . . . . . . . . . . 44

2.b. Laplacien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

2.c. Operateur de Sobel . . . . . . . . . . . . . . . . . . . . . . . . . 46

3. Detection de bords de Canny . . . . . . . . . . . . . . . . . . . . . . . . 47

4. Lissage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

VII Transformee de Hough et detection de lignes 49

1. Transformee de Hough standard . . . . . . . . . . . . . . . . . . . . . . 50

1.a. Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

1.b. Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

2. Methode de Hough probabiliste . . . . . . . . . . . . . . . . . . . . . . . 53

VIIIRetroprojection d’un histogramme 55

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

2. Retroprojection d’un histogramme HS . . . . . . . . . . . . . . . . . . . 56

Chapitre 1

Fonctions de l’interface

3


1. Generalites

Le module CV est charge par : Needs[”CV‘”]. L’ouverture de l’interface se fait avec

CVOpen[].

Les structures de donnees utilisees par OpenCV (IplImage, CvMat, CvCapture, etc)

sont manipulees dans le noyau Mathematica par leur reference. Celle-ci est un entier

superieur ou egal a 1. La reference 0 est aussi utilisee pour representer un argument nul

(equivalent de null en C).

Les donnees peuvent etre recuperees dans Mathematica par differentes fonctions.

L’interface doit etre fermee avec CVClose[]. Cette fonction libere la memoire associee

aux structures de donnees puis ferme la liaison MathLink.

Les fonctions se classent en quatre categories :

. Fonctions d’interface avec les fonctions d’OpenCV.

. Fonctions complementaires de traitement d’image.

. Fonctions d’interface graphique evoluee (implementees en Java).

. Fonctions d’echange de donnees avec Mathematica.

La syntaxe des fonctions d’interface est tres proche de celle des fonctions C de la bi-

bliotheque OpenCV. La principale difference reside dans la manipulation de references

(sous forme d’entiers) au lieu des pointeurs. Les structures de donnees simples, comme

les coordonnees de points, sont directement transmises sous forme de liste.

Les fonctions d’echange de donnees permettent de recuperer les gros volumes de

donnees associes aux images ou a d’autres structures comme les contours, afin de les

traiter directement dans Mathematica, par exemple pour obtenir des representations gra-

phiques.

2. Fonctions de base

2.a. Structures de donnees

Les images sont representees par deux structures de donnees differentes : IplImage et

CvMat. La plupart des fonctions agissent indiferemment sur l’une ou l’autre. On designe

par CvArr un argument qui peut etre soit IplImage, soit CvMat, soit CvSeq.

array=CVGetArray[arr,channel]

Obtenir la matrice des valeurs d’une couche d’une matrice ou d’une image.

. arr (Integer) : reference d’un CvArr (CvMat ou IplImage).

. channel (Integer) : couche a lire (de 1 a 4).

. array (Real List) : matrice des valeurs.

array=CVGetImageArray[img,norm,order]

Obtenir un tableau de valeurs correspondant a une image.


. img (Integer) : reference d’une image IplImage

. norm (Integer) : 1 pour obtenir des valeurs entre 0 et 1, 0 sinon

. order (Integer) : 1 pour laisser les couches dans l’ordre original, -1 pour inverser

l’ordre des couches

. array (Real Array) : matrice de n-uplets, ou n est le nombre de couches de

l’image.

CVReleaseImage[img]

Liberation de la memoire utilisee par une IplImage devenue inutile. Cette fonction

doit etre utilisee systematiquement dans les applications qui manipulent un grand nombre

d’images differentes (par exemple traitement d’une video).

. img (Integer) : reference d’une IplImage.

CVSetArray[arr,channel,array]

Affecter des valeurs a un CvArr (matrice CvMat ou image IplImage). La fonction

opere sur des matrices de dimension quelconque.


. channel (Integer) : couche a remplir (de 1 a 4).

. array (Real List) : matrice contenant les valeurs, sous forme de listes im-

briquees.

2.b. Operations sur les tableaux

CVConvertScale[src,dst,scale,shift]

Conversion de src vers dst avec modification des valeurs : dst=src*scale+shift. La

transformation s’applique aux images multicouches.

. src (Integer) : reference d’un CvArr. Image source.

. dst (Integer) : reference d’un CvArr. Image de destination.

. scale (Real) : facteur multiplicatif.

. shift (Real) : decalage.

ref=CVCreateImage[–width,height˝,depth,channels]

Creer une image IplImage.

. width (Integer) : largeur de l’image

. height (Integer) : hauteur de l’image


. depth (Integer) : profondeur des couches. Utiliser les constantes IplDepth8U,

IplDepth16U, etc.

. channels (Integer) : nombre de couches

. ref (Integer) : reference de la structure IplImage creee

mat=CVCreateMat[rows,cols,type,channels]

Creer une matrice CvMat. Les matrices servent a manipuler des parties d’image ou a

effectuer differents calculs.

. rows (Integer) : nombre de lignes.

. cols (Integer) : nombre de colonnes.

. type (Integer) : type de l’image. Utiliser les constantes CV8U, CV8S, CV16U,

CV16S, CV32S, CV32F ou CV64F.

. channels (Integer) : nombre de couches (entre 1 et 4).

. mat (Integer) : reference de la structure CvMat creee.

CVMinMaxLoc[arr]

Obtenir les valeurs mimimales et maximales, ainsi que leur position, d’un CvArr a une

couche et a deux dimensions.


. m (Real List) : valeurs min/max et positions sous la forme min,max,minX,minY,maxX,maxY

s=CVGetSize[img]

Obtenir la taille d’une image.

. img (Integer) : reference d’un CvArr.

. s (Integer List) : taille sous la forme largeur,hauteur.

CVResetImageROI[img]

Desactiver la region d’interet.

. img (Integer) : reference de IplImage.

CVSetImageROI[img,rect]

Definir une region d’interet (ROI) pour une image. La plupart des fonctions d’OpenCV

operent sur la region d’interet lorsque’elle est definie.

. img (Integer) : reference de IplImage.

. rect (Integer List) : rectangle sous la forme x,y,width,height.


CVSplit[src,dst0,dst1,dst2,dst3]

Recopier les couches d’une image dans des images monochromes.


. dst0, dst1, dst2, dst3 (Integer) : references de CvArr. Images de destina-

tion.

2.c. Structures dynamiques

mem=CVCreateMemStorage[blocksize]

Creer une zone de memoire pour les structures de donnees dynamiques.

. blocksize (Integer) : taille des blocs en octets. Si la valeur est 0, une taille par

defaut est adoptee.

. mem (Integer) : reference d’un CvMemStorage.

next=CVGetSeqHNext[seq]

Obtenir l’element suivant dispose horizontalement dans une structure de donnees.

Chaque element est une sequence.

. seq (Integer) : reference de CvSeq. Element d’une structure de donnees.

. next (Integer) : reference de CvSeq. Element suivant.

prev=CVGetSeqHPrev[seq]

Obtenir l’element precedent dispose horizontalement dans une structure de donnees.



. prev (Integer) : reference de CvSeq. Element precedent.

next=CVGetSeqVNext[seq]

Obtenir l’element suivant dispose verticalement dans une structure de donnees. Chaque

element est une sequence.


. next (Integer) : reference de CvSeq. Element suivant.


prev=CVGetSeqVPrev[seq]

Obtenir l’element precedent dispose verticalement dans une structure de donnees.



. prev (Integer) : reference de CvSeq. Element precedent.

3. Traitement d’image et vision informatique

3.a. Filtrage

CVFilter2D[src,dst,kernel]

Filtrer une image par un noyau de convolution. Celui-ci doit etre une matrice de taille

impaire, par exemple 3x3.



. kernel (Integer) : reference d’une CvMat. Noyau de convolution.

CVLaplace[src,dst,apertureSize]

Calculer le Laplacien d’une image a une couche.



. apertureSize (Integer) : taille du noyau de convolution (1,3,5 ou 7).

CVSobel[src,dst,xorder,yorder,apertureSize]

Calculer une derivee d’une image a une couche par l’operateur de Sobel.



. xorder (Integer) : ordre de la derivee selon x.

. yorder (Integer) : ordre de la derivee selon y.


3.b. Traitements divers


CVCvtColor[src,dst,convert]

Conversion entre deux espaces colorimetriques.



. : code de conversion. Utiliser les constantes CVBGR2HSV, CVHSV2BGR, etc.

3.c. Histogrammes

CVCalcBackProject[img,back,hist]

Retroprojection d’un histogramme sur une image.

. img (Integer List) : liste de references de IplImage, autant que l’histogramme

comporte de dimensions.

. back (Integer) : reference d’un CvArr. Destination de la retroprojection.

. hist (Integer) : reference d’un CVHistogram

hist=CVCreateHist[dims,type,ranges,uniform]

Creation d’un histogramme a n dimensions.

. dims (Integer List) : liste des dimensions.

. type (Integer) : type d’histogramme (CVHistArray, CVHistSparse ou CVHistU-

niform).

. uniform (Integer) : 0 ou 1.

. hist (Integer) : reference de la structure CVHistogram creee.

CVCalcHist[img,hist,accumulate,mask]

Calcul d’histogrammes.

. img (Integer List) : liste de references de IplImage, autant que l’histogramme

comporte de dimensions.

. hist (Integer) : reference d’un CVHistogram

. accumulate (Integer) : 0 ou 1. Si egal a 1, l’histogramme n’est pas efface, ce

qui permet d’accumuler les histogrammes de plusieurs images.

. mask (Integer) : reference d’un CvArr ou 0. Masque indiquant les pixels a prendre

en compte.


CVConvertHistScale[hist,scale,shift]

Transformation des valeurs d’un histogramme : newhist=hist*scale+shift.

. hist (Integer) : reference de l’histogramme (CvHistogram).

. scale (Real) : facteur multiplicatif.

. shift (Real) : decalage.

img=CVGetHueSatHistImage[hist,pixels]

Obtenir une representation graphique sous forme d’image d’un histogramme 2D Hue-

Sat.

. hist (Integer) : reference de l’histogramme (CvHistogram).

. pixels (Integer) : taille en pixels de chaque case de l’histogramme.

. img (Integer) : reference de l’image IplImage creee.

3.d. Detection d’elements

CVCanny[image,edges,threshold1,threshold2,apertureSize]

Detecter les bords par la methode de Canny.

. image (Integer) : reference d’un CvArr. Image source a une couche.

. edges (Integer) : reference d’un CvArr. Image de destination : image binaire

comportant les bords.

. threshold1 (Real) : seuil bas.

. threshold2 (Real) : seuil haut.


seq=CVHoughLines2[image,storage,method,rho,theta,threshold,param1,param2]

Detection de points alignes dans une image binaire, par la transformee de Hough.

. image (Integer) : reference d’un CvArr. Image source a une couche.

. storage (Integer) : reference du CvMemory utilise pour stocker les lignes obte-

nues.

. method (Integer) : les methodes possibles sont CVHoughStandard, CVHougPro-

babilistic, CVHoughMultiScale.

. rho (Real) : resolution en unite de pixels.

. theta (Real) : resolution en radians.


. threshold (Integer) : seuil definissant la valeur minimale dans le plan accumu-

lateur pour qu’une ligne soit retenue.

. param1 (Real) : dans la methode CVHougProbabilistic : longueur de segment

minimale. Dans la methode CVHoughMultiScale : diviseur de la resolution en ρ.

. param2 (Real) : dans la methode CVHougProbabilistic : distance maximale entre

deux segments alignes pour qu’ils soient consideres comme un seul segment. Dans

la methode CVHoughMultiScale : diviseur de la resolution en θ.

. seq (Integer) : reference d’une CvSeq. Sequence comportant les lignes detectees.

lines=CVGetHoughLines[seq,method]

Obtenir les droites detectees par CVHoughLines2 sous forme d’une liste de doublets.

. seq (Integer) : reference d’une CvSeq. Sequence comportant les lignes detectees,

renvoyee par CVHoughLines2.

. method (Integer) : methode utilisee dans CVHoughLines2.

. lines (Array) : pour la methode CVHoughStandard : liste de doublets (ρ, θ).

3.e. Analyse de structures et description de formes

seq=CVFindContours[img,mem,mode,method,offset]

Obtenir les contours presents dans une image. Celle-ci est interpretee comme une

image binaire : les valeurs 0 restent 0, les valeurs non nuls sont interpretees comme 1. Les

contours des zones connexes formees de 1 sont recherches. La fonction renvoit le premier

contour. Pour acceder aux autres contours, utiliser CVGetSeqHNext et CVGetSeqVNext.

. img (Integer) : reference de l’image source (CvArr, 8 bits, une couche).

. mem (Integer) : reference du CvMemory utilise pour stocker les donnees.

. mode (Integer) : CvRetrExternal : contours externes seulement. CVRetrList :

tous les contours sous forme d’une liste chaınee. CVRetrCcomp : tous les contours

sous forme d’une structure a deux niveaux. CvRetrTree : tous les contours sous

forme d’un arbre.

. method (Integer) : methode d’approximation. CVChainCode, CVChainApprox-

None, CVChainApproxSimple, CVChainApproxTC89L1, CVChainApproxTC89KCOS,

CVLinkRuns.

. offset (Integer List) : coordonnees x,y du decalage a appliquer a chaque points

du contour.

. seq (Integer) : premier contour (reference d’une CvSeq).

c=CVGetContour[seq]

Obtenir la liste des points d’un contour.


. seq (Integer) : reference de la sequence (CvSeq) contenant le contour.

. c (Real List) : liste de points.

p=CVContourPerimeter[seq]

Obtenir le contour d’un perimetre.

. seq (Integer) : reference de la sequence (CvSeq) contenant le contour.

. p (Real) : perimetre du contour.

4. Interface graphique et lecture-ecriture des fichiers

4.a. Interface graphique

edit=CVJImageEditor[name,modal]

Creation d’une fenetre pour editer des images (releve de points, de zones, etc). Si la

fenetre est modale, le fil d’execution reprend lorsque la fenetre est fermee par l’utilisateur.

. name (String) : nom de la fenetre.

. modal (Boolean) : fenetre modale ou pas.

. edit (Java class ShowImage) : reference de l’editeur.

CVJShowImage[edit,img]

Afficher une image dans un editeur d’image de la classe ShowImage.


. img (Integer) : reference d’une IplImage.

CVJShowVideoFrames[edit,capture,skip]

Afficher une video image par image dans un editeur d’image. La fleche verte permet

a l’utilisateur de passer a l’image suivante.


. capture (Integer) : reference d’une CvCapture.

. skip (Integer) : nombre d’images du flux video a sauter entre deux images

consecutives affichees.


list=CVJGetPixelPointList[edit]

Obtenir les coordonnees des points selectionnes par l’utilisateur dans l’editeur d’image,

en unite de pixel. Ces coordonnees sont de type flottant (Real) car la selection d’un point

peut se faire entre deux pixels sur une image grossie. Convertir en Integer avec Floor si

necessaire.


. list (Real List) : liste de doublets, coordonnees des points selectionnes.

list=CVJGetUserPointList[edit]

Obtenir les coordonnees des points selectionnes par l’utilisateur dans l’editeur d’image,

dans le repere defini par l’ulisateur.


. list (Real List) : liste de doublets, coordonnees des points selectionnes.

list=CVJGetPixelRectangleList[edit]

Obtenir les rectangles saisis par l’utilisateur dans un editeur d’image, en unite de pixel.


. list (Real List) : liste de 4-uplets de la forme x,y,width,height specifiant les

rectangles selectionnes.

list=CVJGetUserRectangleList[edit]

Obtenir les rectangles saisis par l’utilisateur dans un editeur d’image, dans le repere

defini par l’utilisateur. Le rectangle a ses cotes paralleles a ceux de l’image, et non aux

axes du repere.


. list (Real List) : liste de 4-uplets de la forme x,y,width,height specifiant les

rectangles selectionnes.


4.b. Lecture-ecriture des images et video

img=CVLoadImage[filename,iscolor]

Lecture d’une image a partir d’un fichier. Les formats possibles sont JPG, PNG, BMP,

TIF, PPM, SR. Le fichier est recherche dans le repertoire courant, lequel peut etre modifie

avec la fonction SetDirectory. Le chemin d’acces complet peut aussi etre specifie.

. filename (String) : nom du fichier ou chemin d’acces complet.

. iscolor (Integer) : une des constantes CVLoadImageUnchanged, CVLoadIma-

geGrayScale, CVLoadImageColor.

. img (Integer) : reference d’une IplImage. Si la lecture a echouee, la valeur 0 est

renvoyee.

capture=CVCaptureFromFile[filename]

Lecture d’une video a partir d’un fichier.

. filename (String) : nom du fichier ou chemin d’acces complet.

. capture (Integer) : reference d’une CvCapture. Si la lecture a echouee, la valeur

0 est renvoyee.

img=CVGetFrame[capture,skip]

Lecture d’une image dans une video. L’image obtenue est une copie. En cas de lecture

sequentielle de toute la video, ne pas oublier de liberer la memoire occupee par l’image

avec CVReleaseImage.

. capture (Integer) : reference d’une CvCapture.

. skip (Integer) : nombre d’images a sauter a partir de la position courante.

. img (Integer) : reference d’une IplImage, copie de l’image. Si la fin du flux video

est atteinte, la valeur 0 est renvoyee.

Chapitre 2

Lecture d’une image ou d’une video

15


1. Lecture d’une image

On commence par charger le module puis on ouvre l’interface :

Needs[’CV‘’];

CVOpen[];

Pour lire une image contenue dans un fichier (JPG, PNG) :

img=CVLoadImage[’baboon.jpg’,CVLoadImageUnchanged];

Le fichier est cherche dans le repertoire courant, qu’il faut definir au prealable avec

SetDirectory. On peut aussi indiquer le chemin complet d’acces au fichier. La fonction

renvoit une reference (un entier) a une structure IplImage. Le deuxieme argument peut

ausi prendre la valeur CVLoadImageGrayScale. Dans le cas present, l’image lue comporte

3 couches de 8 bits chacune. Ces couches sont B (Blue) G (Green) et R (Red).

Pour obtenir la taille de l’image :

s=CVGetSize[img]

–300, 300˝

2. Affichage d’une image

Il existe trois moyens d’afficher une image. Le premier consiste a utiliser l’interface

graphique de OpenCV. Une fenetre portant un nom doit etre creee puis l’image lui est

fournie :

CVNamedWindow[’baboin’,CVWindowAutosize];

CVShowImage[’baboin’,img];

On remarquera que cette fonction est prevue pour afficher correctement une image

dont les couches sont dans l’ordre B, G et R. Avec des images RGB, SHV et autres

l’affichage sera incorrect.

La deuxieme methode consiste a convertir l’image en un objet Image. Pour cela, il

faut obtenir un tableau des valeurs de l’image :

array = CVGetImageArray[img,1,-1];

Le deuxieme argument indique que les valeurs doivent etre normalisees entre 0 et 1.

Le troisieme argument indique que l’ordre des couches doit etre inverse, afin d’obtenir

des triplets dans l’ordre RGB.

Image[array]


La fonction CVGetImageArray renvoit trois matrices correspondant aux couches R,

G et B. Si l’image BGR initiale est utilisee, ces matrices ne sont pas dans le bon ordre

pour etre affichees correctement. L’objet Image ainsi obtenu peut etre utilise avec les

fonctions de traitement d’image de Mathematica.

La troisieme possibilite consiste a utiliser l’interface java. Pour cela, on commence par

creer un editeur d’image :

edit=CVJImageEditor[’baboin’,True];

Le deuxieme argument indique si la fenetre doit etre modale ou pas. Si elle est modale,

l’execution reste en attente de la fermeture de la fenetre : il est impossible de continuer

a travailler sur le notebook tant que la fenetre est ouverte. Dans le cas contraire, le fil

d’execution est rendu au noyau de Mathematica des que la fenetre est ouverte. Si la

fenetre est modale, elle reste invisible tant qu’aucune image ne lui a ete fournie.

On fournit ensuite l’image a afficher :

CVJShowImage[edit,img];


Outre la possibilite de zoomer sur l’image, cet editeur permet de definir un repere, de

saisir des points et des rectangles.

3. Lecture d’une video

La lecture d’une video a partir d’un fichier se fait de la maniere suivante :

video=CVCaptureFromFile[’chocBilles.wmv’];

Differentes informations sur la video sont accessibles. La plus importante en pratique

est la taille des images :

width=CVGetCaptureProperty[video,CVCapPropFrameWidth]

height=CVGetCaptureProperty[video,CVCapPropFrameHeight]


640

480

Le taux d’image (frame rate) et le nombre d’image sont en principe accessibles :

fps=CVGetCaptureProperty[video,CVCapPropFps]

count=CVGetCaptureProperty[video,CVCapPropFrameCount]

47.583333333333336

2472

Dans le cas present, cette derniere imformation est fausse. La video dure environ 3

secondes, ce qui fait au maximum 150 images pour le taux indique. Ce taux lui-meme est

douteux puisque cette video a ete prise avec une webcam fonctionnant au maximum a

30 fps.

4. Lecture d’une image d’une video

La fonction suivante permet d’obtenir une copie d’une image d’une video. Le premier

argument est la reference a la video, le second le nombre d’images a sauter. Par exemple,

pour obtenir la 5 ieme et la 10 ieme image en partant du debut :

img5=CVGetFrame[video,5];

img10=CVGetFrame[video,5];

Lorsque la fin de la video est atteinte avant l’image demandee, la fonction CVGetFrame

renvoit une valeur nulle.

Lorsque ces images ne sont plus utilisees, il est bon de liberer la memoire correspon-

dante par :

CVReleaseImage[img5];

CVReleaseImage[img10];

A noter que pour relire la video depuis le debut, il faut la recharger a nouveau, non

sans avoir au prealable desaloue l’espace memoire correspondant :

CVReleaseCapture[video];



5. Deroulement d’une video

La premiere possibilite pour obtenir le deroulement dans le temps d’une video (image

par image) est d’utiliser la fonction CVPlayVideo, qui utilise l’interface graphique d’OpenCV :

CVNamedWindow[’billes’,CVWindowAutosize];

CVPlayVideo[’billes’,video,400];

Le dernier argument est le delai entre l’affichage de deux images consecutives, en

millisecondes.

La fonction precedente est utile pour avoir un apercu de la video. Pour obtenir un

deroulement image par image, on utilisera l’editeur d’image introduit plus haut en lui

fournissant la reference de la video :

CVReleaseCapture[video];


edit=CVJImageEditor[’billes’,True];

CVJShowVideoFrames[edit,video,1];

Cette fois-ci, l’affichage est statique. Le dernier argument est le nombre d’images a

sauter a chaque fois que l’utilisateur appuie sur la fleche verte.

6. Fin de la session

Pour finir, la fonction suivante libere toutes les ressources memoire utilisees et ferme

l’interface :

CVClose[];

Chapitre 3

Reperage manuel de points

21


1. Releve de points sur une image

On commence par lire une image :

Needs[’CV‘’];

CVOpen[];

img=CVLoadImage[’../hough/pic5.png’,CVLoadImageUnchanged];

s=CVGetSize[img];

puis on creee un editeur d’image et on lui fournit l’image :

edit=CVJImageEditor[’image’,True];


Dans le cas present, le deuxieme argument de CVJImageEditor indique que la fenetre

est modale : le retour au programme mathematica (ou au notebook) se fait lorsque la

fenetre est fermee par l’utilisateur. Dans le cas de l’utilisation d’un notebook, il est possible

d’ouvrir une fenetre non modale a condition de placer les deux instructions precedentes

dans un bloc d’execution separee de la suite.

Les points sont selectionnes et places dans une liste cliquant avec la souris sur l’image.

Deux types de coordonnees sont memorises :

. Les coordonnees en unite de pixels, avec l’origine en haut et a gauche de l’image.

. Les coordonnees dans un repere defini par l’utilisateur.

L’utilisateur definit son repere en pointant l’origine puis le point de coordonnees (0,a), ou

a est une unite arbitraire. Il est egalement possible de definir le point (a,0), ce qui revient

a definir l’axe Y. Dans tous les cas, le repere defini est direct (contrairement au repere

en unite de pixels).

Dans le cas present, les points (0,0) et (1,0) ont ete definis en bas de l’image (cercles

rouge et bleu) et trois points ont etes selectionnes (sommets du triangle) :


La liste des points en unite de pixels est obtenue par :

liste1=CVJGetPixelPointList[edit]

––122., 58.˝, –212., 149.˝, –83., 118.˝˝

Dans le cas d’une fenetre non modale, il est possible d’ajouter des points puis d’executer

a nouveau CVJGetPixelPointList. La liste des coordonnees dans le repere de l’utilisa-

teur est obtenue par :

liste2=CVJGetUserPointList[edit]

––0.28333333134651184, 0.6527777910232544˝, –0.5333333611488342, 0.4000000059604645˝, –0.17499999701976776, 0.4861111044883728˝˝

ListPlot[liste2,PlotRange-¿––0,1˝,–0,1˝˝,AspectRatio-¿1]

0.0 0.2 0.4 0.6 0.8 1.00.0

0.2

0.4

0.6

0.8

1.0

2. Releve de rectangles

L’editeur d’image permet aussi de definir des zones rectangulaires, dont les cotes sont

paralleles a ceux de l’image. Dans l’exemple ci-dessous, un rectangle est choisi dans la

zone verte, l’autre dans la zone blanche :


liste3 = CVJGetPixelRectangleList[edit]

––118., 92., 25., 24.˝, –65., 70., 22., 23.˝˝


Pour chaque rectangle de la liste, le 4-uplet est constitue des coordonnees du coin

superieur gauche suivies de la taille du rectangle (largeur et hauteur). La principale uti-

lisation de cette fonction est la selection de zones pour le traitement d’image (en unite

de pixels). Il est toutefois possible de recuperer les rectangles en coordonnees utilisateur

avec CVJGetUserRectangleList.

3. Releve de points sur une video

Le releve de points sur une video se fait comme sur une image fixe. On ouvre un

editeur d’image puis on lui fournit la video a lire :

video=CVCaptureFromFile[”toupie.mpg”];

edit2=CVJImageEditor[”toupie”,True];

CVJShowVideoFrames[edit2,video,10];

Les images sont affichees une par une. Lorsque l’utilisateur appuie sur la fleche verte,

un saut de n images est effectue (ici n=10). Dans l’exemple ci-dessous, la position du

centre de la toupie a ete selectionnee toute les 10 images (60 images par sec) de maniere

a reconstituer sa trajectoire :

La liste des points est recuperee comme precedemment.

CVClose[];

Chapitre 4

Niveaux de gris et couleurs

25


1. Niveaux de gris d’un image monochrome

1.a. Obtention d’une image monochrome

Needs[’CV‘’];

CVOpen[];

Lorsqu’on ne souhaite pas exploiter les informations de couleur d’une image, on peut

la lire directement sous forme d’une image monochrome :

img=CVLoadImage[’airplane.jpg’,CVLoadImageGrayScale];

L’image obtenue comporte 1 couche de 8 bits. Les valeurs des niveaux de gris sont

donc comprises entre 0 et 255.

Affichons l’image dans le notebook :

array = CVGetImageArray[img,1,1];

Image[array]

1.b. Histogramme des niveaux de gris

L’histogramme des niveaux de gris represente le nombre de pixels ayant une valeur

donnee en fonction de cette valeur. Il faut tout d’abord creer l’histogramme :

hist=CVCreateHist[–256˝,CVHistArray,––0,255˝˝,1];

Le premier argument est une liste donnant le nombre de valeurs dans chaque dimen-

sions (ici il n’y a qu’une seule dimension). Le troisieme argument precise les bornes des

valeurs. Pour calculer l’histogramme :

CVCalcHist[–img˝,hist,0,0];


On remarque que l’image doit etre transmise dans une liste a un seul element (histo-

gramme 1D).

Les valeurs de l’histogramme peuvent etre recuperees sous forme d’une liste :

h=CVGetHistArray[hist];

Voyons par exemple l’element 100 de cette liste :

h[[100]]

485.

Il y a donc 485 pixels qui ont la 100 ieme valeur de l’intervalle 0,255, c’est-a-dire la

valeur 101.

La representation graphique est obtenue par :

ListPlot[h,PlotRange-¿––0,255˝,–0,5000˝˝]

0 50 100 150 200 2500

1000

2000

3000

4000

5000

La valeur minimale et la valeur maximale de l’histogramme sont obtenues par :

minmax=CVGetMinMaxHistValue[hist]


––0., 0.˝, –4839., 157.˝˝

Le premier doublet donne la valeur minimale (0 pixels) et le niveau correspondant (0,

le plus faible). Le second doublet indique la valeur maximale (4839 pixels) et le niveau

correspondant (157). Les pixels les plus nombreux sont donc ceux de valeur 157, qui

correspondent au maximum visible sur la courbe.

Il est possible de normaliser l’histogramme de telle sorte que la somme de ses valeurs

soit egale a une valeur choisie. Par exemple, pour que la somme soit egale a 1.0 :

CVNormaliszeHist[hist,1.0];

1.c. Ajustement des niveaux de gris

L’ajustement des niveaux de gris permet de modifier la luminosite et/ou le contraste

d’une image monochrome. L’image precedente souffre d’un important defaut de contraste.

Comme on le constate sur l’histogramme, la valeur la plus elevee des pixels est 170 alors

qu’il s’agit du fond neigeux qui devrait etre proche de 255. De meme, la valeur minimale

devrait etre proche de 0 et non pas 50.

Pour modifier cette image, on commence par creer une nouvelle image monochrome

de la meme taille :

s=CVGetSize[img];

img2=CVCreateImage[s,IplDepth8U,1];

Pour etendre les valeurs de l’image sur toute la gamme possible (0 a 255), il faut

multiplier ces valeurs par 255/(170-50) puis retranche 50*255/(170-50). Ceci est obtenu

par la fonction suivante :

CVConvertScale[img,img2,255.0/(170-50),-50.0*255.0/(170-50)];

Voyons le nouvel histogramme :

CVCalcHist[–img2˝,hist,0,0];

h=CVGetHistArray[hist];

ListPlot[h,PlotRange-¿––0,255˝,–0,5000˝˝]


0 50 100 150 200 2500

1000

2000

3000

4000

5000

Image[CVGetImageArray[img2,1,1]]

1.d. Seuillage

Le seuillage permet d’obtenir une image binaire. Si par exemple nous voulons isoler

les parties noires de l’avion :



CVThreshold[img2,img3,50.0,255.0,CVThreshBinary];


2. Images en couleur

2.a. Couches BGR

On commence par lire une image en couleur :

img4=CVLoadImage[’baboon.jpg’,CVLoadImageUnchanged];

L’image comporte 3 couches (Blue Green Red) de 8 bits chacune. Pour obtenir une

image Mathematica, il faut obtenir un tableaux de valeurs normalisees et dont l’ordre des

couches est inverse (Red Green Blue) :

array=CVGetImageArray[img4,1,-1];

Image[array]


La majorite des operations de traitement d’image se font sur des couches individuelles.

Pour obtenir les couches B, G et R il faut tout d’abord creer trois images monochromes

de meme taille que l’image BGR :

s=CVGetSize[img4];

blue=CVCreateImage[s,IplDepth8U,1];

green=CVCreateImage[s,IplDepth8U,1];

red=CVCreateImage[s,IplDepth8U,1];

L’image BGR est scindee en trois couches :

CVSplit[img4,blue,green,red,0]

Voyons par exemple la couche rouge :

Image[CVGetImageArray[red,1,1]]

2.b. Couches HSV

Les informations de couleurs sont beaucoup plus facilement extraites si l’image est

convertie en couches HSV (Hue Saturation Value) :

CVCvtColor[img4,img4,CVBGR2HSV]

La couche H (Hue) contient l’information de couleur, la couche S (Saturation) contient

l’information de saturation des couleurs et la couche V (Value) l’information de luminance.

La separation en couches s’effectue comme precedemment :

hue=CVCreateImage[s,IplDepth8U,1];

sat=CVCreateImage[s,IplDepth8U,1];

val=CVCreateImage[s,IplDepth8U,1];

CVSplit[img4,hue,sat,val,0]

Les valeurs de Hue sont comprises entre 0 et 180 alors que les valeurs de Sat et Val

sont comprises entre 0 et 255.


2.c. Histogramme HS des couleurs

Un histogramme 2D Hue-Sat represente le nombre de pixel en fonction de (H,S). On

doit tout d’abord creer l’histogramme 2D :

histHS=CVCreateHist[–20,20˝,CVHistArray,––0,180˝,–0,255˝˝,1];

puis le calculer a partir des couches H et S :

CVCalcHist[–hue,sat˝,histHS,0,0]

Voyons les valeurs minimales et maximales :

minmax=CVGetMinMaxHistValue[histHS]

––0., 3., 17.˝, –2021., 11., 7.˝˝

Une representation graphique de l’histogramme peut etre obtenue de la maniere sui-

vante, sous forme d’une image BGR :

histImg=CVGetHueSatHistImage[histHS,10];

Image[CVGetImageArray[histImg,1,-1]]

La valeur de Hue est en abscisse (ici il y a 20 valeurs reparties uniformement entre

0 et 180), la valeur de Sat en ordonnee (origine en bas a gauche). L’intensite du carre

est proportionnelle au nombre de pixels. Ici, le maximum de pixels est obtenu pour une

couleur bleue (H=11/20*180,S=7/20*256)

CVClose[]

Chapitre 5

Extraction de contours

33


1. Obtention d’une image binaire

L’extraction de contours opere sur une image binaire, c’est-a-dire constituee de 0 et

de 1. Les zones connexes formees de 1 possedent un ou plusieurs contours.

On commence par lire une image en niveaux de gris :

Needs[’CV‘’];

CVOpen[];

img=CVLoadImage[’formes1.png’,CVLoadImageGrayScale];

s=CVGetSize[img];

Si l’on souhaite traiter les informations de couleurs, par exemple isoler des formes

d’une certaine couleur, il faut le faire avant l’extraction de contours.

L’image binaire est obtenue en effectuant un seuillage :

bin=CVCreateImage[s,IplDepth8U,1];

CVThreshold[img,bin,200.0,255.0,CVThreshBinaryInv];

Image[CVGetImageArray[bin,1,1]]

2. Extraction des contours externes

Il faut tout d’abord creer un espace memoire qui sera utilise pour stocker les contours :

mem = CVCreateMemStorage[0];

Les contours externes sont obtenus par

cont1=CVFindContours[bin,mem,CVRetrExternal,CVChainApproxNone,–0,0˝];


Les contours sont fournis sous forme d’une liste chaınee. La liste des points du premier

contour est obtenue par :

c1=CVGetContour[cont1];

Le perimetre d’un contour est obtenu par :

p=CVContourPerimeter[cont1]

266.

le contour suivant est obtenu par :

cont2=CVGetSeqHNext[cont1];

c2=CVGetContour[cont2];

Lorsque le dernier contour de la liste chaınee est atteint, la fonction CVGetSeqHNext

renvoit 0. La liste des contours est obtenue de la maniere suivante :

liste=–˝;

cont=cont1;

While[cont!=0,

c=CVGetContour[cont];

c=CVFlipY[s,c];

liste=Append[liste,c];

cont = CVGetSeqHNext[cont];

];

Les contours ont ete modifies avec la fonction CVFlipY de maniere a se superposer a

l’image originale (origine en haut a gauche).

ListPlot[liste,PlotRange-¿––0,s[[1]]˝,–0,s[[2]]˝˝,AspectRatio-¿1]

0 50 100 150 200 250 3000

50

100

150

200

250

300


3. Extraction de tous les contours

3.a. Liste de contours

Les contours peuvent etre obtenus sous forme d’une liste chaınee :

cont=CVFindContours[bin,mem,CVRetrList,CVChainApproxNone,–0,0˝];

liste=–˝

While[cont!=0,

c=CVFlipY[s,CVGetContour[cont]];

liste=Append[liste,c];

cont = CVGetSeqHNext[cont];

];

ListPlot[liste,PlotRange-¿––0,s[[1]]˝,–0,s[[2]]˝˝,AspectRatio-¿1]

0 50 100 150 200 250 3000

50

100

150

200

250

300

L’inconvenient de cette methode est l’absence d’information sur le caractere interne

ou externe de chaque contour.

3.b. Structure a deux niveaux

Une structure a deux niveaux est obtenue par :

cont=CVFindContours[bin,mem,CVRetrCcomp,CVChainApproxNone,–0,0˝];

Le premier niveau contient les contours externes. Ce niveau est balaye de maniere

horizontal, au moyen de la fonction CVGetSeqHNext.

Considerons par exemple le premier contour :


ListPlot[c,PlotRange-¿––0,s[[1]]˝,–0,s[[2]]˝˝,AspectRatio-¿1]


0 50 100 150 200 250 3000

50

100

150

200

250

300

Il s’agit du contour d’une zone connexe (blanche) qui n’avait pas ete detecte avec

l’option CVRetrExternal.

Voyons le 2ieme contour :

cont=CVGetSeqHNext[cont];



0 50 100 150 200 250 3000

50

100

150

200

250

300

Il s’agit du contour externe d’une zone connexe qui contient un trou noir (lequel

contient la zone precedente). Le contour interne (le bord du trou) est obtenu en explorant

le deuxieme niveau. Celui-ci est accessible par un deplacement vertical :

vnext=CVGetSeqVNext[cont]

c=CVFlipY[s,CVGetContour[vnext]];



0 50 100 150 200 250 3000

50

100

150

200

250

300

Si la zone connexe contient plusieurs trous, ceux sont accessibles par un deplacement

horizontal sur le deuxieme niveau.

3.c. Hierarchie complete

Dans certains cas, l’emboıtement des contours est plus complexe. Considerons l’image

suivante :

img=CVLoadImage[’formes2.png’,CVLoadImageGrayScale];

s=CVGetSize[img];

bin=CVCreateImage[s,IplDepth8U,1];

CVThreshold[img,bin,100.0,255.0,CVThreshBinary];

Image[CVGetImageArray[bin,1,1]]

La hierarchie complete des contours peut etre obtenue sous forme d’un arbre par :

cont1=CVFindContours[bin,mem,CVRetrTree,CVChainApproxNone,–0,0˝];


Considerons tout d’abord la racine de l’arbre et son noeud descendant direct, obtenu

par deplacement vertical dans la sequence :

c1=CVFlipY[s,CVGetContour[cont1]];

cont2=CVGetSeqVNext[cont1];


ListPlot[–c1,c2˝,PlotRange-¿––0,s[[1]]˝,–0,s[[2]]˝˝,AspectRatio-¿1]

0 50 100 150 200 250 3000

50

100

150

200

250

300

Le niveau suivant de l’arbre contient les contours des deux formes incluses dans la

precedente :









ListPlot[–c3,c4,c5,c6˝,PlotRange-¿––0,s[[1]]˝,–0,s[[2]]˝˝,AspectRatio-¿1]


0 50 100 150 200 250 3000

50

100

150

200

250

300

En explorant l’arbre verticalement a partir de cont4, on obtient les contours des deux

petits carres :









ListPlot[–c7,c8,c9,c10˝,PlotRange-¿––0,s[[1]]˝,–0,s[[2]]˝˝,AspectRatio-¿1]

0 50 100 150 200 250 3000

50

100

150

200

250

300

4. Caracteristiques des contours

La fonction suivante permet d’obtenir le rectangle d’aire minimale contenant le contour.

On l’applique ici a un des contours obtenus plus haut :


rect=CVMinAreaRect2[cont7]

–118.4705810546875, 160.61764526367188, 30.80202293395996, 31.044557571411133,

75.96376037597656˝

Les elements de la liste obtenue sont : les coordonnees du centre du rectangle, sa

largeur et sa hauteur, l’orientation (en degres) par rapport a l’axe Y.

La fonction suivante permet d’obtenir l’ellipse qui s’ajuste le mieux aux points du

contour :

ellipse=CVFitEllipse2[cont1];

–153.67434692382812, 144.31842041015625, 224.0941925048828, 249.94686889648438,

80.38348388671875˝

CVClose[];

Chapitre 6

Filtrage par convolution et detection debords

42


1. Filtrage par convolution

Needs[’CV‘’];

CVOpen[];

Lecture d’une image en niveaux de gris :

img=CVLoadImage[’CIMG3181.jpg’,CVLoadImageGrayScale];

s=CVGetSize[img];

Image[CVGetImageArray[img,1,1]]

Le noyau de convolution est une matrice carree de taille impaire. On choisit ici une

matrice 3x3, composee de flottants 32 bits et d’une seule couche :

noyau=CVCreateMat[3,3,CV32F,1];

La matrice est remplie (l’indice 1 indique la premiere couche) :

CVSetArray[noyau,1,N[––1/9,1/9,1/9˝,–1/9,1/9,1/9˝,–1/9,1/9,1/9˝˝]]

Remarquer la presence de l’operateur N, necessaire pour convertir les fractions en

nombres a virgule flottante.

Le filtrage consiste a effectuer le produit de convolution de cette matrice par l’image.

Dans le cas present, cela revient a remplacer chaque point de l’image par la moyenne

arithmetique de ce point et des 8 points voisins. Le filtrage est realise par :


CVFilter2D[img,img2,noyau];



2. Application : operateurs de derivation

2.a. Derivation simple

Le noyau de convolution suivant permet d’obtenir une approximation de la derivee

premiere suivant x (avec un moyennage dans la direction y) :

noyau=CVCreateMat[3,3,CV32F,1];

CVSetArray[noyau,1,N[––1,0,-1˝,–1,0,-1˝,–1,0,-1˝˝]]

La convolution conduit dans ce cas a des valeurs comprises entre -255 et 255. Il faut

donc creeer une image de nombres 16 bits signes :

img3=CVCreateImage[s,IplDepth16S,1];

CVFilter2D[img,img3,noyau]

Voyons les valeurs minimales et maximales de l’image obtenue :

minmax=CVMinMaxLoc[img3]

––-248., 246.˝, –84., 176.˝, –247., 155.˝˝

Le premier doublet donne les valeurs minimale et maximale, les deux doublets suivants

sont les positions du minimum et du maximum sur l’image.

Pour obtenir une image representable, il faut transformer l’intervalle [-255,255] en

[0,255] :


CVConvertScale[img3,img4,0.5,127.0];



Les derivees positives apparaissent comme des traits blancs, les derivees negatives

comme des traits noirs. Les zones ou la derivee est nulle sont gris moyen (valeur 127

environ).

2.b. Laplacien

Le laplacien de l’image est obtenu de la maniere suivante :


CVLaplace[img,img5,3];

Le dernier argument indique la taille du noyau utilise. Voyons le resultat :

minmax=CVMinMaxLoc[img5]

––-382., 340.˝, –86., 179.˝, –269., 39.˝˝


range=minmax[[1,2]]-minmax[[1,1]];

CVConvertScale[img5,img6,255.0/range,-255.0*minmax[[1,1]]/range];



2.c. Operateur de Sobel

Cet operateur est principalement utilise pour la detection de bords. Pour l’utiliser, on

doit preciser l’ordre des derivations par rapport a x et y :


xorder=1; yorder=1;

CVSobel[img,img7,xorder,yorder,3];

minmax=CVMinMaxLoc[img7];


range=minmax[[1,2]]-minmax[[1,1]];

CVConvertScale[img7,img8,255.0/range,-255.0*minmax[[1,1]]/range];



3. Detection de bords de Canny

La detection de bords de Canny repose sur le calcul de gradients. Il faut preciser un

seuil bas et un seuil haut. Si un pixel a un gradient superieur au seuil haut, il est considere

comme un bord et transforme en 255 (blanc). Si le gradient est inferieur au seuil bas, il

est transforme en 0 (noir). Si le gradient est entre les deux seuils, le pixel est considere

comme faisant partie d’un bord seulement s’il est connecte a un autre pixel de bord.


seuilHaut=120.0;

seuilBas=60.0;

CVCanny[img,img9,seuilBas,seuilHaut,3];


On remarque que certains bords d’objets ne sont pas detectes. Il s’agit toutefois d’une

image difficile car le contraste entre les objets et le fond est tres faible. D’autre part, des

elements de la texture de certains objets sont interpretes comme des bords. Une solution

a ce probleme consiste a appliquer un flou a l’image avant de detecter les bords.

4. Lissage

Le lissage est un filtrage par convolution qui consiste a estomper les details d’une

image, par exemple pour reduire le bruit ou faire disparaitre une texture genante.

On commence par selectionner la zone a filtrer avec l’editeur d’image :

edit=CVJImageEditor[’formes’,True];


rectList = CVJGetPixelRectangleList[edit];

rect = Floor[rectList[[1]]]


–33, 34, 183, 171˝

Cette zone rectangulaire sert a definir la region d’interet (Region Of Interest) :


CVConvertScale[img,img10,1.0,0.0];

CVRectangle[img10,rect,–0,0,0˝,1];

CVSetImageROI[img10,rect];

Comme exemple de lissage, appliquons un flou gaussien sur un noyau de 5x5 :

CVSmooth[img10,img10,CVGaussian,5,5,0.0];

CVResetImageROI[img10];


CVClose[];

Chapitre 7

Transformee de Hough et detection delignes

49


1. Transformee de Hough standard

1.a. Principe

La transformee de Hough est une methode permettant de detecter des droites dans

une image, c’est-a-dire un ensemble de points plus ou moins alignes. Cette methode

repose sur le parametrage d’une droite par un angle θ et une distance ρ comme definis

sur la figure suivante :

x

y

θρ

L’equation cartesienne de la droite est :

ρ = x cos θ + y sin θ

L’algorithme de Hough utilise une matrice accumulatrice qui represente le plan (ρ, θ), de

dimensions (p, q) ou p est le nombre de valeurs de ρ possibles et q le nombre de valeurs

de θ. Pour chaque point (x, y) de l’image binaire traitee, chaque droite (ρ, θ) passant

par ce point ajoute une unite dans l’element correspondant de la matrice. A la fin de

l’accumulation, les points de la matrice dont la valeur est la plus elevee correspondent

a un grand nombre de points alignes sur l’image. Ces droites sont selectionnees a partir

d’un seuil ajustable.

1.b. Utilisation

Needs[’CV‘’]

CVOpen[]

On commence par lire une image en niveaux de gris :

img=CVLoadImage[’pic5.png’,CVLoadImageGrayScale];

s=CVGetSize[img];

Image[CVGetImageArray[img,1,-1]]


Le but etant ici d’obtenir des droites representant les bords des formes, on procede

tout d’abord a une detection de bords de Canny :


CVCanny[img,img2,50.0,100.0,3];

Image[CVGetImageArray[img2,1,-1]]

On reserve un espace memoire pour la sequence de lignes :

mem=CVCreateMemStorage[0];

La fonction CVHoughLines2 permet d’obtenir les lignes sous forme d’une sequence :

method=CVHoughStandard;

seq=CVHoughLines2[img2,mem,method,1.0,N[2*Pi/100],100,0.0,0.0];


Le 4ieme argument (valeur 1.0) est la resolution en ρ de la matrice accumulatrice,

le 5ieme argument la resolution en θ. La resolution doit etre choisie en fonction de

l’image traitee. Dans le cas present, une resolution fine est adaptee car les bords sont

bien rectilignes. Le 5ieme argument est le seuil a partir duquel les droites accumulees sont

selectionnees. Les deux derniers arguments sont ici inutilises.

Le nombre de lignes retenues est donne par :

n=CVGetSeqSize[seq]

10

Le nombre de ligne depend du seuil choisi. Pour obtenir un nombre de ligne predetermine,

il faudra appliquer plusieurs fois la fonction CVHoughLines2 en faisant varier le seuil. Les

droites sont obtenues par :

lines=CVGetHoughLines[seq,method]

––19., 0.˝, –9., 1.5707963705062866˝, –-49., 2.2619469165802˝, –241., 0.˝,

–278., 1.5707963705062866˝, –236., 1.1309734582901˝, –-52., 2.38761043548584˝,

–383., 0.˝, –55., 2.2619469165802˝, –381., 0.˝˝

Les droites sont donnees par les doublets (ρ, θ). Par exemple, la premiere droite de la

liste est (ρ = 19, θ = 0).

Pour finir, on peut recuperer l’image en couleur et tracer dessus les lignes obtenues :

img3=CVLoadImage[’pic5.png’,CVLoadImageUnchanged];

CVDrawHoughLines[img3,seq,method,–255,0,0˝,1000,1];



2. Methode de Hough probabiliste

La methode de Hough probabiliste calcule seulement une fraction des points du plan

accumulateur en les choisissant aleatoirement, ce qui la rend plus rapide que la methode

standard. Elle effectue de plus des calculs de longueur des lignes, ce qui permet de detecter

des segments.

Voyons son application sur l’image precedente :

method=CVHoughProbabilistic;

seq=CVHoughLines2[img2,mem,method,1.0,N[2*Pi/100],80,10.0,1.0];

L’avant dernier argument (valeur 10.0) est la longueur minimale des segments retenus.

Le dernier argument (valeur 5.0) est la distance maximale entre deux segments alignes

pour qu’ils soient consideres comme un seul segment.

Le nombre de segments obtenus :

n=CVGetSeqSize[seq]

14

Les coordonnees des extremites des segments sont obtenues par :

segments=CVGetHoughLines[seq,method]

–––19., 277.˝, –19., 12.˝˝, ––121., 36.˝, –237., 132.˝˝, ––241., 276.˝, –241.,

99.˝˝, ––22., 9.˝, –238., 9.˝˝, ––79., 278.˝, –239., 278.˝˝, ––381., 255.˝,

–381., 157.˝˝, ––126., 59.˝, –172., 107.˝˝, ––383., 257.˝, –383., 155.˝˝,

––72., 130.˝, –128., 177.˝˝, ––262., 137.˝, –360., 91.˝˝, ––242., 62.˝, –328.,

22.˝˝, ––173., 215.˝, –237., 138.˝˝, ––263., 153.˝, –334., 153.˝˝, ––33., 95.˝,

–97., 17.˝˝˝

Trace des segments :

img3=CVLoadImage[’pic5.png’,CVLoadImageUnchanged];

CVDrawHoughLines[img3,seq,method,–255,0,0˝,1000,1];



CVClose[]

Chapitre 8

Retroprojection d’un histogramme

55


1. Introduction

Les histogrammes ont ete introduits dans Niveaux de gris et couleurs.

Considerons par exemple un histogramme de niveaux de gris d’une image monochrome.

Si x designe un niveau de gris quelconque, l’histogramme fournit (pour un echantillonnage

de x) le nombre f (x) de pixels de l’image ayant ce niveau de gris. La retroprojection d’un

histogramme sur une image est la transformation qui remplace le niveau x de chaque

point de l’image par la valeur f (x).

La retroprojection est surtout utilisee avec les histogrammes 2D Hue-Sat, dans le but

d’effectuer une reconnaissance d’objets a partir de leur couleur.

2. Retroprojection d’un histogramme HS

Un histogramme HS permet de connaitre le nombre de pixels f (h, s) ayant une valeur

h de HUE et s de SAT. La retroprojection consiste a remplacer chaque pixel de l’image

par la valeur f (h, s).

Comme exemple, on considere une image en comportant des objets de couleurs voi-

sines. On cherche a identifier les objets ayant la meme couleur qu’un objet particulier.

La meme technique pourra etre utilisee pour suivre un objet dans une sequence d’images

video.

On commence par lire l’image puis on selectionne un rectangle qui delimite une couleur

particuliere :

Needs[’CV‘’];

CVOpen[];

img=CVLoadImage[’puzzle.png’,CVLoadImageUnchanged];

s=CVGetSize[img];

edit=CVJImageEditor[’puzzle’,True];


rectList=CVJGetPixelRectangleList[edit];

rect=Floor[rectList[[1]]]

–66, 150, 16, 28˝


CVConvertScale[img,img2,1.0,0.0];

CVRectangle[img2,rect,–255,0,0˝,1];



L’image BGR est convertie en HSV puis les trois couches sont separees :

hsv=CVCreateImage[s,IplDepth8U,3];

CVCvtColor[img,hsv,CVBGR2HSV];

hue = CVCreateImage[s,IplDepth8U,1];

sat = CVCreateImage[s,IplDepth8U,1];

val = CVCreateImage[s,IplDepth8U,1];

CVSplit[hsv,hue,sat,val,0];

La zone rectangulaire selectionnee ci-dessus permet de definir une zone d’interet :

CVSetImageROI[hue,rect];

CVSetImageROI[sat,rect];

On calcule l’histogramme HS de cette zone d’interet, avec un echantillonnage de

20x20 :

histHS=CVCreateHist[–20,20˝,CVHistArray,––0,180˝,–0,255˝˝,1];

CVCalcHist[–hue,sat˝,histHS,0,0];

histImg=CVGetHueSatHistImage[histHS,10];

Image[CVGetImageArray[histImg,1,-1]]


Voyons les valeurs minimale et maximale de l’histogramme :

minmax=CVGetMinMaxHistValue[histHS]

––0., 0., 0.˝, –110., 1., 14.˝˝

La valeur maximale est ici inferieure a 256. D’une maniere generale, il faudra normaliser

l’histogramme avant d’effectuer la retroprojection sur une image 8 bits :

CVConvertHistScale[histHS,256.0/minmax[[2,1]],0.0];

On desactive les ROI puis on creee une image monochrome pour acceuillir la retroprojection :

CVResetImageROI[hue];

CVResetImageROI[sat];

back=CVCreateImage[s,IplDepth8U,1];

Enfin la retroprojection de l’histogramme sur l’image initiale :

CVCalcBackProject[–hue,sat˝,back,histHS];

Image[CVGetImageArray[back,1,-1]]


CVClose[];

interface mathematica pour opencv - f-legrand.fr · interface mathematica pour opencv 7...

Documents