void CvFeatureEvaluator::init( const CvFeatureParams *_featureParams, int _maxSampleCount, Size _winSize ) { CV_Assert( _maxSampleCount > 0 ); featureParams = (CvFeatureParams *) _featureParams; winSize = _winSize; numFeatures = _featureParams->numFeatures; cls.create( (int) _maxSampleCount, 1, CV_32FC1 ); generateFeatures(); }
void Ferns::init(std::vector<cv::Size> const& scales) { this->clear(); generateFeatures(scales); acum = 0; thrN = 0.5 * nstructs; for (int i=0; i<nstructs; i++) { posteriors.push_back(std::vector<float>(std::pow(2.0, nBIT*structSize), 0)); pCounter.push_back(std::vector<int>(std::pow(2.0, nBIT*structSize), 0)); nCounter.push_back(std::vector<int>(std::pow(2.0, nBIT*structSize), 0)); } }
void CvHaarEvaluator::generateFeatures() { generateFeatures( featureParams->numFeatures ); }
// my main function int main(int argc, char** argv) { // Main Variables int i, j; time_t t1, t2, t3, t4, t5, t6, t7, renderTime, deallocateTime; if (argc != 2) { fatal_error("usage: %s <PATH_FOR_IMAGES>", argv[0]); } // ************************TIME CHECKPOINT 1: Initialization**************************** (void) time(&t1); printf("Starting Checkpoint 1 - initialization...\n"); // Variables int file_count = 0; char** filenames = NULL; struct pData* poses = NULL; FILE *poseFile; char poseFilename[strlen(argv[1]) + strlen("poses.txt")]; sprintf(poseFilename, "%sposes.txt", argv[1]); poseFile = fopen(poseFilename, "r"); if (poseFile != NULL) { int c, step = 0; while (file_count < NUM_IMAGES) { filenames = (char **) realloc(filenames, (file_count+1) * sizeof(char *)); poses = (struct pData*) realloc(poses, (file_count+1) * sizeof(struct pData)); if ((step % STEP) == 0) { initialize(poseFile, poses, filenames, file_count); file_count++; step++; } else { while((c = fgetc(poseFile)) != '\n'); step++; } } } // ************************TIME CHECKPOINT 2: Loading Image Data*************************** (void) time(&t2); printf("Starting Checkpoint 2 - loading images from directory...\n"); // Variables int image_count = 0; IplImage** images = NULL; images = (IplImage**) malloc(file_count * sizeof(IplImage*)); // ERROR check allocation if (images == NULL) { fatal_error("allocating memory for images"); } // load images memset(images, 0, file_count*sizeof(IplImage*)); image_count = loadImages(argv[1], filenames, file_count, images); // Release the memory for filenames. Not needed anymore. free(filenames); // ************************TIME CHECKPOINT 3: Finding Features***************************** (void) time(&t3); printf("Starting Checkpoint 3 - finding features in each image...\n"); // Step 1: generate features form images generateFeatures(images, image_count); // ************************TIME CHECKPOINT 4: Calculating Homographies********************* (void) time(&t4); printf("Starting Checkpoint 4 - matching images...\n"); // A match represents a homography between two images int match_count = 0; CvMat** matches = (CvMat **) malloc(image_count * image_count * sizeof(CvMat*)); // ERROR check allocation if (matches == NULL) { fatal_error("allocating memory for matches"); } // Calculate homographies memset(matches, 0, image_count*image_count*sizeof(CvMat*)); match_count = enumerateMatches(images, image_count, matches); // ************************TIME CHECKPOINT 5: Calculating Norms of Homographies************ (void) time(&t5); printf("Starting Checkpoint 5 - calculating norms of homography...\n"); // The confidence is a measurement of similarity between images (i.e. norm of homography) double* confidences = (double*) calloc(match_count, sizeof(double)); // ERROR check allocation if (confidences == NULL) { fatal_error("allocating memory for confidences"); } calculateNorms(confidences, matches, image_count, match_count); // ************************TIME CHECKPOINT 6: Generating Best Homographies************ (void) time(&t6); printf("Starting Checkpoint 6 - Generating best homographies...\n"); // Variables int* bestMatchedIndex = (int*) calloc(image_count, sizeof(int)); generateBestHomographies(bestMatchedIndex, image_count, confidences); // ************************Render Checkpoint: Rendering Scene**************************** (void) time(&renderTime); printf("Starting Render Checkpoint - Rendering...\n"); // Variables IplImage* viewport; clock_t currtime; int key; myScene = (struct scene*) malloc(sizeof(struct scene)); initScene(0, myScene, poses, image_count); cvNamedWindow("Scene", 1); cvMoveWindow("Scene", 560, 200); rightClicked = 0; leftClicked = 0; middleClicked = 0; mousePosX = 0; mousePosY = 0; cvSetMouseCallback("Scene", mouseHandler, 0); viewport = cvCreateImage(cvSize(WINDOW_WIDTH, WINDOW_HEIGHT), IPL_DEPTH_8U, 3); while(1) { currtime = clock(); if (!OPTION) { cvSetZero(viewport); //cvReleaseImage(&viewport); //viewport = cvCreateImage(cvSize(WINDOW_WIDTH, WINDOW_HEIGHT), IPL_DEPTH_8U, 3); } renderScene(images, matches, bestMatchedIndex, viewport, poses); cvShowImage("Scene", viewport); key = cvWaitKey(10); if (key == 'e' || key == 'E' || key == 27) { printf("EXITING!!!\n"); break; } else if (key == 'r' || key == 'R') { initScene(0, myScene, poses, image_count); }else if (OPTION) { updateSceneKey(key); } //if (DEBUG) printf("time for frame: %.2lf\n", (((double) 1.0*clock()) - currtime) / CLOCKS_PER_SEC); } cvReleaseImage(&viewport); // ************************DEALLOCATION CHECKPOINT: Deallocating Memory****************** (void) time(&deallocateTime); printf("Starting Deallocation Checkpoint - Deallocating...\n"); // free allocated data // free CHECKPOINT 7 free(myScene); // free CHECKPOINT 6 free(bestMatchedIndex); // free CHECKPOINT 5 free(confidences); // free CHECKPOINT 3 and 4 for (i = 0; i < match_count; i++) { cvReleaseMat(&matches[i]); } free(matches); // free CHECKPOINT 2 for (i = 0; i < image_count; i++) { cvReleaseImage(&images[i]); } free(images); // free CHECKPOINT 1 free(poses); // Print Statistics printf("\n"); printf("Number of images: %d\n", image_count); printf("Time for initialization: %.2lf\n", difftime(t2,t1)); printf("Time to load data: %.2lf\n", difftime(t3,t2)); printf("Time to generate features: %.2lf\n", difftime(t4,t3)); printf("Time to generate matches: %.2lf\n", difftime(t5,t4)); printf("Time to generate confidence/norms: %.2lf\n", difftime(t6, t5)); printf("Time to search for optimal homographies: %.2lf\n", difftime(renderTime, t6)); printf("Time for rendering: %.2lf\n", difftime(deallocateTime,renderTime)); printf("Total Time: %.2lf\n", difftime(deallocateTime, t1)); return 0; }
void ICFDetector::train(const vector<string>& image_filenames, const vector< vector<Rect> >& labelling, ICFDetectorParams params) { Size model_size(params.model_n_cols, params.model_n_rows); vector<Mat> samples; /* positive samples + negative samples */ Mat sample, resized_sample; int pos_count = 0; for( size_t i = 0; i < image_filenames.size(); ++i, ++pos_count ) { Mat img = imread(String(image_filenames[i].c_str())); for( size_t j = 0; j < labelling[i].size(); ++j ) { Rect r = labelling[i][j]; if( r.x > img.cols || r.y > img.rows ) continue; sample = img.colRange(max(r.x, 0), min(r.width, img.cols)) .rowRange(max(r.y, 0), min(r.height, img.rows)); resize(sample, resized_sample, model_size); samples.push_back(resized_sample); } } int neg_count = 0; RNG rng; for( size_t i = 0; i < image_filenames.size(); ++i ) { Mat img = imread(String(image_filenames[i].c_str())); for( int j = 0; j < (int)(pos_count / image_filenames.size() + 1); ) { Rect r; r.x = rng.uniform(0, img.cols); r.width = rng.uniform(r.x + 1, img.cols); r.y = rng.uniform(0, img.rows); r.height = rng.uniform(r.y + 1, img.rows); if( !overlap(r, labelling[i]) ) { sample = img.colRange(r.x, r.width).rowRange(r.y, r.height); //resize(sample, resized_sample); samples.push_back(resized_sample); ++neg_count; ++j; } } } Mat_<int> labels(1, pos_count + neg_count); for( int i = 0; i < pos_count; ++i) labels(0, i) = 1; for( int i = pos_count; i < pos_count + neg_count; ++i ) labels(0, i) = -1; vector<Point3i> features = generateFeatures(model_size); Ptr<ACFFeatureEvaluator> feature_evaluator = createACFFeatureEvaluator(features); Mat_<int> data((int)features.size(), (int)samples.size()); Mat_<int> feature_col; vector<Mat> channels; for( int i = 0; i < (int)samples.size(); ++i ) { computeChannels(samples[i], channels); feature_evaluator->setChannels(channels); feature_evaluator->evaluateAll(feature_col); for( int j = 0; j < feature_col.rows; ++j ) data(i, j) = feature_col(0, j); } WaldBoostParams wparams; wparams.weak_count = params.weak_count; wparams.alpha = 0.001f; Ptr<WaldBoost> waldboost = createWaldBoost(wparams); waldboost->train(data, labels); }