/*************************************************************************
* @函数名称：
* calStructSim()
* @输入:
* const IplImage* input1 - 输入图像1
* const IplImage* input2 - 输入图像2
* @返回值:
* double - 结构度相似性
* @说明:
* 计算图像结构度相似性，用图像像素间的相关来刻画结构关系
* 计算公式为：l(x,y)=(cov_xy+c2)/(std_x+std_y+c2)
*************************************************************************/
double calStructSim(const IplImage* input1, const IplImage* input2)
{
double stc=0, c3=0;
double k2=0.03;
CvScalar stdev1, stdev2;
CvScalar mean1,mean2;
cvAvgSdv(input1,&mean1,&stdev1);
cvAvgSdv(input2,&mean2,&stdev2);
double cov = 0;
double sum = 0;
int i, j;
int rows=input1->height;
int cols=input1->width;
for (i = 0; i < rows; i++)
{
uchar* input1_data=(uchar*)(input1->imageData+i*input1->widthStep);
uchar* input2_data=(uchar*)(input2->imageData+i*input2->widthStep);
for (j = 0; j < cols; j++)
{
sum += ((input1_data[j] - mean1.val[0]) *(input2_data[j] - mean2.val[0]));
}
}
cov = sum / (rows*cols);
c3 = (k2 * 255) * (k2 * 255) / 2;
stc=(cov+c3)/(stdev1.val[0]*stdev2.val[0]+c3);
return stc;
}
CvMat * icvReadSVHNImages(char * filename, CvMat * response)
{
const int max_samples = response->rows;
const int max_strlen = 64*64;
CvMat * data = cvCreateMat(max_samples,max_strlen,CV_32F);
char datastr[1000];
int ii; CvMat hdr;
CvMat * sample = cvCreateMat(64,64,CV_32F);
CvMat * warp = cvCreateMat(2,3,CV_32F);
for (ii=0;;ii++){
sprintf(datastr,filename,ii+1);
IplImage * img = cvLoadImage(datastr, CV_LOAD_IMAGE_GRAYSCALE);
if (!img || ii==max_samples){break;}
CvMat * mat = cvCreateMat(img->height,img->width,CV_32F);
cvConvert(img,mat);
int nimages = CV_MAT_ELEM(*response,int,ii,0);
float ww = CV_MAT_ELEM(*response,int,ii,3);
float hh = CV_MAT_ELEM(*response,int,ii,4);
float xx = CV_MAT_ELEM(*response,int,ii,1)-ww*.5f;
float yy = CV_MAT_ELEM(*response,int,ii,2)-hh*.5f;
for (int jj=1;jj<nimages;jj++){
float www = CV_MAT_ELEM(*response,int,ii,1+4*jj+2);
float hhh = CV_MAT_ELEM(*response,int,ii,1+4*jj+3);
float xxx = CV_MAT_ELEM(*response,int,ii,1+4*jj+0)-www*.5f;
float yyy = CV_MAT_ELEM(*response,int,ii,1+4*jj+1)-hhh*.5f;
xx = MIN(xx,xxx); yy = MIN(yy,yyy);
ww = MAX(xxx+www-xx,ww);
hh = MAX(yyy+hhh-yy,hh);
}
xx+=ww*.5f;yy+=hh*.5f; float ss = MAX(ww,hh);
cvZero(warp);cvZero(sample);
warp->data.fl[2]=xx-ss*.5f-ss*.15f;
warp->data.fl[5]=yy-ss*.5f-ss*.15f;
warp->data.fl[0]=warp->data.fl[4]=ss*1.3f/64.f; //
icvWarp(mat,sample,warp);
CvScalar avg,sdv;
cvAvgSdv(sample,&avg,&sdv);
cvSubS(sample,avg,sample);
cvScale(sample,sample,1.f/sdv.val[0]);
#if 0 // debug
cvPrintf(stderr,"%f,",warp);
cvAvgSdv(sample,&avg,&sdv); // re-calculate
fprintf(stderr,"avg: %f, sdv: %f\n--\n",avg.val[0],sdv.val[0]);
CV_SHOW(sample); // CV_SHOW(mat);
#endif
memcpy(data->data.fl+max_strlen*ii,sample->data.ptr,max_strlen*sizeof(float));
cvReleaseImage(&img);
cvReleaseMat(&mat);
}
data->rows = ii;
cvReleaseMat(&sample);
cvReleaseMat(&warp);
assert(CV_MAT_TYPE(data->type)==CV_32F);
return data;
}
/*************************************************************************
* @函数名称：
* calContrastSim()
* @输入:
* IplImage* input1 - 输入图像1
* IplImage* input2 - 输入图像2
* @返回值:
* double - 返回图像对比度相似性
* @说明:
* 计算图像对比度相似性，考虑了图像的对比度掩盖效应
* 计算公式为：l(x,y)=(2*std_x*std_y+c2)/(std_x*std_x+std_y*std_y+c2)
*************************************************************************/
double calContrastSim(const IplImage* input1, const IplImage* input2)
{
double con=0, c2=0;
double k2=0.03;
CvScalar stdev1, stdev2;
cvAvgSdv(input1,NULL,&stdev1);
cvAvgSdv(input2,NULL,&stdev2);
c2=(k2*255 )*(k2*255);
con=(2*stdev1.val[0]*stdev2.val[0]+c2)/(stdev1.val[0]*stdev1.val[0]+stdev2.val[0]*stdev2.val[0]+c2);
return con;
}
static CvSeq *
gst_face_detect_run_detector (GstFaceDetect * filter,
CvHaarClassifierCascade * detector, gint min_size_width,
gint min_size_height)
{
double img_stddev = 0;
if (filter->min_stddev > 0) {
CvScalar mean, stddev;
cvAvgSdv (filter->cvGray, &mean, &stddev, NULL);
img_stddev = stddev.val[0];
}
if (img_stddev >= filter->min_stddev) {
return cvHaarDetectObjects (filter->cvGray, detector,
filter->cvStorage, filter->scale_factor, filter->min_neighbors,
filter->flags, cvSize (min_size_width, min_size_height)
#if (CV_MAJOR_VERSION >= 2) && (CV_MINOR_VERSION >= 2)
, cvSize (0, 0)
#endif
);
} else {
GST_LOG_OBJECT (filter,
"Calculated stddev %f lesser than min_stddev %d, detection not performed",
img_stddev, filter->min_stddev);
return cvCreateSeq (0, sizeof (CvSeq), sizeof (CvPoint), filter->cvStorage);
}
}
CvSeq *reghand::filthull2(CvSeq *filted_elimhull)
{
//CvSeq *filtedhullseq=cvCloneSeq(filted_elimhull);
float maxdis=0;CvPoint **fingpt;CvScalar mean,std=cvScalarAll(0);
CvMat *dismat=cvCreateMat(1,filted_elimhull->total,CV_32FC1);
CvPoint2D32f center=minrect.center;
for (int i=0;i<filted_elimhull->total;i++)
{
CvPoint **data=CV_GET_SEQ_ELEM(CvPoint*,filted_elimhull,i);
CvPoint pt=**data;
float dis=sqrt(pow(pt.x-center.x,2)+pow(pt.y-center.y,2));
dismat->data.fl[i]=dis;
if(dis>maxdis){maxdis=dis;fingpt=data;}
}
cvAvgSdv(dismat,&mean,&std);
if(filted_elimhull->total==1&&maxdis>fingerTh*0.5) return filted_elimhull;
if(filted_elimhull->total==2&&maxdis>fingerTh*0.5&&std.val[0]<10)
{
CvPoint startpt=**CV_GET_SEQ_ELEM(CvPoint*,filted_elimhull,0);
CvPoint endpt=**CV_GET_SEQ_ELEM(CvPoint*,filted_elimhull,1);;
double bfang=atan(double(startpt.y-handcenter.y)/(startpt.x-handcenter.x))*180/PI;
if(bfang<0)bfang+=180;
double afang=atan(double(endpt.y-handcenter.y)/(endpt.x-handcenter.x))*180/PI;
if(afang<0)afang+=180;
if(fabs(bfang-afang)>60)
{cvClearSeq(filted_elimhull);cvSeqPush(filted_elimhull,fingpt);return filted_elimhull;}
else return filted_elimhull;
}
IplImage* getColor(IplImage* img)
{
//printf("Place object in the middle of the frame");
IplImage* img2 = cvCreateImage(cvGetSize(img),8,3);
cvCvtColor(img,img2,CV_BGR2HSV);
IplImage* roi = cvCreateImage(cvGetSize(img), 8, 3);
roi = cvCloneImage(img2);
cvSetImageROI(roi, cvRect(220,160,160,128)); // Center object in the middle of the frame
// Find avg and std dev of Image
CvScalar meanScalar;
CvScalar stdDevScalar;
cvAvgSdv(roi, &meanScalar, &stdDevScalar);
double meanH;
double meanS;
double meanV;
double stdH;
double stdS;
double stdV;
meanH = meanScalar.val[0];
meanS = meanScalar.val[1];
meanV = meanScalar.val[2];
stdH = stdDevScalar.val[0];
stdS = stdDevScalar.val[1];
stdV = stdDevScalar.val[2];
// Set ranges
double minH;
double minS;
double minV;
double maxH;
double maxS;
double maxV;
minH = meanH - stdH;
minS = meanS - stdS;
minV = meanV - stdV;
maxH = meanH + stdH;
maxS = meanS + stdS;
maxV = meanV + stdV;
minC.val[0] = minH;
minC.val[1] = minS;
minC.val[2] = minV;
maxC.val[0] = maxH;
maxC.val[1] = maxS;
maxC.val[2] = maxV;
cvReleaseImage(&img2);
cvShowImage("ROI", roi);
cvReleaseImage(&roi);
}
void cvMean_StdDev( const CvArr* image, double* mean, double* sdv, const CvArr* mask)
{
CvScalar _mean, _sdv;
cvAvgSdv( image, &_mean, &_sdv, mask );
if( mean )
*mean = _mean.val[0];
if( sdv )
*sdv = _sdv.val[0];
}
void THISCLASS::OnStep() {
// Get the input image
IplImage* inputimage = mCore->mDataStructureImageGray.mImage;
if (! inputimage) {
AddError(wxT("No image on selected input."));
return;
}
// Calculate non-zero elements
if (mCalculateNonZero) {
int non_zero= cvCountNonZero(inputimage);
CommunicationMessage m(wxT("STATS_NONZERO"));
m.AddInt(non_zero);
mCore->mCommunicationInterface->Send(&m);
}
// Calculate sum
if (mCalculateSum) {
CvScalar sum= cvSum(inputimage);
CommunicationMessage m(wxT("STATS_SUM"));
m.AddDouble(sum.val[0]);
mCore->mCommunicationInterface->Send(&m);
}
// Calculate mean and standard deviation
if (mCalculateMeanStdDev) {
CvScalar mean;
CvScalar std_dev;
cvAvgSdv(inputimage, &mean, &std_dev, NULL);
CommunicationMessage m(wxT("STATS_MEANSTDDEV"));
m.AddDouble(mean.val[0]);
m.AddDouble(std_dev.val[0]);
mCore->mCommunicationInterface->Send(&m);
}
// Calculate min and max
if (mCalculateMinMax) {
double min_val;
double max_val;
cvMinMaxLoc(inputimage, &min_val, &max_val, NULL, NULL, NULL);
CommunicationMessage m(wxT("STATS_MINMAX"));
m.AddDouble(min_val);
m.AddDouble(max_val);
mCore->mCommunicationInterface->Send(&m);
}
// Set the display
DisplayEditor de(&mDisplayOutput);
if (de.IsActive()) {
de.SetMainImage(inputimage);
}
}
/**
- FUNCIÓ: Mean
- FUNCIONALITAT: Get blob mean color in input image
- PARÀMETRES:
- image: image from gray color are extracted
- RESULTAT:
-
- RESTRICCIONS:
-
- AUTOR: rborras
- DATA DE CREACIÓ: 2008/05/06
- MODIFICACIÓ: Data. Autor. Descripció.
*/
double CBlob::Mean( IplImage *image )
{
// it is calculated?
/* if( m_meanGray != -1 )
{
return m_meanGray;
}
*/
// Create a mask with same size as blob bounding box
IplImage *mask;
CvScalar mean, std;
CvPoint offset;
GetBoundingBox();
if (m_boundingBox.height == 0 ||m_boundingBox.width == 0 || !CV_IS_IMAGE( image ))
{
m_meanGray = 0;
return m_meanGray;
}
// apply ROI and mask to input image to compute mean gray and standard deviation
mask = cvCreateImage( cvSize(m_boundingBox.width, m_boundingBox.height), IPL_DEPTH_8U, 1);
cvSetZero(mask);
offset.x = -m_boundingBox.x;
offset.y = -m_boundingBox.y;
// draw contours on mask
cvDrawContours( mask, m_externalContour.GetContourPoints(), CV_RGB(255,255,255), CV_RGB(255,255,255),0, CV_FILLED, 8,
offset );
// draw internal contours
t_contourList::iterator it = m_internalContours.begin();
while(it != m_internalContours.end() )
{
cvDrawContours( mask, (*it).GetContourPoints(), CV_RGB(0,0,0), CV_RGB(0,0,0),0, CV_FILLED, 8,
offset );
it++;
}
cvSetImageROI( image, m_boundingBox );
cvAvgSdv( image, &mean, &std, mask );
m_meanGray = mean.val[0];
m_stdDevGray = std.val[0];
cvReleaseImage( &mask );
cvResetImageROI( image );
return m_meanGray;
}
void SSR(IplImage* src, int sigma, int scale)
{
IplImage* src_fl = cvCreateImage(cvGetSize(src), IPL_DEPTH_32F, src->nChannels);
IplImage* src_fl1 = cvCreateImage(cvGetSize(src), IPL_DEPTH_32F, src->nChannels);
IplImage* src_fl2 = cvCreateImage(cvGetSize(src), IPL_DEPTH_32F, src->nChannels);
float a = 0.0, b = 0.0, c = 0.0;
cvConvertScale(src, src_fl, 1.0, 1.0);//转换范围，所有图像元素增加1.0保证cvlog正常
cvLog(src_fl, src_fl1);
cvSmooth(src_fl, src_fl2, CV_GAUSSIAN, 0, 0, sigma); //SSR算法的核心之一，高斯模糊
cvLog(src_fl2, src_fl2);
cvSub(src_fl1, src_fl2, src_fl);//Retinex公式，Log(R(x,y))=Log(I(x,y))-Log(Gauss(I(x,y)))
//计算图像的均值、方差，SSR算法的核心之二
//使用GIMP中转换方法：使用图像的均值方差等信息进行变换
//没有添加溢出判断
CvScalar mean;
CvScalar dev;
cvAvgSdv(src_fl, &mean, &dev, NULL);//计算图像的均值和标准差
double min[3];
double max[3];
double maxmin[3];
for (int i = 0; i < 3; i++)
{
min[i] = mean.val[i] - scale*dev.val[i];
max[i] = mean.val[i] + scale*dev.val[i];
maxmin[i] = max[i] - min[i];
}
float* data2 = (float*)src_fl->imageData;
for (int i = 0; i < src_fl2->width; i++)
{
for (int j = 0; j < src_fl2->height; j++)
{
data2[j*src_fl->widthStep / 4 + 3 * i + 0] = 255 * (data2[j*src_fl->widthStep / 4 + 3 * i + 0] - min[0]) / maxmin[0];
data2[j*src_fl->widthStep / 4 + 3 * i + 1] = 255 * (data2[j*src_fl->widthStep / 4 + 3 * i + 1] - min[1]) / maxmin[1];
data2[j*src_fl->widthStep / 4 + 3 * i + 2] = 255 * (data2[j*src_fl->widthStep / 4 + 3 * i + 2] - min[2]) / maxmin[2];
}
}
cvConvertScale(src_fl, src, 1, 0);
cvReleaseImage(&src_fl);
cvReleaseImage(&src_fl1);
cvReleaseImage(&src_fl2);
}
int main( int argc, char** argv )
{
//Check if user specify image to process
if(argc >= 2 )
{
char* filename= argv[1];
//load image in gray level
imagen=cvLoadImage(filename,0);
}
else
{
printf("Use:\n\t%s image\n",argv[0]);
return 0;
}
//------------------------------------------------------------------------------------
//NUMBER ISOLATION
//Create needed images
smooth= cvCreateImage(cvSize(imagen->width, imagen->height), IPL_DEPTH_8U, 1);
threshold= cvCreateImage(cvSize(imagen->width, imagen->height), IPL_DEPTH_8U, 1);
open_morf= cvCreateImage(cvSize(imagen->width, imagen->height), IPL_DEPTH_8U, 1);
cvSmooth(imagen, smooth, CV_GAUSSIAN, 3, 0, 0, 0);
CvScalar avg;
CvScalar avgStd;
cvAvgSdv(smooth, &avg, &avgStd, NULL);
//printf("Avg: %f\nStd: %f\n", avg.val[0], avgStd.val[0]);
//threshold image
cvThreshold(smooth, threshold, (int)avg.val[0]+4*(int)(avgStd.val[0]/8), 255, CV_THRESH_BINARY);
//Morfologic filters
cvErode(threshold, open_morf, NULL,1);
cvDilate(open_morf, open_morf, NULL,1);
int lprs=cvSaveImage(argv[2],open_morf,&lprs);
//Duplicate image for countour
cvReleaseImage(&imagen);
cvReleaseImage(&open_morf);
return 0;
}
int set_avg_pos( IplImage* frame){
CvScalar avgScalar;
CvScalar stnScalar;
cvSetImageROI(frame,g_msPrm.box);
cvAvgSdv(frame,&avgScalar,&stnScalar,NULL);
set_sliders_filter("set_HSV",&avgScalar,&stnScalar);
printf("avg h - %f s - %f v - %f\n",
avgScalar.val[0],
avgScalar.val[1],
avgScalar.val[2]
);
printf("avg hs - %f ss - %f vs - %f\n",
stnScalar.val[0],
stnScalar.val[1],
stnScalar.val[2]
);
cvResetImageROI(frame);
//cvCvtColor(frame,frame,CV_HSV2RGB);
draw_box(frame,g_msPrm.box);
cvShowImage("Camera",frame);
return 0;
}
int load_asef_filters(const char* file_name, int *p_n_rows, int *p_n_cols,
CvRect *left_eye_region, CvRect *right_eye_region,
CvMat **p_left_filter, CvMat **p_right_filter){
int rv;
char buf[LINE_BUF_SIZE];
FILE *fp = fopen(file_name, "r");
if (!fp){
return -1;
}
int n_rows, n_cols; // row and column size
read_line(fp, buf, LINE_BUF_SIZE);
printf("%s\n", buf);
if (strcmp(buf, "CFEL")){
return -1;
}
// Print comments and copyright
for (int i = 0; i < 2; i++){
if (read_line(fp, buf, LINE_BUF_SIZE) <= 0){
return -1;
}
printf("%s\n", buf);
}
read_line(fp, buf, LINE_BUF_SIZE);
sscanf(buf, "%d %d", &n_rows, &n_cols);
*p_n_rows = n_rows;
*p_n_cols = n_cols;
int rect_x, rect_y, rect_width, rect_hight;
read_line(fp, buf, LINE_BUF_SIZE);
sscanf(buf, "%d %d %d %d", &rect_x, &rect_y, &rect_width, &rect_hight);
if (left_eye_region){
*left_eye_region = cvRect(rect_x, rect_y, rect_width, rect_hight);
}
read_line(fp, buf, LINE_BUF_SIZE);
sscanf(buf, "%d %d %d %d", &rect_x, &rect_y, &rect_width, &rect_hight);
if (right_eye_region){
*right_eye_region = cvRect(rect_x, rect_y, rect_width, rect_hight);
}
uint32_t endien_checker;
unsigned long endianness;
read_line(fp, buf, LINE_BUF_SIZE);
endien_checker = *(uint32_t*)buf;
// printf("%u, %u, %u\n", endien_checker, 0x41424344, 0x44434241);
if ( !strcmp(buf, "ABCD") ){
// Big endian
endianness = 0;
} else if ( !strcmp(buf, "DCBA")){
// Little endian
// Almost always this case on your x86 machine.
// Not sure about ARM (Android/iOS), you can test it out :)
endianness = 1;
} else {
endianness = -1;
}
// TODO: handle big endian with byte swap;
size_t filter_data_size = n_rows * n_cols * sizeof(float);
CvScalar mean, std_dev;
unsigned char* lfilter_data = (unsigned char*)malloc(filter_data_size);
rv = fread(lfilter_data, 1, filter_data_size, fp);
assert(rv == filter_data_size);
if (p_left_filter){
CvMat *left_filter = cvCreateMatHeader(n_rows, n_cols, CV_32FC1);
cvSetData(left_filter, lfilter_data, CV_AUTO_STEP);
cvAvgSdv(left_filter, &mean, &std_dev, NULL);
cvScale(left_filter, left_filter, 1.0/std_dev.val[0], -mean.val[0]*1.0/std_dev.val[0]);
*p_left_filter = left_filter;
} else{
free(lfilter_data);
}
unsigned char* rfilter_data = (unsigned char*)malloc(filter_data_size);
rv = fread(rfilter_data, 1, filter_data_size, fp);
assert(rv == filter_data_size);
if (p_right_filter){
CvMat *right_filter = cvCreateMatHeader(n_rows, n_cols, CV_32FC1);
cvSetData(right_filter, rfilter_data, CV_AUTO_STEP);
cvAvgSdv(right_filter, &mean, &std_dev, NULL);
cvScale(right_filter, right_filter, 1.0/std_dev.val[0], -mean.val[0]*1.0/std_dev.val[0]);
*p_right_filter = right_filter;
} else{
free(rfilter_data);
}
fclose(fp);
return 1;
}
char* char_ext(IplImage* imagen,basicOCR ocr )
{
//cvNamedWindow("temp");
//cvShowImage("temp",imagen);
//cvWaitKey(0);
//char* plate=NULL;
char* no=(char*)malloc(20*sizeof(char));
//------------------------------------- -----------------------------------------------
//NUMBER ISOLATION
//Create needed images
smooth= cvCreateImage(cvGetSize(imagen), imagen->depth, 1);
threshold= cvCreateImage(cvGetSize(imagen), imagen->depth, 1);
open_morf= cvCreateImage(cvGetSize(imagen), imagen->depth, 1);
//Init variables for countours
contour = 0;
contourLow = 0;
//Create storage needed for contour detection
CvMemStorage* storage = cvCreateMemStorage(0);
//Smooth image
cvSmooth(imagen, smooth, CV_GAUSSIAN, 3, 0, 0, 0);
CvScalar avg;
CvScalar avgStd;
cvAvgSdv(smooth, &avg, &avgStd, NULL);
//printf("Avg: %f\nStd: %f\n", avg.val[0], avgStd.val[0]);
//threshold image
cvThreshold(smooth, threshold, (int)avg.val[0]+4*(int)(avgStd.val[0]/8), 255, CV_THRESH_BINARY_INV);
//Morfologic filters
cvErode(threshold, open_morf, NULL,1);
cvDilate(open_morf, open_morf, NULL,1);
//Duplicate image for countour
img_contornos=cvCloneImage(open_morf);
//Search countours in preprocesed image
cvFindContours( img_contornos, storage, &contour, sizeof(CvContour),
CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cvPoint(0, 0) );
//Optimize contours, reduce points
contourLow=cvApproxPoly(contour, sizeof(CvContour), storage,CV_POLY_APPROX_DP,1,1);
//-----------------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------
//NUMBER RECOGNITION
CvRect rect;
int carea=0,area=0;
int count=0;
int match;
int w,h;
w=imagen->width;
h=imagen->height;
area=(w)*(h);
// printf("area : %d, %d %d\n",area,w,h);
//printf("\n%d\n",area/26);
char name[6];
//static int width;
for( ; contourLow != 0; contourLow = contourLow->h_next )
{
rect=cvBoundingRect(contourLow,0);
cvSetImageROI(smooth,rect);
IplImage *temp22=cvCreateImage(cvSize(rect.width,rect.height),IPL_DEPTH_8U,1);
IplImage *temp23=cvCreateImage(cvSize(rect.width,rect.height),IPL_DEPTH_8U,1);
cvCopy(smooth,temp22,NULL);
carea=rect.width*rect.height;
/*if((rect.width>rect.height)||(carea>(area/6))||(carea<(area/25)))
{
cvReleaseImage(&temp22);
continue;
}*/
if((carea<(area/4))&&(carea>(area/25)))
{
static int width = temp22->width;
sprintf(name,"char%d",count);
cvNamedWindow(name);
cvMoveWindow(name,840 - count*3*width,10);
cvThreshold(temp22, temp23, (int)avg.val[0]+4*(int)(avgStd.val[0]/8), 255, CV_THRESH_BINARY);
cvShowImage(name,temp23);
cvWaitKey(500);
match=ocr.classify(temp23,0);
if(match<=25)
no[count]=97+match;
else
no[count]=48+match-26;
count++;
}
cvReleaseImage(&temp22);
cvReleaseImage(&temp23);
cvResetImageROI(smooth);
}
cvWaitKey(0);
no[count]='\0';
rev(no,count);
//strcpy(plate,no);
//printf("\n%d\n",count);
//-------------------------------------------------------------------------------------------------------------------------------------
//cvReleaseImage(&imagen_color);
cvReleaseImage(&imagen);
cvReleaseImage(&open_morf);
cvReleaseImage(&img_contornos);
return no;
free(no);
}
CV_IMPL void
cvMatchTemplate( const CvArr* _img, const CvArr* _templ, CvArr* _result, int method )
{
cv::Ptr<CvMat> sum, sqsum;
int coi1 = 0, coi2 = 0;
int depth, cn;
int i, j, k;
CvMat stub, *img = (CvMat*)_img;
CvMat tstub, *templ = (CvMat*)_templ;
CvMat rstub, *result = (CvMat*)_result;
CvScalar templ_mean = cvScalarAll(0);
double templ_norm = 0, templ_sum2 = 0;
int idx = 0, idx2 = 0;
double *p0, *p1, *p2, *p3;
double *q0, *q1, *q2, *q3;
double inv_area;
int sum_step, sqsum_step;
int num_type = method == CV_TM_CCORR || method == CV_TM_CCORR_NORMED ? 0 :
method == CV_TM_CCOEFF || method == CV_TM_CCOEFF_NORMED ? 1 : 2;
int is_normed = method == CV_TM_CCORR_NORMED ||
method == CV_TM_SQDIFF_NORMED ||
method == CV_TM_CCOEFF_NORMED;
img = cvGetMat( img, &stub, &coi1 );
templ = cvGetMat( templ, &tstub, &coi2 );
result = cvGetMat( result, &rstub );
if( CV_MAT_DEPTH( img->type ) != CV_8U &&
CV_MAT_DEPTH( img->type ) != CV_32F )
CV_Error( CV_StsUnsupportedFormat,
"The function supports only 8u and 32f data types" );
if( !CV_ARE_TYPES_EQ( img, templ ))
CV_Error( CV_StsUnmatchedSizes, "image and template should have the same type" );
if( CV_MAT_TYPE( result->type ) != CV_32FC1 )
CV_Error( CV_StsUnsupportedFormat, "output image should have 32f type" );
if( img->rows < templ->rows || img->cols < templ->cols )
{
CvMat* t;
CV_SWAP( img, templ, t );
}
if( result->rows != img->rows - templ->rows + 1 ||
result->cols != img->cols - templ->cols + 1 )
CV_Error( CV_StsUnmatchedSizes, "output image should be (W - w + 1)x(H - h + 1)" );
if( method < CV_TM_SQDIFF || method > CV_TM_CCOEFF_NORMED )
CV_Error( CV_StsBadArg, "unknown comparison method" );
depth = CV_MAT_DEPTH(img->type);
cn = CV_MAT_CN(img->type);
icvCrossCorr( img, templ, result );
if( method == CV_TM_CCORR )
return;
inv_area = 1./((double)templ->rows * templ->cols);
sum = cvCreateMat( img->rows + 1, img->cols + 1, CV_MAKETYPE( CV_64F, cn ));
if( method == CV_TM_CCOEFF )
{
cvIntegral( img, sum, 0, 0 );
templ_mean = cvAvg( templ );
q0 = q1 = q2 = q3 = 0;
}
else
{
CvScalar _templ_sdv = cvScalarAll(0);
sqsum = cvCreateMat( img->rows + 1, img->cols + 1, CV_MAKETYPE( CV_64F, cn ));
cvIntegral( img, sum, sqsum, 0 );
cvAvgSdv( templ, &templ_mean, &_templ_sdv );
templ_norm = CV_SQR(_templ_sdv.val[0]) + CV_SQR(_templ_sdv.val[1]) +
CV_SQR(_templ_sdv.val[2]) + CV_SQR(_templ_sdv.val[3]);
if( templ_norm < DBL_EPSILON && method == CV_TM_CCOEFF_NORMED )
{
cvSet( result, cvScalarAll(1.) );
return;
}
templ_sum2 = templ_norm +
CV_SQR(templ_mean.val[0]) + CV_SQR(templ_mean.val[1]) +
CV_SQR(templ_mean.val[2]) + CV_SQR(templ_mean.val[3]);
if( num_type != 1 )
{
templ_mean = cvScalarAll(0);
templ_norm = templ_sum2;
}
templ_sum2 /= inv_area;
templ_norm = sqrt(templ_norm);
templ_norm /= sqrt(inv_area); // care of accuracy here
q0 = (double*)sqsum->data.ptr;
q1 = q0 + templ->cols*cn;
q2 = (double*)(sqsum->data.ptr + templ->rows*sqsum->step);
q3 = q2 + templ->cols*cn;
}
p0 = (double*)sum->data.ptr;
p1 = p0 + templ->cols*cn;
p2 = (double*)(sum->data.ptr + templ->rows*sum->step);
p3 = p2 + templ->cols*cn;
sum_step = sum ? sum->step / sizeof(double) : 0;
sqsum_step = sqsum ? sqsum->step / sizeof(double) : 0;
for( i = 0; i < result->rows; i++ )
{
float* rrow = (float*)(result->data.ptr + i*result->step);
idx = i * sum_step;
idx2 = i * sqsum_step;
for( j = 0; j < result->cols; j++, idx += cn, idx2 += cn )
{
double num = rrow[j], t;
double wnd_mean2 = 0, wnd_sum2 = 0;
if( num_type == 1 )
{
for( k = 0; k < cn; k++ )
{
t = p0[idx+k] - p1[idx+k] - p2[idx+k] + p3[idx+k];
wnd_mean2 += CV_SQR(t);
num -= t*templ_mean.val[k];
}
wnd_mean2 *= inv_area;
}
if( is_normed || num_type == 2 )
{
for( k = 0; k < cn; k++ )
{
t = q0[idx2+k] - q1[idx2+k] - q2[idx2+k] + q3[idx2+k];
wnd_sum2 += t;
}
if( num_type == 2 )
num = wnd_sum2 - 2*num + templ_sum2;
}
if( is_normed )
{
t = sqrt(MAX(wnd_sum2 - wnd_mean2,0))*templ_norm;
if( fabs(num) < t )
num /= t;
else if( fabs(num) < t*1.125 )
num = num > 0 ? 1 : -1;
else
num = method != CV_TM_SQDIFF_NORMED ? 0 : 1;
}
rrow[j] = (float)num;
}
}
}
double* FeatureManager::getGridMbrmFeature(IplImage* pImage)//\B6\D4һ\B8\F6\CD\F8\B8\F1\C4ڵ\C4ͼ\CF\F1\C7\F8\D3\F2\C7\F3\CC\D8\D5\F7
{
const int MBRMDIM=17;
double* pGridFeature=new double[MBRMDIM];//store 9 color features and 12 texture featuers
//store 9 color moments and 12 texture features
double bSum=0.0,gSum=0.0,rSum=0.0;
IplImage* pGray = cvCreateImage(cvGetSize(pImage),8,1);//get the gray image
cvCvtColor(pImage,pGray,CV_RGB2GRAY);
//get means, standard deviation
CvScalar rectAvg,rectSdv;
cvAvgSdv(pImage,&rectAvg,&rectSdv);
pGridFeature[0]=rectAvg.val[0];//B average
pGridFeature[1]=rectAvg.val[1];//G average
pGridFeature[2]=rectAvg.val[2];//R average
pGridFeature[3]=rectSdv.val[0];//B Standard deviation
pGridFeature[4]=rectSdv.val[1];//G Standard deviation
pGridFeature[5]=rectSdv.val[2];//R Standard deviation
//get skewness
for(int row=0;row!=pImage->height;++row)
{
uchar* ptr=(uchar*)(pImage->imageData+row*pImage->widthStep);
for(int col=0;col!=pImage->width;++col)
{
bSum+=pow(*(ptr+col*3)-rectAvg.val[0],3);
gSum+=pow(*(ptr+col*3+1)-rectAvg.val[1],3);
rSum+=pow(*(ptr+col*3+2)-rectAvg.val[2],3);
}
}
pGridFeature[6]=bSum<0?-pow(1.0/(pImage->width*pImage->height)*(-bSum),1.0/3.0):pow(1.0/(pImage->width*pImage->height)*bSum,1.0/3.0);//B Skewness
pGridFeature[7]=gSum<0?-pow(1.0/(pImage->width*pImage->height)*(-gSum),1.0/3.0):pow(1.0/(pImage->width*pImage->height)*gSum,1.0/3.0);//G Skewness
pGridFeature[8]=rSum<0?-pow(1.0/(pImage->width*pImage->height)*(-rSum),1.0/3.0):pow(1.0/(pImage->width*pImage->height)*rSum,1.0/3.0);//R Skewness
//get Gabor texture feature
//\C9\FA\B3\C9һ\B8\F6Gabor\BA\CB
CvScalar rectGaborAvg;
// CvScalar rectGaborSdv;
double Sigma = 2*PI;
double F = sqrt(2.0);
int cnt=0;
CvGabor* gabor1=NULL;
for(int scale =3;scale<=6;scale+=3)
for (int orientation=0;orientation!=4;++orientation)
{
gabor1 = new CvGabor;
IplImage* reimg = cvCreateImage(cvGetSize(pGray), IPL_DEPTH_8U, 1);
gabor1->Init(PI*orientation/4,/* scale*/3, Sigma, F);
gabor1->conv_img(pGray, reimg, CV_GABOR_REAL);
// cvAvgSdv(reimg,&rectGaborAvg,&rectGaborSdv);
rectGaborAvg=cvAvg(reimg);
cvReleaseImage(&reimg);
pGridFeature[cnt+9]=rectGaborAvg.val[0];
++cnt;
// pGridFeature[cnt+12]=rectGaborSdv.val[0];
delete gabor1;
}
cvReleaseImage(&pGray);
return pGridFeature;
}
/**
*Choose the weak classifier using the fast method just based on the distribution of the weight
*@param data The positive and negative training samples
*@param label the ground truth label of the training samples
*@param current_best_classifier The current weak classifier for selection.
*@param bindexlabel The BOOL value to ensure that each feature can only be choose once
*@param imith To control the shape of the sign function
*@param curIteration The current iteration number of strong classifier
*/
int adaBoostBinary::choosefeature_fast(CvMat *data, CvMat *label, lda_classifier *current_best_classifier,bool *bindexlabel, float imith, int curIteration)
{
int sample_num=pos_sample_num+neg_sample_num;
int size_dim=data->cols;
int paraNum=1;
int numInpara=size_dim/paraNum;
lda_classifier *para_best_classifier = (lda_classifier*)malloc(sizeof(lda_classifier)*paraNum);
CvMat *labelneg=cvCreateMat(sample_num, 1, CV_8UC1);
for(int i=0; i<sample_num; i++){
if(label->data.ptr[i]>0){
labelneg->data.ptr[i]=0;
}
else{
labelneg->data.ptr[i]=1;
}
}
float *para_res=(float*)malloc(sizeof(float)*sample_num*paraNum);
//#pragma omp parallel for
for(int j1=0; j1<paraNum; j1++)
{
para_best_classifier[j1].minerror=-10;
for(int j2=0; j2<numInpara; j2++)
{
int j=j1*numInpara+j2;
// if((j+1)%8<=1) continue;
CvMat *score=cvCreateMat(sample_num,1,CV_32FC1);
///find the current best error and threshold
CvScalar meanpos, meanneg, stdpos, stdneg;
for(int t=0; t<sample_num; t++) score->data.fl[t] = cvmGet(data, t, j);
//printf("arow=%d, acol=%d, brow=%d, bcol=%d\n",score->rows,score->cols,label->rows, label->cols);
cvAvgSdv(score, &meanpos, &stdpos, label);
cvAvgSdv(score, &meanneg, &stdneg, labelneg);
float threshold=0.0;
if(stdpos.val[0]+stdneg.val[0]>0.0) threshold = (meanpos.val[0]*stdneg.val[0]+meanneg.val[0]*stdpos.val[0])/(stdpos.val[0]+stdneg.val[0]);
else threshold = (meanpos.val[0]+meanneg.val[0])/2;
if(threshold==0.0) continue;
float cur_error=0.0;
int thr_sign=1;
if(meanpos.val[0]<meanneg.val[0])
{
thr_sign=-1;
threshold=-threshold;
}
for(int t=0; t<sample_num; t++)
{
float curscore=score->data.fl[t]*thr_sign-threshold;
float htx=curscore/sqrt(curscore*curscore+imith*imith);
cur_error+=weight->data.fl[t]*htx*labelsign[t];
}
if (cur_error> para_best_classifier[j1].minerror&&bindexlabel[j]==false)
{
para_best_classifier[j1].minerror = cur_error;
printf("*%f ",cur_error);
para_best_classifier[j1].bindex = j;
para_best_classifier[j1].pro_thresh = threshold;
para_best_classifier[j1].thr_sign = thr_sign;
// float check_error=0.0f;
for(int t=0;t<sample_num; t++)
{
float curscore=score->data.fl[t]*thr_sign-threshold;
float htx=curscore/sqrt(curscore*curscore+imith*imith);
//para_res[j1*sample_num+t]=curscore/sqrt(curscore*curscore+imith*imith);
para_res[j1*sample_num+t]=htx;
}
}
cvRelease((void **)&score);
}//for para inter pixle j2
}//for para outer pixel j1
for(int i=0; i<paraNum; i++)
{
if(current_best_classifier->minerror>para_best_classifier[i].minerror)
{
current_best_classifier->minerror=para_best_classifier[i].minerror;
current_best_classifier->bindex=para_best_classifier[i].bindex;
current_best_classifier->pro_thresh=para_best_classifier[i].pro_thresh;
current_best_classifier->thr_sign=para_best_classifier[i].thr_sign;
for(int t=0; t<sample_num; t++) iter_res[curIteration*sample_num+t]=para_res[i*sample_num+t];
}
}
bindexlabel[current_best_classifier->bindex]=true;
cvRelease((void **)&labelneg);
free(para_res);
free(para_best_classifier);
return 1;
}
void FaceNormIllu::do_NormIlluRETINA(IplImage *img_64, IplImage *dst, const double Thr){
const CvSize fsize=cvGetSize(img_64);
// IplImage *img_64=cvCreateImage(fsize, IPL_DEPTH_64F, 1);
IplImage *img_gauss_sigma_1=cvCreateImage(fsize, IPL_DEPTH_64F, 1);
IplImage *img_gauss_sigma_2=cvCreateImage(fsize, IPL_DEPTH_64F, 1);
IplImage *F1=cvCreateImage(fsize, IPL_DEPTH_64F, 1);
IplImage *F2=cvCreateImage(fsize, IPL_DEPTH_64F, 1);
IplImage *I_la1=cvCreateImage(fsize, IPL_DEPTH_64F, 1);
IplImage *I_la2=cvCreateImage(fsize, IPL_DEPTH_64F, 1);
IplImage *Ibip=cvCreateImage(fsize, IPL_DEPTH_64F, 1);
//IplImage *Inorm=cvCreateImage(fsize, IPL_DEPTH_64F, 1);
// cvConvert(img, img_64);
//const double mI1=cvMean(img_64)*0.5;
const double mI1 = cvAvg(img_64).val[0] * 0.5;
// NxN, N=6*sigma + 1, where NxN is the gaussian smooth filter
cvSmooth(img_64, img_gauss_sigma_1, CV_GAUSSIAN, 7, 7, 1, 0);
cvAddS(img_gauss_sigma_1, cvScalar(mI1), F1, 0);
double minV, maxV;
cvMinMaxLoc(img_64, 0, &maxV);
// #pragma omp parallel for
for (int i=0; i<fsize.height; i++){
double *ptr_img_64=(double*)(img_64->imageData+i*img_64->widthStep);
double *ptr_F1=(double*)(F1->imageData+i*F1->widthStep);
double *ptr_I_la1=(double*)(I_la1->imageData+i*I_la1->widthStep);
for (int j=0; j<fsize.width; j++){
const double vImg64=ptr_img_64[j];
const double vF1=ptr_F1[j];
ptr_I_la1[j]=(maxV+vF1)*vImg64/(vImg64+vF1);
}
}
cvSmooth(I_la1, img_gauss_sigma_2, CV_GAUSSIAN, 19, 19, 3, 0);
// const double mI2=cvMean(I_la1)*0.5;
const double mI2 = cvAvg(img_64).val[0] * 0.5;
cvAddS(img_gauss_sigma_2, cvScalar(mI2), F2, 0);
cvMinMaxLoc(I_la1, 0, &maxV);
//#pragma omp parallel for
for (int i=0; i<fsize.height; i++){
double *ptr_I_la1=(double*)(I_la1->imageData+i*I_la1->widthStep);
double *ptr_F2=(double*)(F2->imageData+i*F2->widthStep);
double *ptr_I_la2=(double*)(I_la2->imageData+i*I_la2->widthStep);
for (int j=0; j<fsize.width; j++){
const double vI_la1=ptr_I_la1[j];
const double vF2=ptr_F2[j];
ptr_I_la2[j]=(maxV+vF2)*vI_la1/(vI_la1+vF2);
}
}
//// DoG filter, sigma1=0.5, sigma2=4
cvSmooth(I_la2, img_gauss_sigma_1, CV_GAUSSIAN, 3, 3, 0.5, 0);
cvSmooth(I_la2, img_gauss_sigma_2, CV_GAUSSIAN, 25, 25, 4, 0);
cvSub(img_gauss_sigma_1, img_gauss_sigma_2, Ibip,0);
double meanV, stdV;
// cvMean_StdDev(Ibip, &meanV, &stdV, 0);
CvScalar _avgV, _stdV;
cvAvgSdv(Ibip, &_avgV, &_stdV);
meanV = _avgV.val[0];
stdV = _stdV.val[0];
cvConvertScale(Ibip, dst, 1./stdV, 0);
//#pragma omp parallel for
for (int i=0; i<fsize.height; i++){
double *ptr_Inorm=(double*)(dst->imageData+i*dst->widthStep);
for (int j=0; j<fsize.width; j++){
const double vInorm=ptr_Inorm[j];
//printf("%f ",vInorm);
if (vInorm>=0){
ptr_Inorm[j]=MIN(Thr, fabs(vInorm));
}
else{
ptr_Inorm[j]=-MIN(Thr, fabs(vInorm));
}
}
}
// cvReleaseImage(&img_64);
cvReleaseImage(&img_gauss_sigma_1);
cvReleaseImage(&img_gauss_sigma_2);
cvReleaseImage(&F1);
cvReleaseImage(&F2);
cvReleaseImage(&I_la1);
cvReleaseImage(&I_la2);
cvReleaseImage(&Ibip);
// normalizar los valores [0.0, 1.0]
cvMinMaxLoc(dst, &minV, &maxV);
cvSubS(dst, cvScalar(minV), dst);
cvConvertScale(dst, dst, 1.0/(maxV - minV));
}
CV_IMPL void
cvMatchTemplate( const CvArr* _img, const CvArr* _templ, CvArr* _result, int method )
{
CvMat* sum = 0;
CvMat* sqsum = 0;
CV_FUNCNAME( "cvMatchTemplate" );
__BEGIN__;
int coi1 = 0, coi2 = 0;
int depth, cn;
int i, j, k;
CvMat stub, *img = (CvMat*)_img;
CvMat tstub, *templ = (CvMat*)_templ;
CvMat rstub, *result = (CvMat*)_result;
CvScalar templ_mean = cvScalarAll(0);
double templ_norm = 0, templ_sum2 = 0;
int idx = 0, idx2 = 0;
double *p0, *p1, *p2, *p3;
double *q0, *q1, *q2, *q3;
double inv_area;
int sum_step, sqsum_step;
int num_type = method == CV_TM_CCORR || method == CV_TM_CCORR_NORMED ? 0 :
method == CV_TM_CCOEFF || method == CV_TM_CCOEFF_NORMED ? 1 : 2;
int is_normed = method == CV_TM_CCORR_NORMED ||
method == CV_TM_SQDIFF_NORMED ||
method == CV_TM_CCOEFF_NORMED;
CV_CALL( img = cvGetMat( img, &stub, &coi1 ));
CV_CALL( templ = cvGetMat( templ, &tstub, &coi2 ));
CV_CALL( result = cvGetMat( result, &rstub ));
if( CV_MAT_DEPTH( img->type ) != CV_8U &&
CV_MAT_DEPTH( img->type ) != CV_32F )
CV_ERROR( CV_StsUnsupportedFormat,
"The function supports only 8u and 32f data types" );
if( !CV_ARE_TYPES_EQ( img, templ ))
CV_ERROR( CV_StsUnmatchedSizes, "image and template should have the same type" );
if( CV_MAT_TYPE( result->type ) != CV_32FC1 )
CV_ERROR( CV_StsUnsupportedFormat, "output image should have 32f type" );
if( img->rows < templ->rows || img->cols < templ->cols )
{
CvMat* t;
CV_SWAP( img, templ, t );
}
if( result->rows != img->rows - templ->rows + 1 ||
result->cols != img->cols - templ->cols + 1 )
CV_ERROR( CV_StsUnmatchedSizes, "output image should be (W - w + 1)x(H - h + 1)" );
if( method < CV_TM_SQDIFF || method > CV_TM_CCOEFF_NORMED )
CV_ERROR( CV_StsBadArg, "unknown comparison method" );
depth = CV_MAT_DEPTH(img->type);
cn = CV_MAT_CN(img->type);
if( is_normed && cn == 1 && templ->rows > 8 && templ->cols > 8 &&
img->rows > templ->cols && img->cols > templ->cols )
{
CvTemplMatchIPPFunc ipp_func =
depth == CV_8U ?
(method == CV_TM_SQDIFF_NORMED ? (CvTemplMatchIPPFunc)icvSqrDistanceValid_Norm_8u32f_C1R_p :
method == CV_TM_CCORR_NORMED ? (CvTemplMatchIPPFunc)icvCrossCorrValid_Norm_8u32f_C1R_p :
(CvTemplMatchIPPFunc)icvCrossCorrValid_NormLevel_8u32f_C1R_p) :
(method == CV_TM_SQDIFF_NORMED ? (CvTemplMatchIPPFunc)icvSqrDistanceValid_Norm_32f_C1R_p :
method == CV_TM_CCORR_NORMED ? (CvTemplMatchIPPFunc)icvCrossCorrValid_Norm_32f_C1R_p :
(CvTemplMatchIPPFunc)icvCrossCorrValid_NormLevel_32f_C1R_p);
if( ipp_func )
{
CvSize img_size = cvGetMatSize(img), templ_size = cvGetMatSize(templ);
IPPI_CALL( ipp_func( img->data.ptr, img->step ? img->step : CV_STUB_STEP,
img_size, templ->data.ptr,
templ->step ? templ->step : CV_STUB_STEP,
templ_size, result->data.ptr,
result->step ? result->step : CV_STUB_STEP ));
for( i = 0; i < result->rows; i++ )
{
float* rrow = (float*)(result->data.ptr + i*result->step);
for( j = 0; j < result->cols; j++ )
{
if( fabs(rrow[j]) > 1. )
rrow[j] = rrow[j] < 0 ? -1.f : 1.f;
}
}
EXIT;
}
}
CV_CALL( icvCrossCorr( img, templ, result ));
if( method == CV_TM_CCORR )
EXIT;
inv_area = 1./((double)templ->rows * templ->cols);
CV_CALL( sum = cvCreateMat( img->rows + 1, img->cols + 1,
CV_MAKETYPE( CV_64F, cn )));
if( method == CV_TM_CCOEFF )
{
CV_CALL( cvIntegral( img, sum, 0, 0 ));
CV_CALL( templ_mean = cvAvg( templ ));
q0 = q1 = q2 = q3 = 0;
}
else
{
CvScalar _templ_sdv = cvScalarAll(0);
CV_CALL( sqsum = cvCreateMat( img->rows + 1, img->cols + 1,
CV_MAKETYPE( CV_64F, cn )));
CV_CALL( cvIntegral( img, sum, sqsum, 0 ));
CV_CALL( cvAvgSdv( templ, &templ_mean, &_templ_sdv ));
templ_norm = CV_SQR(_templ_sdv.val[0]) + CV_SQR(_templ_sdv.val[1]) +
CV_SQR(_templ_sdv.val[2]) + CV_SQR(_templ_sdv.val[3]);
if( templ_norm < DBL_EPSILON && method == CV_TM_CCOEFF_NORMED )
{
cvSet( result, cvScalarAll(1.) );
EXIT;
}
templ_sum2 = templ_norm +
CV_SQR(templ_mean.val[0]) + CV_SQR(templ_mean.val[1]) +
CV_SQR(templ_mean.val[2]) + CV_SQR(templ_mean.val[3]);
if( num_type != 1 )
{
templ_mean = cvScalarAll(0);
templ_norm = templ_sum2;
}
templ_sum2 /= inv_area;
templ_norm = sqrt(templ_norm);
templ_norm /= sqrt(inv_area); // care of accuracy here
q0 = (double*)sqsum->data.ptr;
q1 = q0 + templ->cols*cn;
q2 = (double*)(sqsum->data.ptr + templ->rows*sqsum->step);
q3 = q2 + templ->cols*cn;
}
p0 = (double*)sum->data.ptr;
p1 = p0 + templ->cols*cn;
p2 = (double*)(sum->data.ptr + templ->rows*sum->step);
p3 = p2 + templ->cols*cn;
sum_step = sum ? sum->step / sizeof(double) : 0;
sqsum_step = sqsum ? sqsum->step / sizeof(double) : 0;
for( i = 0; i < result->rows; i++ )
{
float* rrow = (float*)(result->data.ptr + i*result->step);
idx = i * sum_step;
idx2 = i * sqsum_step;
for( j = 0; j < result->cols; j++, idx += cn, idx2 += cn )
{
double num = rrow[j], t;
double wnd_mean2 = 0, wnd_sum2 = 0;
if( num_type == 1 )
{
for( k = 0; k < cn; k++ )
{
t = p0[idx+k] - p1[idx+k] - p2[idx+k] + p3[idx+k];
wnd_mean2 += CV_SQR(t);
num -= t*templ_mean.val[k];
}
wnd_mean2 *= inv_area;
}
if( is_normed || num_type == 2 )
{
for( k = 0; k < cn; k++ )
{
t = q0[idx2+k] - q1[idx2+k] - q2[idx2+k] + q3[idx2+k];
wnd_sum2 += t;
}
if( num_type == 2 )
num = wnd_sum2 - 2*num + templ_sum2;
}
if( is_normed )
{
t = sqrt(MAX(wnd_sum2 - wnd_mean2,0))*templ_norm;
if( t > DBL_EPSILON )
{
num /= t;
if( fabs(num) > 1. )
num = num > 0 ? 1 : -1;
}
else
num = method != CV_TM_SQDIFF_NORMED || num < DBL_EPSILON ? 0 : 1;
}
rrow[j] = (float)num;
}
}
__END__;
cvReleaseMat( &sum );
cvReleaseMat( &sqsum );
}
