su li anh vs open cv.pdf

B mn TGMT v KH R-bt

Khoa Cng ngh thng tin

H Khoa hc t nhin TP HCM

S DNG OPENCV

[CTT451] [Nhp mn Th gic My tnh]

Thng 3/2013

B mn TGMT & KHR | Khoa CNTT | H KHTN TP.HCM | Thng 3/2013

Trang 1

MC LC 1. Chun b: ........................................................................................................ 2

2. Cu hnh OpenCV vi Visual Studio C++ .................................................... 2

3. Chng trnh u tin .................................................................................... 6

4. Chng trnh th hai: .................................................................................... 7

5. Bi tp ............................................................................................................ 8


Trang 2

CU HNH OPENCV VI VS C++ 1. Chun b:

Download OpenCV ti: http://opencv.org/downloads.html, hoc download th

vin OpenCV c bin dch sn: http://www.mediafire.com/?gda0fgqi5u8h7.

Gm 3 th mc nh sau:

2. Cu hnh OpenCV vi Visual Studio C++


Trang 3

To project Lab1:

T Menu Project References


Trang 4

Chn Configuration Properties C/C++ General

Chn Configuration Properties Linker General


Trang 5

Chn Configuration Properties Linker Input

Sao chp cc file ui *.dll vo th mc debug ca Project


Trang 6

3. Chng trnh u tin

Vit chng trnh ti v hin mt tp tin nh cho trc ln mn hnh.

Sau khi to project, b sung on chng trnh sau:

#include "stdafx.h" #include #include #include int _tmain(int argc, _TCHAR* argv[]) { IplImage * img = cvLoadImage("C:\\hinh1.jpg"); if ( img != NULL ) { cvNamedWindow( "My window" ); cvShowImage( "My window", img ); cvWaitKey();//i ngi dng nhn 1 phm bt k cvReleaseImage( &img ); //Gii phng vng nh cvDestroyWindow( "My window" ); //ng ca s } return 0; }


Trang 7

on chng trnh trn s ti mt nh ln b nh v hin th ra mn hnh. Ta xem

xt mt s dng lnh chnh:

IplImage * img = cvLoadImage("C:\\hinh1.jpg");

Hm cvLoadImage() thc hin ti nh da vo tn file c truyn vo,

ng thi cp pht mt vng nh cn thit cho cu trc d liu nh. Hm ny tr v

mt con tr tr ti vng nh c cp pht trn.

cvNamedWindow( "My window" );

Hm cvNamedWindow to mt ca s trn mn hnh cha v hin th nh.

cvShowImage( "My window", img );

Chng ta c mt nh di dng mt con tr IplImage *, v hin th n

ln ca s va to thng qua hm cvShowImage().

4. Chng trnh th hai:

Vit chng trnh pht mt on video:

#include

int main( int argc, char** argv ) { cvNamedWindow( "Example2", CV_WINDOW_AUTOSIZE ); CvCapture* capture = cvCreateFileCapture("C:\\video1.avi"); IplImage* frame; while(1) { frame = cvQueryFrame( capture ); if( !frame ) break; cvShowImage( "Example2", frame ); char c = cvWaitKey(33); if( c == 27 ) break; } cvReleaseCapture( &capture ); cvDestroyWindow( "Example2" ); }

CvCapture* capture = cvCreateFileCapture("video1.avi");


Trang 8

Hm cvCreateFileCapture() vi tham s truyn vo l tn on video

cn load on video v s tr v con tr tr ti cu trc CvCapture. Cu trc ny

s cha ton b thng tin on video c c.

frame = cvQueryFrame( capture );

Bn trong vng lp while, bt u c on video. Hm cvQueryFrame()

bt frame k tip trong on video trn vo vng nh (vng nh ny l mt phn

ca cu trc CvCapture c cp pht trc ). Mt con tr c tr v cho

frame c bt gi ny. V cvQueryFrame s dng vng nh c cp pht

cho cu trc nn khng cn gi hm cvReleaseImage() cho frame ny.

5. Bi tp

Vit chng trnh chuyn nh sang nh mc xm (grayscale).

B mn TGMT v KH R-bt



LP TRNH VI OPENCV


Thng 3/2013


Trang 1

MC LC 1. Mt s hm thng dng trong OpenCV ........................................................ 2

2. Ti v hin th nh ......................................................................................... 3

3. Chuyn nh t h mu sang nh xm ....................................................... 5

4. Tch cc knh mu ca nh RGB .................................................................. 6

5. Bi tp ............................................................................................................ 7


Trang 2

LP TRNH VI OPENCV 1. Mt s hm thng dng trong OpenCV

Hm c nh t file:

IplImage* cvLoadImage(string strPathName);

Hm sao chp nh:

void cvCopyImage(IplImage* src, IplImage* dst); IplImage* cvCloneImage( const IplImage* image);

Hm hy i tng nh:

void cvReleaseImage ( IplImage** image);

Hm to ca s:

cvNamedWindow(char* strWindowName, int flag); flag nu l s l th hin th ng kch thc nh.

Hin th nh trn ca s:

cvShowImage (char* strWindowName, IplImage* img);

Hm chuyn i h mu:

void cvCvtColor(IplImage* src, IplImage* dst, int code); Hng s code quy nh cch chuyn i c dng:

CV_2

VD:

CV_BGR2HSV

CV_RGB2GRAY

CV_HSV2BGR

Tch cc knh mu:

cvCvtPixToPlane ( IplImage* src, IplImage* img1, IplImage* img2, IplImage* img3, IplImage* img4); Trn cc knh mu:

void cvCvtPlaneToPix( const CvArr* src0, const CvArr* src1, const CvArr* src2, const CvArr* src3, CvArr* dst);


Trang 3

2. Ti v hin th nh

To lp IplImageWrapper nh sau: class IplImageWrapper { protected: IplImage* _srcImg; IplImage* _destImg; int _width, _height; IplImage *r_plane, *b_plane, *g_plane; public: IplImageWrapper(); ~IplImageWrapper(); void LoadImage(char* path); void ShowImage(char* windowName, int img = 0); void RGB2GRAY1(); void RGB2GRAY2();

void PixToPlane(); void PixToPlane2();

};

Lp gm c 2 bin _srcImg v _destImg l nh ngun v nh ch, hai bin _width, _height lu li kch thc nh v cc bin r_plane, b_plane, g_plane cha tng knh mu ca nh.

Hm constructor v destructor:

IplImageWrapper::IplImageWrapper() { _srcImg = NULL; _destImg = NULL; } IplImageWrapper::~IplImageWrapper() { if(_srcImg != NULL) cvReleaseImage(&_srcImg); if(_destImg != NULL) cvReleaseImage(&_destImg); }

Xy dng hm LoadImage v ShowImage nh sau:


Trang 4

void IplImageWrapper::LoadImage(char* path) { if(_srcImg != NULL) cvReleaseImage(&_srcImg); _srcImg = cvLoadImage(path); if(_srcImg != NULL) { _width = _srcImg->width; _height = _srcImg->height; } } Hm c chc nng load nh t ng dn path v c tr bi con tr _srcImg.

void IplImageWrapper::ShowImage(char* windowName, int img) { IplImage* image; if(img == 0) image = _srcImg; else if(img = 1) image = _destImg; else if(img = 2) image = b_plane;


Trang 5

else if(img = 3) image = g_plane; else if(img = 4) image = r_plane; if(image != NULL) { cvNamedWindow(windowName,1); cvShowImage(windowName,image); } }

Hm to ca s c tn windowName v hin th nh ln ca s ny.

3. Chuyn nh t h mu sang nh xm

Chuyn nh t h mu sang nh xm s dng hm ca OpenCV

void IplImageWrapper::RGB2GRAY1() { if(_destImg != NULL) cvReleaseImage(&_destImg); _destImg = cvCreateImage(cvSize(_width, _height), IPL_DEPTH_8U, 1); cvCvtColor(_srcImg, _destImg, CV_RGB2GRAY); }

Chuyn nh t h mu sang nh xm da vo cng thc:

Gray = 0.299 * R + 0.587 * G + 0.114 * B

void IplImageWrapper::RGB2GRAY2() { int step, channels; step = _srcImg->widthStep; channels = _srcImg->nChannels; _destImg = cvCloneImage(_srcImg); uchar* dataGray; dataGray = (uchar*)_destImg->imageData; int i, j; for(i = 0; i < _height; i++) for (j = 0; j < _width; j++) { uchar r,g,b,gray_value; b = dataGray[i*step+j*channels]; g = dataGray[i*step+j*channels + 1];


Trang 6

r = dataGray[i*step+j*channels + 2]; gray_value = (int)(r*0.3 + g*0.59

+ b*0.11); dataGray[i*step+j*channels] = dataGray[i*step+j*channels + 1] = dataGray[i*step+j*channels + 2] =

gray_value; } }

4. Tch cc knh mu ca nh RGB

Tch cc knh mu s dng hm ca OpenCV

void IplImageWrapper::PixToPlane() { r_plane = cvCreateImage(cvSize(_width,_height), 8, 1); g_plane = cvCreateImage(cvSize(_width,_height), 8, 1); b_plane = cvCreateImage(cvSize(_width,_height), 8, 1); cvCvtPixToPlane(_srcImg, b_plane, g_plane, r_plane, NULL); }

Tch cc knh mu (truy cp d liu nh)

void IplImageWrapper::PixToPlane2()


Trang 7

{ int i, j, step, channels; step = _srcImg->widthStep; channels = _srcImg->nChannels; b_plane = cvCloneImage(_srcImg); g_plane = cvCloneImage(_srcImg); r_plane = cvCloneImage(_srcImg); uchar *dataB, *dataG, *dataR; dataB = (uchar *)b_plane->imageData; dataG = (uchar *)g_plane->imageData; dataR = (uchar *)r_plane->imageData; for(i = 0; i < _height; i++) for (j = 0; j < _width; j++) { dataB[i*step+j*channels+1] = 0; dataB[i*step+j*channels+2] = 0; dataG[i*step+j*channels] = 0; dataG[i*step+j*channels+2] = 0; dataR[i*step+j*channels] = 0; dataR[i*step+j*channels+1] = 0; } }

5. Bi tp

o To nh m bn (negative image) ca nh mc xm

o To nh m bn ca nh mu


Trang 8

o Thc hin cng thm mt hng s vo gi tr ti mi im nh trn nh

mc xm.

o Thc hin vi 3 hng s, mi hng s c dng cng vo gi tr ca

knh mu tng ng ti mi im trn nh mu.

B mn TGMT v KH R-bt



CAMERA CALIBRATION


Thng 3/2013


Trang 1

MC LC Mt s hm Camera Calibration trong OpenCV ........................................... 2 1.

Tnh cc tham s intrinsic v extrinsic ca camera ....................................... 3 2.

2.1. Xc nh cc im gc trn nh bn c: ...................................................... 3

2.2. Tm cc tham s intrinsic v extrinsic ......................................................... 4

Bi tp ............................................................................................................ 4 3.


Trang 2

CAMERA CALIBRATION Mt s hm Camera Calibration trong OpenCV 1.

S dng bn c nh sau:

- Hm xc nh v tr cc gc ca bn c:

int cvFindChessboardCorners(

const void* image,

CvSize patternSize, CvPoint2D32f* corners,

int* cornerCount=NULL,

int flags=CV_CALIB_CB_ADAPTIVE_THRESH)

- V cc gc trn bn c:

void cvDrawChessboardCorners(

CvArr* image,

CvSize pattern_size,

CvPoint2D32f* corners,

int count,

int pattern_was_found);

- Tnh cc tham s intrinsic v extrinsic ca camera:

void cvCalibrateCamera2(

CvMat* object_points,

CvMat* image_points,

int* point_counts,

CvSize image_size,

CvMat* intrinsic_matrix,

CvMat* distortion_coeffs,

CvMat* rotation_vectors = NULL,

CvMat* translation_vectors = NULL,


Trang 3

int flags = 0);

- Tnh undistortion map:

void cvInitUndistortMap(

const CvMat* cameraMatrix,

const CvMat* distCoeffs,

CvArr* map1,

CvArr* map2);

Tnh cc tham s intrinsic v extrinsic ca camera 2.

Cho tp nh bn c sau:

(http://courses.fit.hcmus.edu.vn/file.php/1893/Checkerboard.rar)

2.1. Xc nh cc im gc trn nh bn c: while(done!=-1)

{ char path[200]; strcpy(path, search_dir); strcat(path, fileinfo.name); //Load image from folder image = cvLoadImage(path, 1); cvShowImage("Original Image",image); gray_image = cvCreateImage( cvGetSize( image ), 8, 1 ); // Find chessboard corners:


Trang 4

int found = cvFindChessboardCorners( image, board_sz, corners, &corner_count, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS );

// Get subpixel accuracy on those corners cvCvtColor( image, gray_image, CV_BGR2GRAY ); cvFindCornerSubPix(gray_image, corners, corner_count, cvSize(11, 11 ), cvSize( -1, -1 ), cvTermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1 )); // Draw it cvDrawChessboardCorners(image,board_sz,corners,corner_count, found ); cvShowImage( "Calibration", image ); // If we got a good board, add it to our data if( corner_count == board_n ) { step = successes*board_n; for( int i=step, j=0; j < board_n; ++i, ++j ) {

CV_MAT_ELEM( *image_points, float, i, 0 ) = corners[j].x; CV_MAT_ELEM( *image_points, float, i, 1 ) = corners[j].y;

CV_MAT_ELEM( *object_points, float, i, 0 ) = j/board_w; CV_MAT_ELEM( *object_points, float, i, 1 ) = j%board_w; CV_MAT_ELEM( *object_points, float, i, 2 ) = 0.0f; } CV_MAT_ELEM( *point_counts, int, successes, 0 ) = board_n; successes++; } cvWaitKey(500); done = _findnext( handle, &fileinfo ); }

on code s ln lt load cc nh trong th mc c ng dn l

search_dir. Vi mi nh s tin hnh tm cc im gc.

2.2. Tm cc tham s intrinsic v extrinsic // Calibrate the camera cvCalibrateCamera2( object_points2, image_points2, point_counts2, cvGetSize( image ), intrinsic_matrix, distortion_coeffs, NULL, NULL, CV_CALIB_FIX_ASPECT_RATIO );

// Save the intrinsics and distortions cvSave( "Intrinsics.xml", intrinsic_matrix ); cvSave( "Distortion.xml", distortion_coeffs );

Bi tp 3.

- T tp cc nh bn c

(http://courses.fit.hcmus.edu.vn/file.php/1893/Checkerboard.rar ) tm cc

im gc v tnh cc tham s intrinsic v extrinsic.

- Hin th nh Undistort.

CANNY EDGE DETECTION


Thng 4/2013

B mn TGMT v KH R-bt



B mn TGMT & KHR | Khoa CNTT | H KHTN TP.HCM | Thng 4/2013 2

MC LC MC LC ........................................................................................................................... 1

1 Thut ton Pht hin cnh Canny ................................................................................ 3

2 Ci t thut ton pht hin cnh bng OpenCV ........................................................ 4

3 Bi tp .......................................................................................................................... 6

Ti liu tham kho ............................................................................................................... 7


1 Thut ton Pht hin cnh Canny Bc 1: Gim nhiu

Thng thng gim nhiu s dng cc b lc lm m. C th s dng b lc

Gaussian tch chp vi nh:

2 4 5 4 2

4 9 12 9 4

5 12 15 12 5

4 9 12 9 4

2 4 5 4 2

Bc 2: Tnh ln v gc ca Gradient

Tnh o hm ( ) v ( ) theo chiu x v y ca nh. Mt s b lc nh:

Roberts, Prewitt, Sobel.

B lc Sobel 3x3:

-1 0 1 1 2 1

-2 0 2 0 0 0

-1 0 1 -1 -2 -1

ln Gradient:

( ) ( )

Gc Gradient:

( ( )

( ))

Tnh bng cch lm trn t gc vo mt trong bn hng: 00, 450, 900, 1350.


Bc 3: chn khng cc i (Non-Maximum Surpression)

Bc ny ch gi li nhng pixel thuc cnh m c ln gradient ln nht

Xem xt 3 pixel trong vng 3 x 3 xung quanh pixel (x,y):

- Nu (x, y) = 00 th (x+1, y), (x, y) v (x-1, y) c xem xt.

- Nu (x, y) = 900 th (x, y+1), (x, y) v (x, y-1).

- Nu (x, y) = 450 th (x+1, y+1), (x, y) v (x-1, y-1).

- Nu (x, y) = 1350 th (x-1, y+1), (x, y) v (x+1, y-1).

Nu pixel (x, y) c gradient ln nht ca 3 pixel xem xt th pixel l cnh.

Bc 4: Ngng Hysteresis (Hysteresis Thresholding)

Hysteresis s dng 2 ngng, ngng thigh v tlow. Pixel m c ln gradient D <

tlow th c loi ngay lp tc. Nhng pixel tlow < D < thigh c gi li nu l mt cnh

lin tc vi nhng pixel c ln gradient D > thigh.

2 Ci t thut ton pht hin cnh bng OpenCV Xy dng class Canny nh sau:

class Canny { protected: IplImage *_srcImg, *_destImg; int _width, _height; int _lowThreshold, _maxThreshold; public: Canny(int low, int max) { _srcImg = NULL;


_destImg = NULL; _lowThreshold = low; _maxThreshold = max; } int CannyEdgeDetection(char *path); };

Hm CannyEdgedetection:

int Canny::CannyEdgeDetection(char *path) { _srcImg = cvLoadImage(path); if(_srcImg == NULL) return 0; cvNamedWindow("Image"); cvShowImage("Image", _srcImg); IplImage *grayImg, *blurImg; grayImg = cvCreateImage(cvGetSize(_srcImg), IPL_DEPTH_8U, 1); cvCvtColor(_srcImg, grayImg, CV_BGR2GRAY); cvNamedWindow("Gray Image"); cvShowImage("Gray Image", grayImg); blurImg = cvCreateImage(cvGetSize(_srcImg), IPL_DEPTH_8U, 1); cvSmooth(grayImg, blurImg, CV_GAUSSIAN, 5, 5);

cvNamedWindow("Blur Image"); cvShowImage("Blur Image", blurImg);

_destImg = cvCreateImage(cvGetSize(_srcImg), IPL_DEPTH_8U, 1); cvCanny(blurImg, _destImg, _lowThreshold, _maxThreshold, 3); cvNamedWindow("Canny Edge Detection"); cvShowImage("Canny Edge Detection",_destImg); return 1; }


3 Bi tp Vit chng trnh pht hin bin cnh da vo thut ton Canny nh trong mc 1.


Ti liu tham kho [1] Canny, J., A Computational Approach To Edge Detection, IEEE Trans. Pattern

Analysis and Machine Intelligence, 8(6):679698, 1986.

SIFT HARRIS - BLOB


Thng 4/2013

B mn TGMT v KH R-bt




MC LC MC LC ........................................................................................................................... 1

1 Scale invariant feature transform (SIFT) ..................................................................... 3

1.1 Xy dng khng gian t l ......................................................................................... 3

1.2 D tm cc tr cc b ................................................................................................. 4

1.3 Loi b keypoint c tng phn (contrast) thp................................................... 4

1.4 Loi b keypoint nm trn bin cnh ........................................................................ 5

1.5 Gn hng cho keypoint ........................................................................................... 5

1.6 Miu t c trng ....................................................................................................... 6

2 Thut ton pht hin gc Harris .................................................................................. 7

3 Thut ton pht hin Blob ........................................................................................... 8

4 Bi tp .......................................................................................................................... 9

Ti liu tham kho ............................................................................................................. 10


1 Scale invariant feature transform (SIFT)

1.1 Xy dng khng gian t l

- Khng gian t l (scale space) gm cc nh , tch chp

(convolution) ca lc Gaussian vi nh u vo .

- Khng gian t l c chia thnh tng octave, mi octave gm 1 s nguyn s

nh. Cc nh tch chp vi lc Gaussian khc nhau tham s k, .

Phi to ra s + 3 nh cho mi octave, nh c lm m th i trong octave s

l .

- Difference-of-Gaussian c s dng pht hin im trng yu

(keypoint) trong khng gian t l, bng cch tr 2 nh L k nhau trong

octave nh trong Error! Reference source not found..

(1.1)

- Sau khi x l xong trn 1 octave, nh u tin trong octave k tip c

gim kch thc i mt na.


1.2 D tm cc tr cc b

- Tm cc i v cc tiu ca cc , mi im c so snh vi 8 ln

cn trong nh hin ti, v 9 ln cn trong scale trn v scale di. Mt im

c chn ch khi hoc n ln hn tt c hoc nh hn tt c cc ln cn.

1.3 Loi b keypoint c tng phn (contrast) thp

p dng khai trin Taylor cp 2 cho hm .

(1.2)

Trong :

o hm cp 1 ca D ti x:

(

)

o hm cp 2 ca D ti x:

(

)

Ly o hm ca D(x) v cho bng khng:

(1.3)


Nu ti bt k hng no th im cc tr nm gn mt keypoint

khc hn l keypoint ang xt, loi keypoint ang xt.

Gi tr ca hm c s dng loi nhng cc tr c tng phn thp,

thay vo D ta c:

Nhng cc tr c gi tr | | s c loi b (gi s gi tr

xm ca im nh nm trong on [0,1]).

1.4 Loi b keypoint nm trn bin cnh

Tin hnh loi b cc im nm trn bin cnh, s khng n nh nu c

mt lng nhiu nh. Phng php Harris c dng xc nh xem 1

keypoint nm gc, bin cnh hay trn vng phng.

[

] (1.4)

o hm c c lng thng qua hiu s cc im ln cn. trnh tnh

cc gi tr ring, m ch cn quan tm ti t s ca chng. Gi l hai gi

tr ring ca H.

( )

Gi r l t s gia 2 gi tr ring:

Ch gi li nhng keypoint m c:

Ngng ngh r = 10.

1.5 Gn hng cho keypoint

Gn mt hng thch hp cho keypoint da trn c tnh cc b ca nh, v

vy bt bin vi php quay nh.

Vi mi nh c lm m L(x,y) scale gn nht m keypoint c pht hin,

ln gradient v hng c tnh:


( )

Lc hng gm 36 bins biu din ht 360o ca cc hng gradient.

Cc im xung quanh keypoint c thm vo lc bng ln gradient v

ca s trn trng s Gaussian.

Tm nh cao nht trong lc , cc nh cn li m t 80% so vi nh

cao nht, th s to keypoint ng vi hng ny.

1.6 Miu t c trng

Tnh ln v hng gradient ca mi im xung quanh keypoint. Hm

Gaussian c dng gn trng s ln ch mi im. Kch thc vng

xung quanh keypoint l 16x16, v c chia thnh 4x4 vng con.

Vector miu t c trng cha gi tr ca tt c lc hng. Vng con

4x4 ca lc biu din 8 hng cho mi bin. S thnh phn ca vector c

trng cho mi keypoint l 4x4x8 = 128.


2 Thut ton pht hin gc Harris Tnh o hm theo x v y ca nh

Tnh tch ti mi pixel ca o hm v

p b lc Gaussian ln , v

Ti mi pixel:

[

]

Gi:

A =

B =

C =

M = det(H) k * Trace(H)2 > ngng

Tnh nonmax suppression

Ti mi pixel, gi tr M(x,y) khng ln hn cc pixel xung quanh (3 x 3) th

loi pixel ny.


3 Thut ton pht hin Blob Xy dng khng gian t l (scale space):

T nh ban u to ra cc nh m vi mc khc nhau. Sau thay i kch

thc nh ban u xung mt na, v tip tc sinh ra cc nh m. Qu trnh c lp li

nh th.

to ra cc nh m c th p dng b lc Laplacian. C th xp x Laplacian bi

Difference of Gaussians.

Pht hin cc cc i (cc tiu) cc b: blob l cc v tr m c cc i cc b

khng ch trong cng nh (8 pixel ln cn) m cn vi cc pixel trong hai nh t l ln

cn (2 x 9 pixel ln cn), nh vy tng cng 8 + 18 pixel ln cn c xem xt.


4 Bi tp - Vit chng trnh tm c trng SIFT.

- Vit chng trnh pht hin gc Harris

- Vit chn trnh pht hin Blob.


Ti liu tham kho [1] David G. Lowe, "Distinctive image features from scale-invariant keypoints,"

International Journal of Computer Vision, 60, 2 (2004), pp. 91-110.

[2] C. Harris and M. Stephens (1988). "A combined corner and edge detector".

Proceedings of the 4th Alvey Vision Conference. pp. 147151.

SPLIT AND MERGE

ALGORITHM


Thng 4/2013

B mn TGMT v KH R-bt




MC LC MC LC ........................................................................................................................... 1

1 Cc thut ton Split v Merge ..................................................................................... 3

2 Thut ton WaterShed ................................................................................................. 3

3 Bi tp .......................................................................................................................... 5

Ti liu tham kho ............................................................................................................... 6


1 Cc thut ton Split v Merge Cho R biu din ton b vng ca nh, v mt logic v t P.

- Split (chia nh): vi mi vng Ri, m P(Ri) = FALSE th chia nh Ri. Chia nh

cc vng cho n khi cc vng Ri m P(Ri) = TRUE.

- Merge (nhm li): nhm cc vng ln cn Ri v Rk nu ( ) .

Mt s thut ton th hin t tng Slit v Merge ny nh:

- Watershed

- Region splitting

- Region merging

- Graph-based segmentation

- Probabilistic aggregation

2 Thut ton WaterShed Hm cho thut ton Watershed nh sau:

void cvWatershed(const CvArr* image, CvArr* markers);

Vi:

image l nh mu 8 bit

maker l nh knh n (IPL_DEPTH_32S) c cng kch thc vi image.

Maker c th c c t mt n nh phn s dng cvFindContours() v

cvDrawContours(). Tham kho on chng trnh FindContours v DrawContours

sau:

#include "cv.h" #include "highgui.h" int main( int argc, char** argv ) { IplImage* src; // the first command line parameter must be file name of binary // (black-n-white) image if( argc == 2 && (src=cvLoadImage(argv[1], 0))!= 0) { IplImage* dst = cvCreateImage( cvGetSize(src), 8, 3 ); CvMemStorage* storage = cvCreateMemStorage(0); CvSeq* contour = 0; cvThreshold( src, src, 1, 255, CV_THRESH_BINARY ); cvNamedWindow( "Source", 1 );


cvShowImage( "Source", src ); cvFindContours( src, storage, &contour, sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE ); cvZero( dst ); for( ; contour != 0; contour = contour->h_next ) { CvScalar color = CV_RGB( rand()&255, rand()&255, rand()&255 ); /* replace CV_FILLED with 1 to see the outlines */ cvDrawContours( dst, contour, color, color, -1, CV_FILLED, 8 ); } cvNamedWindow( "Components", 1 ); cvShowImage( "Components", dst ); cvWaitKey(0); } }


3 Bi tp - Ci t mt s thut ton Split v Merge:

o Watershed

o Region splitting

o Region merging

o Graph-based segmentation

o Probabilistic aggregation


Ti liu tham kho [1] Computer Vision: Algorithms and Applications, book draft by Richard Szeliski.

COMPUTATION

HOMOGRAPHY


Thng 5/2013

B mn TGMT v KH R-bt




MC LC MC LC ........................................................................................................................... 1

1 ng dng Homography ............................................................................................... 3

2 Chng trnh ................................................................................................................ 3


1 ng dng Homography Tm mt i tng bit trc

Cho i tng sau:

Tm i tng trn trong hnh sau:

Bc 1: pht hin cc keypoints s dng c trng SURF

Bc 2: t tp cc keypoints c pht hin trn, tnh ton cc vector c trng

(vector miu t).

Bc 3: i snh cc vector miu t s dng FLANN matcher.

- V cc i snh tt nht: l cc i snh nh hn ngng

- Xc nh i tng trong nh

2 Chng trnh #include "stdio.h" #include "iostream" #include "opencv/cv.h" #include "opencv/highgui.h"


#include "opencv2/nonfree/features2d.hpp" #include "opencv2/legacy/legacy.hpp" #include "opencv2/core/core.hpp" using namespace cv; /** @function main */ int main( int argc, char** argv ) { Mat img_object = imread( "C:\\OPENCV245\\Test\\3.jpg", CV_LOAD_IMAGE_GRAYSCALE ); Mat img_scene = imread( "C:\\OPENCV245\\Test\\5.jpg", CV_LOAD_IMAGE_GRAYSCALE ); if( !img_object.data || !img_scene.data ) { std::cout max_dist ) max_dist = dist; } printf("-- Max dist : %f \n", max_dist ); printf("-- Min dist : %f \n", min_dist ); //-- Draw only "good" matches (i.e. whose distance is less than 3*min_dist ) std::vector< DMatch > good_matches; for( int i = 0; i < descriptors_object.rows; i++ ) { if( matches[i].distance < 3*min_dist ) { good_matches.push_back( matches[i]); }


} Mat img_matches; drawMatches( img_object, keypoints_object, img_scene, keypoints_scene, good_matches, img_matches, Scalar::all(-1), Scalar::all(-1), vector(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS ); //-- Localize the object std::vector obj; std::vector scene; for( int i = 0; i < good_matches.size(); i++ ) { //-- Get the keypoints from the good matches obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt ); scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt ); } Mat H = findHomography( obj, scene, CV_RANSAC ); //-- Get the corners from the image_1 ( the object to be "detected" ) std::vector obj_corners(4); obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint( img_object.cols, 0 ); obj_corners[2] = cvPoint( img_object.cols, img_object.rows ); obj_corners[3] = cvPoint( 0, img_object.rows ); std::vector scene_corners(4); perspectiveTransform( obj_corners, scene_corners, H); //-- Draw lines between the corners (the mapped object in the scene - image_2 ) line( img_matches, scene_corners[0] + Point2f( img_object.cols, 0), scene_corners[1] + Point2f( img_object.cols, 0), Scalar(0, 255, 0), 4 ); line( img_matches, scene_corners[1] + Point2f( img_object.cols, 0), scene_corners[2] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 ); line( img_matches, scene_corners[2] + Point2f( img_object.cols, 0), scene_corners[3] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 ); line( img_matches, scene_corners[3] + Point2f( img_object.cols, 0), scene_corners[0] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 ); //-- Show detected matches imshow( "Good Matches & Object detection", img_matches ); waitKey(0); return 0; }

Chy chng trnh


i tng th 2:

Kalman v Particle Filter


Thng 5/2013

B mn TGMT v KH R-bt




MC LC MC LC ........................................................................................................................... 1

1 V d s dng Kalman Filter: ...................................................................................... 3

2 Mean-Shift ................................................................................................................... 6

3 Pht hin v theo vt khun mt trong video .............................................................. 6


1 V d s dng Kalman Filter: Gi s chng ta c mt im chuyn ng xung quanh mt vng trn, nh mt chic

xe chy trn ng ua. Chic xe chuyn ng vi vn tc l mt hng s. Xc nh

v tr chic xe s dng phng php theo vt.

#include "opencv2/video/tracking.hpp" #include "opencv2/highgui/highgui.hpp" #include using namespace cv; static inline Point calcPoint(Point2f center, double R, double angle) { return center + Point2f((float)cos(angle), (float)-sin(angle))*(float)R; } int main(int, char**) { Mat img(500, 500, CV_8UC3); KalmanFilter KF(2, 1, 0); Mat state(2, 1, CV_32F); /* (phi, delta_phi) */ Mat processNoise(2, 1, CV_32F); Mat measurement = Mat::zeros(1, 1, CV_32F); char code = (char)-1; for(;;) { randn( state, Scalar::all(0), Scalar::all(0.1) ); KF.transitionMatrix = *(Mat_(2, 2)


Point measPt = calcPoint(center, R, measAngle); // plot points #define drawCross( center, color, d ) \ line( img, Point( center.x - d, center.y - d ), \ Point( center.x + d, center.y + d ), color, 1, CV_AA, 0); \ line( img, Point( center.x + d, center.y - d ), \ Point( center.x - d, center.y + d ), color, 1, CV_AA, 0 ) img = Scalar::all(0); drawCross( statePt, Scalar(255,255,255), 3 ); drawCross( measPt, Scalar(0,0,255), 3 ); drawCross( predictPt, Scalar(0,255,0), 3 ); line( img, statePt, measPt, Scalar(0,0,255), 3, CV_AA, 0 ); line( img, statePt, predictPt, Scalar(0,255,255), 3, CV_AA, 0 ); if(theRNG().uniform(0,4) != 0) KF.correct(measurement); randn( processNoise, Scalar(0), Scalar::all(sqrt(KF.processNoiseCov.at(0, 0)))); state = KF.transitionMatrix*state + processNoise; imshow( "Kalman", img ); code = (char)waitKey(100); if( code > 0 ) break; } if( code == 27 || code == 'q' || code == 'Q' ) break; } return 0; }


2 Mean-Shift int cvMeanShift(

const CvArr* prob_image,

CvRect window,

CvTermCriteria criteria,

CvConnectedComp* comp

);

prob_image biu din v tr mt c th ca d liu.

window ca s kernel ban u

criteria: quyt nh s ln lp ca window c th dng

comp cha ta tm kim ca window.

3 Pht hin v theo vt khun mt trong video #include "opencv/cv.h" #include "opencv/cxcore.h" #include "opencv/highgui.h" #include #include #include using namespace std; // Create memory for calculations static CvMemStorage* storage = 0; // Create a new Haar classifier static CvHaarClassifierCascade* cascade = 0; // Create a string that contains the cascade name const char* cascade_name = "haarcascade_frontalface.xml"; /* "haarcascade_profileface.xml";*/ void detect_and_draw(IplImage* img); bool writeActive; IplImage* im; IplImage* imFace; IplImage* imR; IplImage* imG; IplImage* imB;


struct face { CvRect rectangle; int dx, dy, confidence; float weight; CvHistogram* rHistogram; CvHistogram* gHistogram; CvHistogram* bHistogram; }; vector allFaces; CvHistogram* getHistogram(IplImage* im, CvRect r) { cvSetImageROI(im, r); int numBins = 64; float range[] = {0.0,255.0}; float* ranges[] = {range}; CvHistogram* h = cvCreateHist(1, &numBins, CV_HIST_ARRAY, ranges); cvCalcHist(&im, h); /*for(int binIter=0; binIter


n1*=f.rectangle.width * searchSTD; n1+=predX; n2*=f.rectangle.height * searchSTD; n2+=predY; n3=1; /*n3*=0.05; n3+=1; n3 = MIN(1.3, MAX(0.7,n3) );/**/ scale = n3; newWidth = predW * scale; //scale = n4; newHeight = predH * scale; if (n1>0 && n2>0 && n1


{ //cout


coutheight),IPL_DEPTH_8U, 1); imG = cvCreateImage(cvSize(im->width,im->height),IPL_DEPTH_8U, 1); imB = cvCreateImage(cvSize(im->width,im->height),IPL_DEPTH_8U, 1); IplImage* sampling = cvCreateImage(cvSize(im->width,im->height),IPL_DEPTH_32F, 1); int frame = 0; int keyPressed = -1; writeActive=true; while(i!=0 && (keyPressed==-1 || keyPressed=='f' || keyPressed=='w')) { cvShowImage("Given",im); cvCvtColor(im, imHSV, CV_BGR2HSV); CvScalar pixRGB, pixHSV; float cb, cr; //separate into channels cvSetImageCOI(im,1); cvCopy(im,imB); cvSetImageCOI(im,2); cvCopy(im,imG);


cvSetImageCOI(im,3); cvCopy(im,imR); cvSetImageCOI(im,0); if(keyPressed=='w') { writeActive=!writeActive; } if (frame==0 || allFaces.size()==0 || keyPressed=='f') //detect faces { // Clear the memory storage which was used before cvClearMemStorage( storage ); // There can be more than one face in an image. So create a growable sequence of faces. // Detect the objects and store them in the sequence CvSeq* faces = cvHaarDetectObjects( im, cascade, storage, 1.1, 2, CV_HAAR_DO_CANNY_PRUNING, cvSize(40, 40) ); for(int currentFace=0; currentFacetotal; currentFace++) { //get rectangle bounding first face CvRect* r = (CvRect *)cvGetSeqElem( faces, currentFace ); face newFace; newFace.rectangle = *r; newFace.confidence = 2; newFace.dx = 0; newFace.dy = 0; //find the total amount of skin-colored pixels in the face float skinSum=0; for (int y=r->y; yy+r->height; y++) { for (int x=r->x; xx+r->width; x++) { pixRGB = cvGet2D(im,y,x); pixHSV = cvGet2D(imHSV,y,x); cb = 0.148*pixRGB.val[2] - 0.291*pixRGB.val[1] + 0.439*pixRGB.val[0] + 128; cr = 0.439*pixRGB.val[2] - 0.368*pixRGB.val[1] - 0.071*pixRGB.val[0] + 128; if ( ( pixHSV.val[0]>245 || pixHSV.val[0]


bool matchesExisting=false; for(int faceIter = 0; faceIter < allFaces.size(); faceIter++ ) { //find the width and height of the region of overlap int overlapWidth, overlapHeight; if ( newFace.rectangle.x < allFaces.at(faceIter).rectangle.x) { overlapWidth = min( newFace.rectangle.x + newFace.rectangle.width - allFaces.at(faceIter).rectangle.x, allFaces.at(faceIter).rectangle.width); }else{ overlapWidth = min( allFaces.at(faceIter).rectangle.x + allFaces.at(faceIter).rectangle.width - newFace.rectangle.x, newFace.rectangle.width); } if ( newFace.rectangle.y < allFaces.at(faceIter).rectangle.y) { overlapHeight = min( newFace.rectangle.y + newFace.rectangle.height - allFaces.at(faceIter).rectangle.y, allFaces.at(faceIter).rectangle.height); }else{ overlapHeight = min( allFaces.at(faceIter).rectangle.y + allFaces.at(faceIter).rectangle.height - newFace.rectangle.y, newFace.rectangle.height); } //if region of overlap is greater than 60% of larger rectangle, then faces are the same if ( ((float)overlapWidth*overlapHeight)/(max( newFace.rectangle.width*newFace.rectangle.height, allFaces.at(faceIter).rectangle.width*allFaces.at(faceIter).rectangle.height) )>0.6) { matchesExisting = true; allFaces.at(faceIter).confidence = min( 4, allFaces.at(faceIter).confidence+2); allFaces.at(faceIter).rectangle = newFace.rectangle; allFaces.at(faceIter).dx = newFace.dx; allFaces.at(faceIter).dy = newFace.dy; allFaces.at(faceIter).rHistogram = getHistogram(imR, newFace.rectangle); allFaces.at(faceIter).gHistogram = getHistogram(imG, newFace.rectangle); allFaces.at(faceIter).bHistogram = getHistogram(imB, newFace.rectangle); break; } } if (!matchesExisting) //if its new, add it to our vector { newFace.rHistogram = getHistogram(imR, newFace.rectangle); newFace.gHistogram = getHistogram(imG, newFace.rectangle);


newFace.bHistogram = getHistogram(imB, newFace.rectangle); allFaces.push_back(newFace); } } //subtract 1 from confidence of all faces for(int faceIter = 0; faceIter < allFaces.size(); faceIter++ ) { allFaces.at(faceIter).confidence--; if (allFaces.at(faceIter).confidence < 1) //if confidence gone, remove it { allFaces.erase(allFaces.begin()+faceIter, allFaces.begin()+faceIter+1); faceIter--; } } } if(allFaces.size()>0) //track faces { cvSet(sampling,cvScalar(0)); for(int faceIter = 0; faceIter < allFaces.size(); faceIter++ ) //first face only for now { //predicted position int predX = allFaces.at(faceIter).rectangle.x + allFaces.at(faceIter).dx; int predY = allFaces.at(faceIter).rectangle.y + allFaces.at(faceIter).dy; vector samples = getSamples(allFaces.at(faceIter), predX, predY, allFaces.at(faceIter).rectangle.width, allFaces.at(faceIter).rectangle.height, 100, 0.2, im->width, im->height); //do importance resampling a number of times for(int resampling=0; resamplingwidth, im->height); } int bestIdx=0; float bestWeight=0; //generate random samples for(int sampleIter=0; sampleIter bestWeight) { bestWeight = samples.at(sampleIter).weight; bestIdx = sampleIter; } //cvSet2D(sampling, samples.at(sampleIter).rectangle.y,samples.at(sampleIter).rectangle.x, cvScalar(samples.at(sampleIter).weight)); }


//move to best sample allFaces.at(faceIter).dx = samples.at(bestIdx).rectangle.x - allFaces.at(faceIter).rectangle.x; allFaces.at(faceIter).dy = samples.at(bestIdx).rectangle.y - allFaces.at(faceIter).rectangle.y; allFaces.at(faceIter).rectangle = samples.at(bestIdx).rectangle; /*cvCopyHist(samples.at(bestIdx).rHistogram, &allFaces.at(faceIter).rHistogram); cvCopyHist(samples.at(bestIdx).gHistogram, &allFaces.at(faceIter).gHistogram); cvCopyHist(samples.at(bestIdx).bHistogram, &allFaces.at(faceIter).bHistogram);*/ } drawFaces(); //cvCvtColor(imFace, imCopy, CV_BGR2RGB); //if(writeActive) //cvWriteFrame(writer, imFace); //scaleAndShow(sampling,"Sampling"); //cvWaitKey(1); } i = cvGrabFrame(capture); im = cvRetrieveFrame(capture); frame++; keyPressed = cvWaitKey(100); } cvReleaseImage(&im); cvReleaseImage(&imCopy); cvReleaseImage(&imHSV); cvReleaseImage(&skin); cvReleaseCapture(&capture); cvReleaseVideoWriter(&writer); return 0; }

su li anh vs open cv.pdf

Documents