车牌定位html5,OpenCV下车牌定位算法实现代码（一）

#ifdef _CH_

#pragma package 

#endif

#ifndef _EiC

#include "cv.h"

#include "highgui.h"

#include 

#include 

#include 

#endif

intthresh = 50;

IplImage* img = 0;

IplImage* img0 = 0;

CvMemStorage* storage = 0;

CvPoint pt[4];

constchar* wndname ="Square Detection Demo";

// helper function:

// finds a cosine of angle between vectors

// from pt0->pt1 and from pt0->pt2

doubleangle( CvPoint* pt1, CvPoint* pt2, CvPoint* pt0 )

{

doubledx1 = pt1->x - pt0->x;

doubledy1 = pt1->y - pt0->y;

doubledx2 = pt2->x - pt0->x;

doubledy2 = pt2->y - pt0->y;

return(dx1*dx2 + dy1*dy2)/sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);

}

// returns sequence of squares detected on the image.

// the sequence is stored in the specified memory storage

CvSeq* findSquares4( IplImage* img, CvMemStorage* storage )

{

CvSeq* contours;

inti, c, l, N = 11;

CvSize sz = cvSize( img->width & -2, img->height & -2 );

IplImage* timg = cvCloneImage( img );// make a copy of input image

IplImage* gray = cvCreateImage( sz, 8, 1 );

IplImage* pyr = cvCreateImage( cvSize(sz.width/2, sz.height/2), 8, 3 );

IplImage* tgray;

CvSeq* result;

doubles, t;

// create empty sequence that will contain points -

// 4 points per square (the square's vertices)

CvSeq* squares = cvCreateSeq( 0,sizeof(CvSeq),sizeof(CvPoint), storage );

// select the maximum ROI in the image

// with the width and height divisible by 2

cvSetImageROI( timg, cvRect( 0, 0, sz.width, sz.height ));

// down-scale and upscale the image to filter out the noise

cvPyrDown( timg, pyr, 7 );

cvPyrUp( pyr, timg, 7 );

tgray = cvCreateImage( sz, 8, 1 );

// find squares in every color plane of the image

for( c = 0; c 

{

// extract the c-th color plane

cvSetImageCOI( timg, c+1 );

cvCopy( timg, tgray, 0 );

// try several threshold levels

for( l = 0; l 

{

// hack: use Canny instead of zero threshold level.

// Canny helps to catch squares with gradient shading

if( l == 0 )

{

// apply Canny. Take the upper threshold from slider

// and set the lower to 0 (which forces edges merging)

cvCanny( tgray, gray,60, 180, 3 );

// dilate canny output to remove potential

// holes between edge segments

cvDilate( gray, gray, 0, 1 );

}

else

{

//apply threshold if l!=0:

//tgray(x,y) = gray(x,y) 

//cvThreshold( tgray, gray, (l+1)*255/N, 255, CV_THRESH_BINARY );

cvThreshold( tgray, gray, 50, 255, CV_THRESH_BINARY );

}

// find contours and store them all as a list

cvFindContours( gray, storage, &contours,sizeof(CvContour),

CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) );

// test each contour

while( contours )

{

// approximate contour with accuracy proportional

// to the contour perimeter

result = cvApproxPoly( contours,sizeof(CvContour), storage,

CV_POLY_APPROX_DP, cvContourPerimeter(contours)*0.02, 0 );

// square contours should have 4 vertices after approximation

// relatively large area (to filter out noisy contours)

// and be convex.

// Note: absolute value of an area is used because

// area may be positive or negative - in accordance with the

// contour orientation

if( result->total == 4 &&

fabs(cvContourArea(result,CV_WHOLE_SEQ)) > 1000 &&

cvCheckContourConvexity(result) )

{

s = 0;

for( i = 0; i 

{

// find minimum angle between joint

// edges (maximum of cosine)

if( i >= 2 )

{

t = fabs(angle(

(CvPoint*)cvGetSeqElem( result, i ),

(CvPoint*)cvGetSeqElem( result, i-2 ),

(CvPoint*)cvGetSeqElem( result, i-1 )));

s = s > t ? s : t;

}

}

// if cosines of all angles are small

// (all angles are ~90 degree) then write quandrange

// vertices to resultant sequence

if( s 

for( i = 0; i 

cvSeqPush( squares,

(CvPoint*)cvGetSeqElem( result, i ));

}

// take the next contour

contours = contours->h_next;

}

}

}

// release all the temporary images

cvReleaseImage( &gray );

cvReleaseImage( &pyr );

cvReleaseImage( &tgray );

cvReleaseImage( &timg );

returnsquares;

}

// the function draws all the squares in the image

voiddrawSquares( IplImage* img, CvSeq* squares )

{

CvSeqReader reader;

IplImage* cpy = cvCloneImage( img );

inti;

// initialize reader of the sequence

cvStartReadSeq( squares, &reader, 0 );

// read 4 sequence elements at a time (all vertices of a square)

for( i = 0; i total; i += 4 )

{

CvPoint* rect = pt;

intcount = 4;

// read 4 vertices

memcpy( pt, reader.ptr, squares->elem_size );

CV_NEXT_SEQ_ELEM( squares->elem_size, reader );

memcpy( pt + 1, reader.ptr, squares->elem_size );

CV_NEXT_SEQ_ELEM( squares->elem_size, reader );

memcpy( pt + 2, reader.ptr, squares->elem_size );

CV_NEXT_SEQ_ELEM( squares->elem_size, reader );

memcpy( pt + 3, reader.ptr, squares->elem_size );

CV_NEXT_SEQ_ELEM( squares->elem_size, reader );

// draw the square as a closed polyline

cvPolyLine( cpy, &rect, &count, 1, 1, CV_RGB(0,255,0), 3, CV_AA, 0 );

}

// show the resultant image

cvShowImage( wndname, cpy );

cvReleaseImage( &cpy );

}

voidon_trackbar(inta )

{

if( img )

drawSquares( img, findSquares4( img, storage ) );

}

char* names[] = {"pic1.png","pic2.png","pic3.png",

"pic4.png","pic5.png","pic6.png", 0 };

intmain(intargc,char** argv)

{

inti, c;

// create memory storage that will contain all the dynamic data

storage = cvCreateMemStorage(0);

for( i = 0; names[i] != 0; i++ )

{

// load i-th image

img0 = cvLoadImage( names[i], 1 );

if( !img0 )

{

printf("Couldn't load %s\n", names[i] );

continue;

}

img = cvCloneImage( img0 );

// create window and a trackbar (slider) with parent "image" and set callback

// (the slider regulates upper threshold, passed to Canny edge detector)

cvNamedWindow( wndname,0 );

cvCreateTrackbar("canny thresh", wndname, &thresh, 1000, on_trackbar );

// force the image processing

on_trackbar(0);

// wait for key.

// Also the function cvWaitKey takes care of event processing

c = cvWaitKey(0);

// release both images

cvReleaseImage( &img );

cvReleaseImage( &img0 );

// clear memory storage - reset free space position

cvClearMemStorage( storage );

if( c == 27 )break;

}

cvDestroyWindow( wndname );

return0;

}

#ifdef _EiC

main(1,"squares.c");

#endif