void CV_PyrSegmentationTest::run( int /*start_from*/ ) { const int level = 5; const double range = 20; int code = CvTS::OK; CvPoint _cp[] ={{33,33}, {43,33}, {43,43}, {33,43}}; CvPoint _cp2[] ={{50,50}, {70,50}, {70,70}, {50,70}}; CvPoint* cp = _cp; CvPoint* cp2 = _cp2; CvConnectedComp *dst_comp[3]; CvRect rect[3] = {{50,50,21,21}, {0,0,128,128}, {33,33,11,11}}; double a[3] = {441.0, 15822.0, 121.0}; /* ippiPoint cp3[] ={130,130, 150,130, 150,150, 130,150}; */ /* CvPoint cp[] ={0,0, 5,5, 5,0, 10,5, 10,0, 15,5, 15,0}; */ int nPoints = 4; int block_size = 1000; CvMemStorage *storage; /* storage for connected component writing */ CvSeq *comp; CvRNG* rng = ts->get_rng(); int i, j, iter; IplImage *image, *image_f, *image_s; CvSize size = {128, 128}; const int threshold1 = 50, threshold2 = 50; rect[1].width = size.width; rect[1].height = size.height; a[1] = size.width*size.height - a[0] - a[2]; OPENCV_CALL( storage = cvCreateMemStorage( block_size ) ); for( iter = 0; iter < 2; iter++ ) { int channels = iter == 0 ? 1 : 3; int mask[] = {0,0,0}; image = cvCreateImage(size, 8, channels ); image_s = cvCloneImage( image ); image_f = cvCloneImage( image ); if( channels == 1 ) { int color1 = 30, color2 = 110, color3 = 180; cvSet( image, cvScalarAll(color1)); cvFillPoly( image, &cp, &nPoints, 1, cvScalar(color2)); cvFillPoly( image, &cp2, &nPoints, 1, cvScalar(color3)); } else { CvScalar color1 = CV_RGB(30,30,30), color2 = CV_RGB(255,0,0), color3 = CV_RGB(0,255,0); assert( channels == 3 ); cvSet( image, color1 ); cvFillPoly( image, &cp, &nPoints, 1, color2); cvFillPoly( image, &cp2, &nPoints, 1, color3); } cvRandArr( rng, image_f, CV_RAND_UNI, cvScalarAll(0), cvScalarAll(range*2) ); cvAddWeighted( image, 1, image_f, 1, -range, image_f ); cvPyrSegmentation( image_f, image_s, storage, &comp, level, threshold1, threshold2 ); if(comp->total != 3) { ts->printf( CvTS::LOG, "The segmentation function returned %d (not 3) components\n", comp->total ); code = CvTS::FAIL_INVALID_OUTPUT; goto _exit_; } /* read the connected components */ dst_comp[0] = (CvConnectedComp*)CV_GET_SEQ_ELEM( CvConnectedComp, comp, 0 ); dst_comp[1] = (CvConnectedComp*)CV_GET_SEQ_ELEM( CvConnectedComp, comp, 1 ); dst_comp[2] = (CvConnectedComp*)CV_GET_SEQ_ELEM( CvConnectedComp, comp, 2 ); /*{ for( i = 0; i < 3; i++ ) { CvRect r = dst_comp[i]->rect; cvRectangle( image_s, cvPoint(r.x,r.y), cvPoint(r.x+r.width,r.y+r.height), CV_RGB(255,255,255), 3, 8, 0 ); } cvNamedWindow( "test", 1 ); cvShowImage( "test", image_s ); cvWaitKey(0); }*/ code = cvTsCmpEps2( ts, image, image_s, 10, false, "the output image" ); if( code < 0 ) goto _exit_; for( i = 0; i < 3; i++) { for( j = 0; j < 3; j++ ) { if( !mask[j] && dst_comp[i]->area == a[j] && dst_comp[i]->rect.x == rect[j].x && dst_comp[i]->rect.y == rect[j].y && dst_comp[i]->rect.width == rect[j].width && dst_comp[i]->rect.height == rect[j].height ) { mask[j] = 1; break; } } if( j == 3 ) { ts->printf( CvTS::LOG, "The component #%d is incorrect\n", i ); code = CvTS::FAIL_BAD_ACCURACY; goto _exit_; } } cvReleaseImage(&image_f); cvReleaseImage(&image); cvReleaseImage(&image_s); } _exit_: cvReleaseMemStorage( &storage ); cvReleaseImage(&image_f); cvReleaseImage(&image); cvReleaseImage(&image_s); if( code < 0 ) ts->set_failed_test_info( code ); }
/* ///////////////////// chess_corner_test ///////////////////////// */ void CV_ChessboardDetectorTimingTest::run( int start_from ) { int code = cvtest::TS::OK; /* test parameters */ std::string filepath; std::string filename; CvMat* _v = 0; CvPoint2D32f* v; IplImage img; IplImage* gray = 0; IplImage* thresh = 0; int idx, max_idx; int progress = 0; filepath = cv::format("%scv/cameracalibration/", ts->get_data_path().c_str() ); filename = cv::format("%schessboard_timing_list.dat", filepath.c_str() ); CvFileStorage* fs = cvOpenFileStorage( filename.c_str(), 0, CV_STORAGE_READ ); CvFileNode* board_list = fs ? cvGetFileNodeByName( fs, 0, "boards" ) : 0; if( !fs || !board_list || !CV_NODE_IS_SEQ(board_list->tag) || board_list->data.seq->total % 4 != 0 ) { ts->printf( cvtest::TS::LOG, "chessboard_timing_list.dat can not be readed or is not valid" ); code = cvtest::TS::FAIL_MISSING_TEST_DATA; goto _exit_; } max_idx = board_list->data.seq->total/4; for( idx = start_from; idx < max_idx; idx++ ) { int count0 = -1; int count = 0; CvSize pattern_size; int result, result1 = 0; const char* imgname = cvReadString((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*4), "dummy.txt"); int is_chessboard = cvReadInt((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*4+1), 0); pattern_size.width = cvReadInt((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*4 + 2), -1); pattern_size.height = cvReadInt((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*4 + 3), -1); ts->update_context( this, idx-1, true ); /* read the image */ filename = cv::format("%s%s", filepath.c_str(), imgname ); cv::Mat img2 = cv::imread( filename ); img = img2; if( img2.empty() ) { ts->printf( cvtest::TS::LOG, "one of chessboard images can't be read: %s\n", filename.c_str() ); code = cvtest::TS::FAIL_MISSING_TEST_DATA; continue; } ts->printf(cvtest::TS::LOG, "%s: chessboard %d:\n", imgname, is_chessboard); gray = cvCreateImage( cvSize( img.width, img.height ), IPL_DEPTH_8U, 1 ); thresh = cvCreateImage( cvSize( img.width, img.height ), IPL_DEPTH_8U, 1 ); cvCvtColor( &img, gray, CV_BGR2GRAY ); count0 = pattern_size.width*pattern_size.height; /* allocate additional buffers */ _v = cvCreateMat(1, count0, CV_32FC2); count = count0; v = (CvPoint2D32f*)_v->data.fl; int64 _time0 = cvGetTickCount(); result = cvCheckChessboard(gray, pattern_size); int64 _time01 = cvGetTickCount(); OPENCV_CALL( result1 = cvFindChessboardCorners( gray, pattern_size, v, &count, 15 )); int64 _time1 = cvGetTickCount(); if( result != is_chessboard ) { ts->printf( cvtest::TS::LOG, "Error: chessboard was %sdetected in the image %s\n", result ? "" : "not ", imgname ); code = cvtest::TS::FAIL_INVALID_OUTPUT; goto _exit_; } if(result != result1) { ts->printf( cvtest::TS::LOG, "Warning: results differ cvCheckChessboard %d, cvFindChessboardCorners %d\n", result, result1); } int num_pixels = gray->width*gray->height; float check_chessboard_time = float(_time01 - _time0)/(float)cvGetTickFrequency(); // in us ts->printf(cvtest::TS::LOG, " cvCheckChessboard time s: %f, us per pixel: %f\n", check_chessboard_time*1e-6, check_chessboard_time/num_pixels); float find_chessboard_time = float(_time1 - _time01)/(float)cvGetTickFrequency(); ts->printf(cvtest::TS::LOG, " cvFindChessboard time s: %f, us per pixel: %f\n", find_chessboard_time*1e-6, find_chessboard_time/num_pixels); cvReleaseMat( &_v ); cvReleaseImage( &gray ); cvReleaseImage( &thresh ); progress = update_progress( progress, idx-1, max_idx, 0 ); } _exit_: /* release occupied memory */ cvReleaseMat( &_v ); cvReleaseFileStorage( &fs ); cvReleaseImage( &gray ); cvReleaseImage( &thresh ); if( code < 0 ) ts->set_failed_test_info( code ); }
static int aGestureRecognition(void) { IplImage *image, *imagew, *image_rez, *mask_rez, *image_hsv, *img_p[2],*img_v, *init_mask_ver = 0, *final_mask_ver = 0; CvPoint3D32f *pp, p; CvPoint pt; CvSize2D32f fsize; CvPoint3D32f center, cf; IplImage *image_mask, *image_maskw; CvSize size; CvHistogram *hist, *hist_mask; int width, height; int k_points, k_indexs; int warpFlag, interpolate; int hdim[2] = {20, 20}; double coeffs[3][3], rect[2][2], rez = 0, eps_rez = 2.5, rez_h; float *thresh[2]; float hv[3]; float reps, aeps, ww; float line[6], in[3][3], h[3][3]; float cx, cy, fx, fy; static char num[4]; char *name_image; char *name_range_image; char *name_verify_data; char *name_init_mask_very; char *name_final_mask_very; CvSeq *numbers; CvSeq *points; CvSeq *indexs; CvMemStorage *storage; CvRect hand_roi, hand_roi_trans; int i,j, lsize, block_size = 1000, flag; int code; FILE *filin, *fil_ver; /* read tests params */ code = TRS_OK; /* define input information */ strcpy (num, "001"); lsize = strlen(data_path)+12; name_verify_data = (char*)trsmAlloc(lsize); name_range_image = (char*)trsmAlloc(lsize); name_image = (char*)trsmAlloc(lsize); name_init_mask_very = (char*)trsmAlloc(lsize); name_final_mask_very = (char*)trsmAlloc(lsize); /* define input range_image file path */ strcpy(name_range_image, data_path); strcat(name_range_image, "rpts"); strcat(name_range_image, num); strcat(name_range_image, ".txt"); /* define input image file path */ strcpy(name_image, data_path); strcat(name_image, "real"); strcat(name_image, num); strcat(name_image, ".bmp"); /* define verify data file path */ strcpy(name_verify_data, data_path); strcat(name_verify_data, "very"); strcat(name_verify_data, num); strcat(name_verify_data, ".txt"); /* define verify init mask file path */ strcpy(name_init_mask_very, data_path); strcat(name_init_mask_very, "imas"); strcat(name_init_mask_very, num); strcat(name_init_mask_very, ".bmp"); /* define verify final mask file path */ strcpy(name_final_mask_very, data_path); strcat(name_final_mask_very, "fmas"); strcat(name_final_mask_very, num); strcat(name_final_mask_very, ".bmp"); filin = fopen(name_range_image,"r"); fil_ver = fopen(name_verify_data,"r"); fscanf( filin, "\n%d %d\n", &width, &height); printf("width=%d height=%d reading testing data...", width,height); OPENCV_CALL( storage = cvCreateMemStorage ( block_size ) ); OPENCV_CALL( points = cvCreateSeq( CV_SEQ_POINT3D_SET, sizeof(CvSeq), sizeof(CvPoint3D32f), storage ) ); OPENCV_CALL (indexs = cvCreateSeq( CV_SEQ_POINT_SET, sizeof(CvSeq), sizeof(CvPoint), storage ) ); pp = 0; /* read input image from file */ image = atsCreateImageFromFile( name_image ); if(image == NULL) {code = TRS_FAIL; goto m_exit;} /* read input 3D points from input file */ for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { fscanf( filin, "%f %f %f\n", &p.x, &p.y, &p.z); if(/*p.x != 0 || p.y != 0 ||*/ p.z != 0) { OPENCV_CALL(cvSeqPush(points, &p)); pt.x = j; pt.y = i; OPENCV_CALL(cvSeqPush(indexs, &pt)); } } } k_points = points->total; k_indexs = indexs->total; /* convert sequence to array */ pp = (CvPoint3D32f*)trsmAlloc(k_points * sizeof(CvPoint3D32f)); OPENCV_CALL(cvCvtSeqToArray(points, pp )); /* find 3D-line */ reps = (float)0.1; aeps = (float)0.1; ww = (float)0.08; OPENCV_CALL( cvFitLine3D(pp, k_points, CV_DIST_WELSCH, &ww, reps, aeps, line )); /* find hand location */ flag = -1; fsize.width = fsize.height = (float)0.22; // (hand size in m) numbers = NULL; OPENCV_CALL( cvFindHandRegion (pp, k_points, indexs,line, fsize, flag,¢er,storage, &numbers)); /* read verify data */ fscanf( fil_ver, "%f %f %f\n", &cf.x, &cf.y, &cf.z); rez+= cvSqrt((center.x - cf.x)*(center.x - cf.x)+(center.y - cf.y)*(center.y - cf.y)+ (center.z - cf.z)*(center.z - cf.z))/3.; /* create hand mask */ size.height = height; size.width = width; OPENCV_CALL( image_mask = cvCreateImage(size, IPL_DEPTH_8U, 1) ); OPENCV_CALL( cvCreateHandMask(numbers, image_mask, &hand_roi) ); /* read verify initial image mask */ init_mask_ver = atsCreateImageFromFile( name_init_mask_very ); if(init_mask_ver == NULL) {code = TRS_FAIL; goto m_exit;} rez+= iplNorm(init_mask_ver, image_mask, IPL_L2) / (width*height+0.); /* calculate homographic transformation matrix */ cx = (float)(width / 2.); cy = (float)(height / 2.); fx = fy = (float)571.2048; /* define intrinsic camera parameters */ in[0][1] = in[1][0] = in[2][0] = in[2][1] = 0; in[0][0] = fx; in[0][2] = cx; in[1][1] = fy; in[1][2] = cy; in[2][2] = 1; OPENCV_CALL( cvCalcImageHomography(line, ¢er, in, h) ); rez_h = 0; for(i=0;i<3;i++) { fscanf( fil_ver, "%f %f %f\n", &hv[0], &hv[1], &hv[2]); for(j=0;j<3;j++) { rez_h+=(hv[j] - h[i][j])*(hv[j] - h[i][j]); } } rez+=sqrt(rez_h)/9.; /* image unwarping */ size.width = image->width; size.height = image->height; OPENCV_CALL( imagew = cvCreateImage(size, IPL_DEPTH_8U,3) ); OPENCV_CALL( image_maskw = cvCreateImage(size, IPL_DEPTH_8U,1) ); iplSet(image_maskw, 0); cvSetImageROI(image, hand_roi); cvSetImageROI(image_mask, hand_roi); /* convert homographic transformation matrix from float to double */ for(i=0;i<3;i++) for(j=0;j<3;j++) coeffs[i][j] = (double)h[i][j]; /* get bounding rectangle for image ROI */ iplGetPerspectiveBound(image, coeffs, rect); width = (int)(rect[1][0] - rect[0][0]); height = (int)(rect[1][1] - rect[0][1]); hand_roi_trans.x = (int)rect[0][0];hand_roi_trans.y = (int)rect[0][1]; hand_roi_trans.width = width; hand_roi_trans.height = height; cvMaxRect(&hand_roi, &hand_roi_trans, &hand_roi); iplSetROI((IplROI*)image->roi, 0, hand_roi.x, hand_roi.y, hand_roi.width,hand_roi.height); iplSetROI((IplROI*)image_mask->roi, 0, hand_roi.x, hand_roi.y, hand_roi.width,hand_roi.height); warpFlag = IPL_WARP_R_TO_Q; /* interpolate = IPL_INTER_CUBIC; */ /* interpolate = IPL_INTER_NN; */ interpolate = IPL_INTER_LINEAR; iplWarpPerspective(image, imagew, coeffs, warpFlag, interpolate); iplWarpPerspective(image_mask, image_maskw, coeffs, warpFlag, IPL_INTER_NN); /* set new image and mask ROI after transformation */ iplSetROI((IplROI*)imagew->roi,0, (int)rect[0][0], (int)rect[0][1],(int)width,(int)height); iplSetROI((IplROI*)image_maskw->roi,0, (int)rect[0][0], (int)rect[0][1],(int)width,(int)height); /* copy image ROI to new image and resize */ size.width = width; size.height = height; image_rez = cvCreateImage(size, IPL_DEPTH_8U,3); mask_rez = cvCreateImage(size, IPL_DEPTH_8U,1); iplCopy(imagew,image_rez); iplCopy(image_maskw,mask_rez); /* convert rezult image from RGB to HSV */ image_hsv = iplCreateImageHeader(3, 0, IPL_DEPTH_8U, "HSV", "HSV", IPL_DATA_ORDER_PIXEL, IPL_ORIGIN_TL,IPL_ALIGN_DWORD, image_rez->width, image_rez->height, NULL, NULL, NULL, NULL); iplAllocateImage(image_hsv, 0, 0 ); strcpy(image_rez->colorModel, "RGB"); strcpy(image_rez->channelSeq, "RGB"); image_rez->roi = NULL; iplRGB2HSV(image_rez, image_hsv); /* convert to three images planes */ img_p[0] = cvCreateImage(size, IPL_DEPTH_8U,1); img_p[1] = cvCreateImage(size, IPL_DEPTH_8U,1); img_v = cvCreateImage(size, IPL_DEPTH_8U,1); cvCvtPixToPlane(image_hsv, img_p[0], img_p[1], img_v, NULL); /* calculate histograms */ hist = cvCreateHist ( 2, hdim, CV_HIST_ARRAY); hist_mask = cvCreateHist ( 2, hdim, CV_HIST_ARRAY); /* install histogram threshold */ thresh[0] = (float*) trsmAlloc(2*sizeof(float)); thresh[1] = (float*) trsmAlloc(2*sizeof(float)); thresh[0][0] = thresh[1][0] = -0.5; thresh[0][1] = thresh[1][1] = 255.5; cvSetHistThresh( hist, thresh, 1); cvSetHistThresh( hist_mask, thresh, 1); cvCalcHist(img_p, hist, 0); cvCalcHistMask(img_p, mask_rez, hist_mask, 0); cvCalcProbDensity(hist, hist_mask, hist_mask); cvCalcBackProject( img_p, mask_rez, hist_mask ); /* read verify final image mask */ final_mask_ver = atsCreateImageFromFile( name_final_mask_very ); if(final_mask_ver == NULL) {code = TRS_FAIL; goto m_exit;} rez+= iplNorm(final_mask_ver, mask_rez, IPL_L2) / (width*height+0.); trsWrite( ATS_CON | ATS_SUM, "\n gesture recognition \n"); trsWrite( ATS_CON | ATS_SUM, "result testing error = %f \n",rez); if(rez > eps_rez) code = TRS_FAIL; else code = TRS_OK; m_exit: cvReleaseImage(&image_mask); cvReleaseImage(&mask_rez); cvReleaseImage(&image_rez); atsReleaseImage(final_mask_ver); atsReleaseImage(init_mask_ver); cvReleaseImage(&imagew); cvReleaseImage(&image_maskw); cvReleaseImage(&img_p[0]); cvReleaseImage(&img_p[1]); cvReleaseImage(&img_v); cvReleaseHist( &hist); cvReleaseHist( &hist_mask); cvReleaseMemStorage ( &storage ); trsFree(pp); trsFree(name_final_mask_very); trsFree(name_init_mask_very); trsFree(name_image); trsFree(name_range_image); trsFree(name_verify_data); fclose(filin); fclose(fil_ver); /* _getch(); */ return code; }
static int aPyrSegmentation(void* agr) { CvPoint _cp[] ={33,33, 43,33, 43,43, 33,43}; CvPoint _cp2[] ={50,50, 70,50, 70,70, 50,70}; CvPoint* cp = _cp; CvPoint* cp2 = _cp2; CvConnectedComp *dst_comp[3]; CvRect rect[3] = {50,50,21,21, 0,0,128,128, 33,33,11,11}; double a[3] = {441.0, 15822.0, 121.0}; /* ippiPoint cp3[] ={130,130, 150,130, 150,150, 130,150}; */ /* CvPoint cp[] ={0,0, 5,5, 5,0, 10,5, 10,0, 15,5, 15,0}; */ int chanels = (int)agr; /* number of the color chanels */ int width = 128; int height = 128; int nPoints = 4; int block_size = 1000; int color1 = 30, color2 = 110, color3 = 180; int level = 5; long diff, l; int code; CvMemStorage *storage; /* storage for connected component writing */ CvSeq *comp; double lower, upper; unsigned seed; char rand; AtsRandState state; int i,j; IplImage *image, *image_f, *image_s; CvSize size; uchar *f_cur, *f_row; uchar *row; uchar *cur; int threshold1, threshold2; code = TRS_OK; if(chanels != 1 && chanels != 3) return TRS_UNDEF; /* read tests params */ if(!trsiRead( &width, "128", "image width" )) return TRS_UNDEF; if(!trsiRead( &height, "128", "image height" )) return TRS_UNDEF; if(!trsiRead( &level, "5", "pyramid level" )) return TRS_UNDEF; /* create Image */ l = width*height; size.width = width; size.height = height; rect[1].height = height; rect[1].width = width; a[1] = l - a[0] - a[2]; image = cvCreateImage(cvSize(size.width, size.height), IPL_DEPTH_8U, chanels); image_s = cvCreateImage(cvSize(size.width, size.height), IPL_DEPTH_8U, chanels); memset(image->imageData, color1, chanels*l); image_f = cvCreateImage(cvSize(size.width, size.height), IPL_DEPTH_8U, chanels); OPENCV_CALL( storage = cvCreateMemStorage( block_size ) ); /* do noise */ upper = 20; lower = -upper; seed = 345753; atsRandInit( &state, lower, upper, seed ); /* segmentation by pyramid */ threshold1 = 50; threshold2 = 50; switch(chanels) { case 1: { cvFillPoly( image, &cp, &nPoints, 1, color2); cvFillPoly( image, &cp2, &nPoints, 1, color3); row = (uchar*)image->imageData; f_row = (uchar*)image_f->imageData; for(i = 0; i<size.height; i++) { cur = row; f_cur = f_row; for(j = 0; j<size.width; j++) { atsbRand8s( &state, &rand, 1); *(f_cur)=(uchar)((*cur) + rand); cur++; f_cur++; } row+=image->widthStep; f_row+=image_f->widthStep; } cvPyrSegmentation( image_f, image_s, storage, &comp, level, threshold1, threshold2 ); //if(comp->total != 3) { code = TRS_FAIL; goto exit; } /* read the connected components */ /*dst_comp[0] = (CvConnectedComp*)CV_GET_SEQ_ELEM( CvConnectedComp, comp, 0 ); dst_comp[1] = (CvConnectedComp*)CV_GET_SEQ_ELEM( CvConnectedComp, comp, 1 ); dst_comp[2] = (CvConnectedComp*)CV_GET_SEQ_ELEM( CvConnectedComp, comp, 2 );*/ break; } case 3: { cvFillPoly( image, &cp, &nPoints, 1, CV_RGB(color2,color2,color2)); cvFillPoly( image, &cp2, &nPoints, 1, CV_RGB(color3,color3,color3)); row = (uchar*)image->imageData; f_row = (uchar*)image_f->imageData; for(i = 0; i<size.height; i++) { cur = row; f_cur = f_row; for(j = 0; j<size.width; j++) { atsbRand8s( &state, &rand, 1); *(f_cur)=(uchar)((*cur) + rand); atsbRand8s( &state, &rand, 1); *(f_cur+1)=(uchar)(*(cur+1) + rand); atsbRand8s( &state, &rand, 1); *(f_cur+2)=(uchar)(*(cur+2) + rand); cur+=3; f_cur+=3; } row+=image->widthStep; f_row+=image_f->widthStep; } cvPyrSegmentation(image_f, image_s, storage, &comp, level, threshold1, threshold2); /* read the connected components */ if(comp->total != 3) { code = TRS_FAIL; goto exit; } dst_comp[0] = (CvConnectedComp*)CV_GET_SEQ_ELEM( CvConnectedComp, comp, 0 ); dst_comp[1] = (CvConnectedComp*)CV_GET_SEQ_ELEM( CvConnectedComp, comp, 1 ); dst_comp[2] = (CvConnectedComp*)CV_GET_SEQ_ELEM( CvConnectedComp, comp, 2 ); break; } } diff = 0; /*diff = atsCompare1Db( (uchar*)image->imageData, (uchar*)image_s->imageData, chanels*l, 4); for(i = 0; i < 3; i++) { if(dst_comp[i]->area != a[i]) diff++; if(dst_comp[i]->rect.x != rect[i].x) diff++; if(dst_comp[i]->rect.y != rect[i].y) diff++; if(dst_comp[i]->rect.width != rect[i].width) diff++; if(dst_comp[i]->rect.height != rect[i].height) diff++; }*/ trsWrite( ATS_CON | ATS_LST | ATS_SUM, "upper =%f diff =%ld \n",upper, diff); if(diff > 0 ) code = TRS_FAIL; else code = TRS_OK; exit: cvReleaseMemStorage( &storage ); cvReleaseImage(&image_f); cvReleaseImage(&image); cvReleaseImage(&image_s); /* trsFree(cp); */ /* _getch(); */ return code; }
/* ///////////////////// chess_corner_test ///////////////////////// */ void CV_ChessboardDetectorTest::run( int start_from ) { int code = CvTS::OK; #ifndef WRITE_POINTS const double rough_success_error_level = 2.5; const double precise_success_error_level = 0.2; double err = 0, max_rough_error = 0, max_precise_error = 0; #endif /* test parameters */ char filepath[1000]; char filename[1000]; CvMat* _u = 0; CvMat* _v = 0; CvPoint2D32f* u; CvPoint2D32f* v; IplImage* img = 0; IplImage* gray = 0; IplImage* thresh = 0; int idx, max_idx; int progress = 0; sprintf( filepath, "%scameracalibration/", ts->get_data_path() ); sprintf( filename, "%schessboard_list.dat", filepath ); CvFileStorage* fs = cvOpenFileStorage( filename, 0, CV_STORAGE_READ ); CvFileNode* board_list = fs ? cvGetFileNodeByName( fs, 0, "boards" ) : 0; if( !fs || !board_list || !CV_NODE_IS_SEQ(board_list->tag) || board_list->data.seq->total % 2 != 0 ) { ts->printf( CvTS::LOG, "chessboard_list.dat can not be readed or is not valid" ); code = CvTS::FAIL_MISSING_TEST_DATA; goto _exit_; } max_idx = board_list->data.seq->total/2; for( idx = start_from; idx < max_idx; idx++ ) { int etalon_count = -1; int count = 0; CvSize etalon_size = { -1, -1 }; int j, result; ts->update_context( this, idx-1, true ); /* read the image */ sprintf( filename, "%s%s", filepath, cvReadString((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*2),"dummy.txt")); img = cvLoadImage( filename ); if( !img ) { ts->printf( CvTS::LOG, "one of chessboard images can't be read: %s", filename ); if( max_idx == 1 ) { code = CvTS::FAIL_MISSING_TEST_DATA; goto _exit_; } continue; } gray = cvCreateImage( cvSize( img->width, img->height ), IPL_DEPTH_8U, 1 ); thresh = cvCreateImage( cvSize( img->width, img->height ), IPL_DEPTH_8U, 1 ); cvCvtColor( img, gray, CV_BGR2GRAY ); sprintf( filename, "%s%s", filepath, cvReadString((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*2+1),"dummy.txt")); _u = (CvMat*)cvLoad( filename ); if( _u == 0 ) { if( idx == 0 ) ts->printf( CvTS::LOG, "one of chessboard corner files can't be read: %s", filename ); if( max_idx == 1 ) { code = CvTS::FAIL_MISSING_TEST_DATA; goto _exit_; } continue; } etalon_size.width = _u->cols; etalon_size.height = _u->rows; etalon_count = etalon_size.width*etalon_size.height; /* allocate additional buffers */ _v = cvCloneMat( _u ); count = etalon_count; u = (CvPoint2D32f*)_u->data.fl; v = (CvPoint2D32f*)_v->data.fl; OPENCV_CALL( result = cvFindChessBoardCornerGuesses( gray, thresh, 0, etalon_size, v, &count )); //show_points( gray, 0, etalon_count, v, count, etalon_size, result ); if( !result || count != etalon_count ) { ts->printf( CvTS::LOG, "chess board is not found" ); code = CvTS::FAIL_INVALID_OUTPUT; goto _exit_; } #ifndef WRITE_POINTS err = 0; for( j = 0; j < etalon_count; j++ ) { double dx = fabs( v[j].x - u[j].x ); double dy = fabs( v[j].y - u[j].y ); dx = MAX( dx, dy ); if( dx > err ) { err = dx; if( err > rough_success_error_level ) { ts->printf( CvTS::LOG, "bad accuracy of corner guesses" ); code = CvTS::FAIL_BAD_ACCURACY; goto _exit_; } } } max_rough_error = MAX( max_rough_error, err ); #endif OPENCV_CALL( cvFindCornerSubPix( gray, v, count, cvSize( 5, 5 ), cvSize(-1,-1), cvTermCriteria(CV_TERMCRIT_EPS|CV_TERMCRIT_ITER,30,0.1))); //show_points( gray, u + 1, etalon_count, v, count ); #ifndef WRITE_POINTS err = 0; for( j = 0; j < etalon_count; j++ ) { double dx = fabs( v[j].x - u[j].x ); double dy = fabs( v[j].y - u[j].y ); dx = MAX( dx, dy ); if( dx > err ) { err = dx; if( err > precise_success_error_level ) { ts->printf( CvTS::LOG, "bad accuracy of adjusted corners" ); code = CvTS::FAIL_BAD_ACCURACY; goto _exit_; } } } max_precise_error = MAX( max_precise_error, err ); #else cvSave( filename, _v ); #endif cvReleaseMat( &_u ); cvReleaseMat( &_v ); cvReleaseImage( &img ); cvReleaseImage( &gray ); cvReleaseImage( &thresh ); progress = update_progress( progress, idx-1, max_idx, 0 ); } _exit_: /* release occupied memory */ cvReleaseMat( &_u ); cvReleaseMat( &_v ); cvReleaseFileStorage( &fs ); cvReleaseImage( &img ); cvReleaseImage( &gray ); cvReleaseImage( &thresh ); if( code < 0 ) ts->set_failed_test_info( code ); }