void kinect_depth_handler (carmen_kinect_depth_message *kinect_depth_message) { char *depth_img_filename, *depth_rgb_filename; char *depth_img_composed_path, *depth_rgb_composed_path; IplImage *depth_img, *depth_rgb_img; create_kinect_depth_img_filename_from_timestamp(message_index, &depth_img_filename); create_kinect_rgb_depth_img_filename_from_timestamp(message_index, &depth_rgb_filename); compose_output_path(output_dir_name, depth_img_filename, &depth_img_composed_path); compose_output_path(output_dir_name, depth_rgb_filename, &depth_rgb_composed_path); create_image_from_depth_buffer(kinect_depth_message->depth, &depth_img, kinect_depth_message->size, kinect_depth_message->height, kinect_depth_message->width); create_rgb_image_from_depth_buffer(kinect_depth_message->depth, &depth_rgb_img, kinect_depth_message->height, kinect_depth_message->width); cvSaveImage(depth_img_composed_path, depth_img, NULL); cvSaveImage(depth_rgb_composed_path, depth_rgb_img, NULL); printf("depth image saved: %s\n", depth_img_composed_path); free(depth_img_filename); free(depth_rgb_filename); free(depth_img_composed_path); free(depth_rgb_composed_path); cvRelease((void**) &depth_img); cvRelease((void**) &depth_rgb_img); message_index++; }
void save_image_to_file(carmen_bumblebee_basic_stereoimage_message *stereo_image, int camera) { char *left_img_filename, *right_img_filename; char *left_composed_path, *right_composed_path; IplImage *left_img, *right_img; create_stereo_filename_from_timestamp(stereo_image->timestamp, &left_img_filename, &right_img_filename, camera); compose_output_path(output_dir_name, left_img_filename, &left_composed_path); compose_output_path(output_dir_name, right_img_filename, &right_composed_path); create_image_from_rgb_buffer(stereo_image->raw_left, &left_img, stereo_image->width, stereo_image->height); create_image_from_rgb_buffer(stereo_image->raw_right, &right_img, stereo_image->width, stereo_image->height); cvSaveImage(left_composed_path, left_img, NULL); cvSaveImage(right_composed_path, right_img, NULL); printf("left image saved: %s\n", left_composed_path); printf("right image saved: %s\n", right_composed_path); free(left_img_filename); free(left_composed_path); free(right_img_filename); free(right_composed_path); cvRelease((void**) &left_img); cvRelease((void**) &right_img); }
void save_stereo_image_to_file(carmen_simple_stereo_disparity_message *stereo_message, int camera) { stereo_util util = get_stereo_instance(camera, 0, 0); char *disparity_img_filename, *reference_img_filename; char *disparity_composed_path, *reference_composed_path; IplImage *disparity_img, *reference_img; create_disparity_filename_from_timestamp(stereo_message->timestamp, &reference_img_filename, &disparity_img_filename, camera); compose_output_path(output_dir_name, disparity_img_filename, &disparity_composed_path); compose_output_path(output_dir_name, reference_img_filename, &reference_composed_path); create_image_from_float_buffer(stereo_message->disparity, &disparity_img, util.width, util.height); create_image_from_rgb_buffer(stereo_message->reference_image, &reference_img, util.width, util.height); cvSaveImage(disparity_composed_path, disparity_img, NULL); cvSaveImage(reference_composed_path, reference_img, NULL); printf("disparity image saved: %s\n", disparity_composed_path); printf("reference image saved: %s\n", reference_composed_path); free(disparity_img_filename); free(disparity_composed_path); free(reference_img_filename); free(reference_composed_path); cvRelease((void**) &disparity_img); cvRelease((void**) &reference_img); }
float Histogram::calcEMD2(const Histogram* histogram1, const Histogram* histogram2, int distanceType) { Signature* signature1 = histogram1->signature(); Signature* signature2 = histogram2->signature(); float emd2 = cvCalcEMD2(signature1, signature2, distanceType); cvRelease(&signature1); cvRelease(&signature2); return emd2; }
static IplImage* icvRetrieveImage( void* obj ) { IplImage* img = 0; if( CV_IS_IMAGE(obj) ) img = (IplImage*)obj; else if( CV_IS_MAT(obj) ) { CvMat* m = (CvMat*)obj; img = cvCreateImageHeader( cvSize(m->cols,m->rows), CV_MAT_DEPTH(m->type), CV_MAT_CN(m->type) ); cvSetData( img, m->data.ptr, m->step ); img->imageDataOrigin = (char*)m->refcount; m->data.ptr = 0; m->step = 0; cvReleaseMat( &m ); } else if( obj ) { cvRelease( &obj ); CV_Error( CV_StsUnsupportedFormat, "The object is neither an image, nor a matrix" ); } return img; }
static CvMat* icvRetrieveMatrix( void* obj ) { CvMat* m = 0; CV_FUNCNAME( "icvRetrieveMatrix" ); __BEGIN__; if( CV_IS_MAT(obj) ) m = (CvMat*)obj; else if( CV_IS_IMAGE(obj) ) { IplImage* img = (IplImage*)obj; CvMat hdr, *src = cvGetMat( img, &hdr ); CV_CALL( m = cvCreateMat( src->rows, src->cols, src->type )); CV_CALL( cvCopy( src, m )); cvReleaseImage( &img ); } else if( obj ) { cvRelease( &obj ); CV_ERROR( CV_StsUnsupportedFormat, "The object is neither an image, nor a matrix" ); } __END__; return m; }
void haarwrapper_destroy(t_haarwrapper* hc) { if (hc == NULL) return; cvReleaseMemStorage(&hc->storage); cvRelease((void**)&hc->cascade); free(hc); }
void ArrayTest::clear() { for( size_t i = 0; i < test_array.size(); i++ ) { for( size_t j = 0; j < test_array[i].size(); j++ ) cvRelease( &test_array[i][j] ); } BaseTest::clear(); }
/* * Release OpenCV specific structure(i.e CvMat, IplImage..) from memory and delete from hashtable. */ void release_object(void *ptr) { if (ptr) { unregister_object(ptr); try { cvRelease(&ptr); } catch (cv::Exception& e) { raise_cverror(e); } } }
IplImage* get128image(int argc,int **argv) { IplImage *sorceimage=0,*resizedimage; char *imagename; imagename = argc > 1 ? argv[1] : "./none.png"; sorceimage = cvLoadImage(imagename, CV_LOAD_IMAGE_COLOR); //sorceimage = cvLoadImage(imagename,CV_LOAD_IMAGE_GRAYSCALE ); if(sorceimage == 0) return 0; resizedimage=cvCreateImage(cvSize(128,128),IPL_DEPTH_8U,3); cvResize(sorceimage,resizedimage,CV_INTER_NN); cvRelease(&sorceimage); return resizedimage; }
void process_image( char* buffer, int len ) { GPtrArray *markers; int i; CvMat *m = cvCreateMatHeader (len, 1, CV_8UC1); cvSetData (m, buffer, 1); IplImage *color = cvDecodeImage (m, CV_LOAD_IMAGE_COLOR); assert (color != NULL); IplImage *bw = cvCreateImage(cvGetSize(color), color->depth, 1); cvCvtColor (color, bw, CV_RGB2GRAY); koki_camera_params_t params; params.size.x = bw->width; params.size.y = bw->height; params.principal_point.x = params.size.x / 2; params.principal_point.y = params.size.y / 2; params.focal_length.x = 571.0; params.focal_length.y = 571.0; markers = koki_find_markers(koki, bw, 0.11, ¶ms); assert(markers != NULL); for (i=0; i<markers->len; i++){ koki_marker_t *marker; marker = g_ptr_array_index(markers, i); printf("\n(%d) Marker #%d:\n", i, marker->code); } cvRelease ((void**)&bw); cvShowImage ("Source", color); cvWaitKey (0); cvRelease ((void**)&color); cvRelease ((void**)&m); }
void convert8UC3To32FC1Gray(const CvArr *src, CvArr *dst, CvArr *tmpRGBF) { bool inTmpRGBF = tmpRGBF == NULL; if ( inTmpRGBF ) { CvSize sz(cvGetSize(src)); tmpRGBF = cvCreateMat(sz.height, sz.width, CV_32FC3); } cvConvertScale(src, tmpRGBF, 1.0/255.0); cvCvtColor(tmpRGBF, dst, CV_RGB2GRAY); if ( inTmpRGBF ) cvRelease(&tmpRGBF); }
void CvArrTest::clear() { if( test_array ) { int i, j, n; for( i = 0; i < max_arr; i++ ) { n = test_array[i].size(); for( j = 0; j < n; j++ ) cvRelease( &test_array[i][j] ); } } delete[] hdr; hdr = 0; max_hdr = 0; CvTest::clear(); }
void kinect_video_handler (carmen_kinect_video_message *kinect_video_message) { char *video_img_filename; char *video_img_composed_path; IplImage *video_img; create_kinect_video_img_filename_from_timestamp(message_index, &video_img_filename); compose_output_path(output_dir_name, video_img_filename, &video_img_composed_path); create_image_from_rgb_buffer(kinect_video_message->video, &video_img, kinect_video_message->width, kinect_video_message->height); cvSaveImage(video_img_composed_path, video_img, NULL); printf("video image saved: %s\n", video_img_composed_path); free(video_img_filename); free(video_img_composed_path); cvRelease((void**) &video_img); }
static CvMat* icvRetrieveMatrix( void* obj ) { CvMat* m = 0; if( CV_IS_MAT(obj) ) m = (CvMat*)obj; else if( CV_IS_IMAGE(obj) ) { IplImage* img = (IplImage*)obj; CvMat hdr, *src = cvGetMat( img, &hdr ); m = cvCreateMat( src->rows, src->cols, src->type ); cvCopy( src, m ); cvReleaseImage( &img ); } else if( obj ) { cvRelease( &obj ); CV_Error( CV_StsUnsupportedFormat, "The object is neither an image, nor a matrix" ); } return m; }
CV_IMPL void* cvLoad( const char* filename, CvMemStorage* memstorage, const char* name, const char** _real_name ) { void* ptr = 0; const char* real_name = 0; cv::FileStorage fs(cvOpenFileStorage(filename, memstorage, CV_STORAGE_READ)); CvFileNode* node = 0; if( !fs.isOpened() ) return 0; if( name ) { node = cvGetFileNodeByName( *fs, 0, name ); } else { int i, k; for( k = 0; k < (*fs)->roots->total; k++ ) { CvSeq* seq; CvSeqReader reader; node = (CvFileNode*)cvGetSeqElem( (*fs)->roots, k ); CV_Assert(node != NULL); if( !CV_NODE_IS_MAP( node->tag )) return 0; seq = node->data.seq; node = 0; cvStartReadSeq( seq, &reader, 0 ); // find the first element in the map for( i = 0; i < seq->total; i++ ) { if( CV_IS_SET_ELEM( reader.ptr )) { node = (CvFileNode*)reader.ptr; goto stop_search; } CV_NEXT_SEQ_ELEM( seq->elem_size, reader ); } } stop_search: ; } if( !node ) CV_Error( CV_StsObjectNotFound, "Could not find the/an object in file storage" ); real_name = cvGetFileNodeName( node ); ptr = cvRead( *fs, node, 0 ); // sanity check if( !memstorage && (CV_IS_SEQ( ptr ) || CV_IS_SET( ptr )) ) CV_Error( CV_StsNullPtr, "NULL memory storage is passed - the loaded dynamic structure can not be stored" ); if( cvGetErrStatus() < 0 ) { cvRelease( (void**)&ptr ); real_name = 0; } if( _real_name) { if (real_name) { *_real_name = (const char*)cvAlloc(strlen(real_name)); memcpy((void*)*_real_name, real_name, strlen(real_name)); } else { *_real_name = 0; } } return ptr; }
int ArrayTest::prepare_test_case( int test_case_idx ) { int code = 1; size_t max_arr = test_array.size(); vector<vector<Size> > sizes(max_arr); vector<vector<Size> > whole_sizes(max_arr); vector<vector<int> > types(max_arr); size_t i, j; RNG& rng = ts->get_rng(); bool is_image = false; for( i = 0; i < max_arr; i++ ) { size_t sizei = std::max(test_array[i].size(), (size_t)1); sizes[i].resize(sizei); types[i].resize(sizei); whole_sizes[i].resize(sizei); } get_test_array_types_and_sizes( test_case_idx, sizes, types ); for( i = 0; i < max_arr; i++ ) { size_t sizei = test_array[i].size(); for( j = 0; j < sizei; j++ ) { unsigned t = randInt(rng); bool create_mask = true, use_roi = false; CvSize size = cvSize(sizes[i][j]), whole_size = size; CvRect roi = CV_STRUCT_INITIALIZER; is_image = !cvmat_allowed ? true : iplimage_allowed ? (t & 1) != 0 : false; create_mask = (t & 6) == 0; // ~ each of 3 tests will use mask use_roi = (t & 8) != 0; if( use_roi ) { whole_size.width += randInt(rng) % 10; whole_size.height += randInt(rng) % 10; } cvRelease( &test_array[i][j] ); if( size.width > 0 && size.height > 0 && types[i][j] >= 0 && (i != MASK || create_mask) ) { if( use_roi ) { roi.width = size.width; roi.height = size.height; if( whole_size.width > size.width ) roi.x = randInt(rng) % (whole_size.width - size.width); if( whole_size.height > size.height ) roi.y = randInt(rng) % (whole_size.height - size.height); } if( is_image ) { test_array[i][j] = cvCreateImage( whole_size, icvTsTypeToDepth[CV_MAT_DEPTH(types[i][j])], CV_MAT_CN(types[i][j]) ); if( use_roi ) cvSetImageROI( (IplImage*)test_array[i][j], roi ); } else { test_array[i][j] = cvCreateMat( whole_size.height, whole_size.width, types[i][j] ); if( use_roi ) { CvMat submat, *mat = (CvMat*)test_array[i][j]; cvGetSubRect( test_array[i][j], &submat, roi ); submat.refcount = mat->refcount; *mat = submat; } } } } } test_mat.resize(test_array.size()); for( i = 0; i < max_arr; i++ ) { size_t sizei = test_array[i].size(); test_mat[i].resize(sizei); for( j = 0; j < sizei; j++ ) { CvArr* arr = test_array[i][j]; test_mat[i][j] = cv::cvarrToMat(arr); if( !test_mat[i][j].empty() ) fill_array( test_case_idx, (int)i, (int)j, test_mat[i][j] ); } } return code; }
void THISCLASS::OnStep() { std::vector<Particle> rejectedparticles; // Get and check input image IplImage *inputimage = cvCloneImage(mCore->mDataStructureImageBinary.mImage); IplImage *outputImage = mCore->mDataStructureImageBinary.mImage; //mCore->mDataStructureImageBinary.mImage; if (! inputimage) { AddError(wxT("No input image.")); return; } if (inputimage->nChannels != 1) { AddError(wxT("The input image is not a grayscale image.")); return; } cvZero(outputImage); // We clear the ouput vector mParticles.clear(); // Initialization Particle tmpParticle; // Used to put the calculated value in memory CvMoments moments; // Used to calculate the moments std::vector<Particle>::iterator j; // Iterator used to stock the particles by size // We allocate memory to extract the contours from the binary image CvMemStorage* storage = cvCreateMemStorage(0); CvSeq* contour = 0; // Init blob extraxtion CvContourScanner blobs = cvStartFindContours(inputimage, storage, sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_NONE); // This is used to correct the position in case of ROI CvRect rectROI; if (inputimage->roi != NULL) { rectROI = cvGetImageROI(inputimage); } else { rectROI.x = 0; rectROI.y = 0; } while ((contour = cvFindNextContour(blobs)) != NULL) { // Computing the moments cvMoments(contour, &moments); // Computing particle area tmpParticle.mArea = moments.m00; tmpParticle.mCenter.x = (float)(rectROI.x + (moments.m10 / moments.m00 + 0.5)); // moments using Green theorem tmpParticle.mCenter.y = (float)(rectROI.y + (moments.m01 / moments.m00 + 0.5)); // m10 = x direction, m01 = y direction, m00 = area as edicted in theorem // Selection based on area if ((mAreaSelection == false) || ((tmpParticle.mArea <= mMaxArea) && (tmpParticle.mArea >= mMinArea))) { tmpParticle.mCompactness = GetContourCompactness(contour); if ((mCompactnessSelection == false) || ((tmpParticle.mCompactness > mMinCompactness) && (tmpParticle.mCompactness < mMaxCompactness))) { double tempValue = cvGetCentralMoment(&moments, 2, 0) - cvGetCentralMoment(&moments, 0, 2); tmpParticle.mOrientation = atan(2 * cvGetCentralMoment(&moments, 1, 1) / (tempValue + sqrt(tempValue * tempValue + 4 * cvGetCentralMoment(&moments, 1, 1) * cvGetCentralMoment(&moments, 1, 1)))); if ((mOrientationSelection == false) || (((tmpParticle.mOrientation > mMinOrientation) && (tmpParticle.mOrientation < mMaxOrientation)) || ((tmpParticle.mOrientation > mMinOrientation + PI) && (tmpParticle.mOrientation < mMaxOrientation + PI)) || ((tmpParticle.mOrientation > mMinOrientation - PI) && (tmpParticle.mOrientation < mMaxOrientation - PI)))) { cvDrawContours(outputImage, contour, cvScalarAll(255), cvScalarAll(255), 0, CV_FILLED); // Check if we have already enough particles if (mParticles.size() == mMaxNumber) { // If the particle is bigger than the smallest stored particle, store it, else do nothing if (tmpParticle.mArea > mParticles.back().mArea) { // Find the place were it must be inserted, sorted by size for (j = mParticles.begin(); (j != mParticles.end()) && (tmpParticle.mArea < (*j).mArea); j++); // Fill unused values tmpParticle.mID = -1; tmpParticle.mIDCovariance = -1; // Insert the particle mParticles.insert(j, tmpParticle); // Remove the smallest one mParticles.pop_back(); } } else { // The particle is added at the correct place // Find the place were it must be inserted, sorted by size for (j = mParticles.begin(); (j != mParticles.end()) && (tmpParticle.mArea < (*j).mArea); j++); // Fill unused values tmpParticle.mID = -1; tmpParticle.mIDCovariance = -1; // Insert the particle mParticles.insert(j, tmpParticle); } } } } else { rejectedparticles.push_back(tmpParticle); } cvRelease((void**)&contour); } contour = cvEndFindContours(&blobs); // If we need to display the particles /* if(trackingimg->GetDisplay()) { for(j=rejectedparticles.begin();j!=rejectedparticles.end();j++) { trackingimg->DrawCircle(cvPoint((int)(((*j).p).x),(int)(((*j).p).y)),CV_RGB(255,0,0)); } for(j=particles.begin();j!=particles.end();j++) { trackingimg->DrawCircle(cvPoint((int)(((*j).p).x),(int)(((*j).p).y)),CV_RGB(0,255,0)); trackingimg->Cover(cvPoint((int)(((*j).p).x),(int)(((*j).p).y)),CV_RGB(255,0,0),2); } } */ cvReleaseImage(&inputimage); cvRelease((void**)&contour); cvReleaseMemStorage(&storage); // Set these particles mCore->mDataStructureParticles.mParticles = &mParticles; // Let the DisplayImage know about our image DisplayEditor de(&mDisplayOutput); if (de.IsActive()) { de.SetParticles(&mParticles); de.SetMainImage(mCore->mDataStructureImageBinary.mImage); } }
/** * deconstructor */ adaBoostBinary::~adaBoostBinary() { cvRelease((void **)&weight); free(labelsign); free(iter_res); }
/** *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; }
int CvArrTest::prepare_test_case( int test_case_idx ) { int code = 1; CvSize** sizes = (CvSize**)malloc( max_arr*sizeof(sizes[0]) ); CvSize** whole_sizes = (CvSize**)malloc( max_arr*sizeof(whole_sizes[0]) ); int** types = (int**)malloc( max_arr*sizeof(types[0]) ); int i, j, total = 0; CvRNG* rng = ts->get_rng(); bool is_image = false; bool is_timing_test = false; CV_FUNCNAME( "CvArrTest::prepare_test_case" ); __BEGIN__; is_timing_test = ts->get_testing_mode() == CvTS::TIMING_MODE; if( is_timing_test ) { if( !get_next_timing_param_tuple() ) { code = -1; EXIT; } } for( i = 0; i < max_arr; i++ ) { int count = test_array[i].size(); count = MAX(count, 1); sizes[i] = (CvSize*)malloc( count*sizeof(sizes[i][0]) ); types[i] = (int*)malloc( count*sizeof(types[i][0]) ); whole_sizes[i] = (CvSize*)malloc( count*sizeof(whole_sizes[i][0]) ); } if( !is_timing_test ) get_test_array_types_and_sizes( test_case_idx, sizes, types ); else { get_timing_test_array_types_and_sizes( test_case_idx, sizes, types, whole_sizes, &is_image ); } for( i = 0; i < max_arr; i++ ) { int count = test_array[i].size(); total += count; for( j = 0; j < count; j++ ) { unsigned t = cvRandInt(rng); bool create_mask = true, use_roi = false; CvSize size = sizes[i][j], whole_size = size; CvRect roi = {0,0,0,0}; if( !is_timing_test ) { is_image = !cvmat_allowed ? true : iplimage_allowed ? (t & 1) != 0 : false; create_mask = (t & 6) == 0; // ~ each of 3 tests will use mask use_roi = (t & 8) != 0; if( use_roi ) { whole_size.width += cvRandInt(rng) % 10; whole_size.height += cvRandInt(rng) % 10; } } else { whole_size = whole_sizes[i][j]; use_roi = whole_size.width != size.width || whole_size.height != size.height; create_mask = cvReadInt(find_timing_param( "use_mask" ),0) != 0; } cvRelease( &test_array[i][j] ); if( size.width > 0 && size.height > 0 && types[i][j] >= 0 && (i != MASK || create_mask) ) { if( use_roi ) { roi.width = size.width; roi.height = size.height; if( whole_size.width > size.width ) { if( !is_timing_test ) roi.x = cvRandInt(rng) % (whole_size.width - size.width); else roi.x = 1; } if( whole_size.height > size.height ) { if( !is_timing_test ) roi.y = cvRandInt(rng) % (whole_size.height - size.height); else roi.y = 1; } } if( is_image ) { CV_CALL( test_array[i][j] = cvCreateImage( whole_size, icvTsTypeToDepth[CV_MAT_DEPTH(types[i][j])], CV_MAT_CN(types[i][j]) )); if( use_roi ) cvSetImageROI( (IplImage*)test_array[i][j], roi ); } else { CV_CALL( test_array[i][j] = cvCreateMat( whole_size.height, whole_size.width, types[i][j] )); if( use_roi ) { CvMat submat, *mat = (CvMat*)test_array[i][j]; cvGetSubRect( test_array[i][j], &submat, roi ); submat.refcount = mat->refcount; *mat = submat; } } } } } if( total > max_hdr ) { delete hdr; max_hdr = total; hdr = new CvMat[max_hdr]; } total = 0; for( i = 0; i < max_arr; i++ ) { int count = test_array[i].size(); test_mat[i] = count > 0 ? hdr + total : 0; for( j = 0; j < count; j++ ) { CvArr* arr = test_array[i][j]; CvMat* mat = &test_mat[i][j]; if( !arr ) memset( mat, 0, sizeof(*mat) ); else if( CV_IS_MAT( arr )) { *mat = *(CvMat*)arr; mat->refcount = 0; } else cvGetMat( arr, mat, 0, 0 ); if( mat->data.ptr ) fill_array( test_case_idx, i, j, mat ); } total += count; } __END__; for( i = 0; i < max_arr; i++ ) { if( sizes ) free( sizes[i] ); if( whole_sizes ) free( whole_sizes[i] ); if( types ) free( types[i] ); } free( sizes ); free( whole_sizes ); free( types ); return code; }
//-------------------------------------------------------------- void eyeTracker::update(ofxCvGrayscaleImage & grayImgFromCam, float threshold, float minSize, float maxSize, float minSquareness) { //threshold? //threshold = thresh; grayImgPreWarp.setFromPixels(grayImgFromCam.getPixels(), grayImgFromCam.width, grayImgFromCam.height); // TODO: there's maybe an unnecessary grayscale image (and copy) here... if( flipX || flipY ) { grayImgPreWarp.mirror(flipY, flipX); } /* // before we were scaling and translating, but this is removed for now if (fabs(xoffset-1) > 0.1f || fabs(yoffset-1) > 0.1f){ grayImgPreWarp.translate(xoffset, yoffset); } if (fabs(scalef-1) > 0.1f){ grayImgPreWarp.scale(scalef, scalef); }*/ grayImg = grayImgPreWarp; grayImgPreModification = grayImg; grayImg.blur(5); if (bUseContrast == true) { grayImg.applyBrightnessContrast(brightness,contrast); } if (bUseGamma == true) { grayImg.applyMinMaxGamma(gamma); } grayImg += edgeMask; threshImg = grayImg; threshImg.contrastStretch(); threshImg.threshold(threshold, true); // the dilation of a 640 x 480 image is very slow, so let's just do a ROI near the thing we like: threshImg.setROI(currentEyePoint.x-50, currentEyePoint.y-50, 100,100); // 200 pix ok? if (bUseDilate == true) { for (int i = 0; i < nDilations; i++) { threshImg.dilate(); } } threshImg.resetROI(); bFoundOne = false; int whoFound = -1; int num = contourFinder.findContours(threshImg, minSize, maxSize, 100, false, true); if( num ) { for(int k = 0; k < num; k++) { float ratio = contourFinder.blobs[k].boundingRect.width < contourFinder.blobs[k].boundingRect.height ? contourFinder.blobs[k].boundingRect.width / contourFinder.blobs[k].boundingRect.height : contourFinder.blobs[k].boundingRect.height / contourFinder.blobs[k].boundingRect.width; float arcl = contourFinder.blobs[k].length; float area = contourFinder.blobs[k].area; float compactness = (float)((arcl*arcl/area)/FOUR_PI); if (bUseCompactnessTest == true && compactness > maxCompactness) { continue; } //printf("compactness %f \n", compactness); //lets ignore rectangular blobs if( ratio > minSquareness) { currentEyePoint = contourFinder.blobs[k].centroid; currentNormPoint.x = currentEyePoint.x; currentNormPoint.y = currentEyePoint.y; currentNormPoint.x /= w; currentNormPoint.y /= h; bFoundOne = true; whoFound = k; break; } } } if (bFoundOne && whoFound != -1) { // do some convex hull stuff: CvSeq* ptseq = cvCreateSeq( CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvContour),sizeof(CvPoint), storage ); CvSeq* hull; CvPoint pt0; for(int i = 0; i < contourFinder.blobs[whoFound].nPts; i++ ) { pt0.x = contourFinder.blobs[whoFound].pts[i].x; pt0.y = contourFinder.blobs[whoFound].pts[i].y; cvSeqPush( ptseq, &pt0 ); } hull = cvConvexHull2( ptseq, 0, CV_CLOCKWISE, 0 ); int hullcount = hull->total; // -------------------------------- TRY TO GET A GOOD ELLIPSE HELLS YEAH !! int MYN = hullcount; float x[MYN], y[MYN]; double p[6]; double ellipseParam[5]; float theta; FitEllipse fitter; for (int i=0; i<MYN; i++) { CvPoint pt = **CV_GET_SEQ_ELEM( CvPoint*, hull, i); x[i] = pt.x; y[i] = pt.y; } double xc, yc; double xa, ya; double la, lb; fitter.apply(x,y,MYN); p[0] = fitter.Axx; p[1] = fitter.Axy; p[2] = fitter.Ayy; p[3] = fitter.Ax; p[4] = fitter.Ay; p[5] = fitter.Ao; bool bOk = solve_ellipse(p,ellipseParam); ofxCvBlob temp; if (bOk == true) { //float *params_ellipse = pupilGeometries[whichEye].params_ellipse; float axis_a = ellipseParam[0]; float axis_b = ellipseParam[1]; float cx = ellipseParam[2]; float cy = ellipseParam[3]; theta = ellipseParam[4]; float aspect = axis_b/axis_a; for (int i = 0; i < 5; i++) { eyeTrackedEllipse.ellipseParam[i] = ellipseParam[i]; } //theta = ofRandom(0,TWO_PI); int resolution = 24; ofxPoint2f ptsForRotation[resolution]; for (int i=0; i<resolution; i++) { float t = TWO_PI * (float)i/(float)resolution; float ex = cx + (axis_a * cos(t )); float ey = cy + (axis_b * sin(t )); ptsForRotation[i].set(ex,ey); } for (int i=0; i<resolution; i++) { ptsForRotation[i].rotate(theta * RAD_TO_DEG, ofxPoint2f(cx, cy)); } currentEyePoint.set(cx, cy); currentNormPoint.x = currentEyePoint.x; currentNormPoint.y = currentEyePoint.y; currentNormPoint.x /= w; currentNormPoint.y /= h; } else { bFoundOne = false; } cvRelease((void **)&hull); }