opencv/samples/c/one_way_sample.cpp

/*
 *  one_way_sample.cpp
 *  outlet_detection
 *
 *  Created by Victor  Eruhimov on 8/5/09.
 *  Copyright 2009 Argus Corp. All rights reserved.
 *
 */

#include <cv.h>
#include <cvaux.h>
#include <highgui.h>

#include <string>

using namespace cv;

IplImage* DrawCorrespondences(IplImage* img1, const vector<KeyPoint>& features1, 
                              IplImage* img2, const vector<KeyPoint>& features2, const vector<int>& desc_idx);
void generatePCADescriptors(const char* img_path, const char* pca_low_filename, const char* pca_high_filename, 
                            const char* pca_desc_filename, CvSize patch_size);

int main(int argc, char** argv)
{    
    const char pca_high_filename[] = "pca_hr.yml";
    const char pca_low_filename[] = "pca_lr.yml";
    const char pca_desc_filename[] = "pca_descriptors.yml";
    const CvSize patch_size = cvSize(24, 24);
    const int pose_count = 50;
    
    if(argc != 3 && argc != 4)
    {
        printf("Format: \n./one_way_sample [path_to_samples] [image1] [image2]\n");
        printf("For example: ./one_way_sample ../../../opencv/samples/c scene_l.bmp scene_r.bmp\n");
        return 0;
    }
    
    std::string path_name = argv[1];
    std::string img1_name = path_name + "/" + std::string(argv[2]);
    std::string img2_name = path_name + "/" + std::string(argv[3]);

    CvFileStorage* fs = cvOpenFileStorage("pca_hr.yml", NULL, CV_STORAGE_READ);
    if(fs == NULL)
    {
        printf("PCA data is not found, starting training...\n");
        generatePCADescriptors(path_name.c_str(), pca_low_filename, pca_high_filename, pca_desc_filename, patch_size);
    }
    else
    {
        cvReleaseFileStorage(&fs);
    }
    
    
    printf("Reading the images...\n");
    IplImage* img1 = cvLoadImage(img1_name.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
    IplImage* img2 = cvLoadImage(img2_name.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
    
    // extract keypoints from the first image
    SURF surf_extractor(5.0e3);
    vector<KeyPoint> keypoints1;
#if 1
    Mat _img1(img1);
    vector<Point2f> corners;
    
    goodFeaturesToTrack(_img1, corners, 200, 0.01, 20);
    for(size_t i = 0; i < corners.size(); i++)
    {
        KeyPoint p;
        p.pt = corners[i];
        keypoints1.push_back(p);
    }
#else
//    printf("Extracting keypoints\n");
    surf_extractor(img1, Mat(), keypoints1);
#endif
    
    printf("Extracted %d keypoints...\n", (int)keypoints1.size());

    printf("Training one way descriptors...");
    // create descriptors 
    OneWayDescriptorBase descriptors(patch_size, pose_count, ".", pca_low_filename, pca_high_filename, pca_desc_filename);
    descriptors.CreateDescriptorsFromImage(img1, keypoints1);
    printf("done\n");
    
    // extract keypoints from the second image
    vector<KeyPoint> keypoints2;
    surf_extractor(img2, Mat(), keypoints2);
    printf("Extracted %d keypoints from the second image...\n", (int)keypoints2.size());

    
    printf("Finding nearest neighbors...");
    // find NN for each of keypoints2 in keypoints1
    vector<int> desc_idx;
    desc_idx.resize(keypoints2.size());
    for(size_t i = 0; i < keypoints2.size(); i++)
    {
        int pose_idx = 0;
        float distance = 0;
        descriptors.FindDescriptor(img2, keypoints2[i].pt, desc_idx[i], pose_idx, distance);
    }
    printf("done\n");
    
    IplImage* img_corr = DrawCorrespondences(img1, keypoints1, img2, keypoints2, desc_idx);
    
    cvNamedWindow("correspondences", 1);
    cvShowImage("correspondences", img_corr);
    cvWaitKey(0);
    
    cvReleaseImage(&img1);
    cvReleaseImage(&img2);
    cvReleaseImage(&img_corr);
}

IplImage* DrawCorrespondences(IplImage* img1, const vector<KeyPoint>& features1, IplImage* img2, const vector<KeyPoint>& features2, const vector<int>& desc_idx)
{
    IplImage* img_corr = cvCreateImage(cvSize(img1->width + img2->width, MAX(img1->height, img2->height)), IPL_DEPTH_8U, 3);
    cvSetImageROI(img_corr, cvRect(0, 0, img1->width, img1->height));
    cvCvtColor(img1, img_corr, CV_GRAY2RGB);
    cvSetImageROI(img_corr, cvRect(img1->width, 0, img2->width, img2->height));
    cvCvtColor(img2, img_corr, CV_GRAY2RGB);
    cvResetImageROI(img_corr);
    
    for(size_t i = 0; i < features1.size(); i++)
    {
        cvCircle(img_corr, features1[i].pt, 3, CV_RGB(255, 0, 0));
    }
    
    for(size_t i = 0; i < features2.size(); i++)
    {
        CvPoint pt = cvPoint(features2[i].pt.x + img1->width, features2[i].pt.y);
        cvCircle(img_corr, pt, 3, CV_RGB(255, 0, 0));
        cvLine(img_corr, features1[desc_idx[i]].pt, pt, CV_RGB(0, 255, 0));
    }
    
    return img_corr;
}

/*
 *  pca_features
 * 
 *
 */

void savePCAFeatures(const char* filename, CvMat* avg, CvMat* eigenvectors)
{
    CvMemStorage* storage = cvCreateMemStorage();
    
    CvFileStorage* fs = cvOpenFileStorage(filename, storage, CV_STORAGE_WRITE);
    cvWrite(fs, "avg", avg);
    cvWrite(fs, "eigenvectors", eigenvectors);
    cvReleaseFileStorage(&fs);   
    
    cvReleaseMemStorage(&storage);
}

void calcPCAFeatures(vector<IplImage*>& patches, const char* filename, CvMat** avg, CvMat** eigenvectors)
{
    int width = patches[0]->width;
    int height = patches[0]->height;
    int length = width*height;
    int patch_count = (int)patches.size();
    
    CvMat* data = cvCreateMat(patch_count, length, CV_32FC1);
    *avg = cvCreateMat(1, length, CV_32FC1);
    CvMat* eigenvalues = cvCreateMat(1, length, CV_32FC1);
    *eigenvectors = cvCreateMat(length, length, CV_32FC1);
    
    for(int i = 0; i < patch_count; i++)
    {
        float sum = cvSum(patches[i]).val[0];
        for(int y = 0; y < height; y++)
        {
            for(int x = 0; x < width; x++)
            {
                *((float*)(data->data.ptr + data->step*i) + y*width + x) = (float)(unsigned char)patches[i]->imageData[y*patches[i]->widthStep + x]/sum;
            }
        }
    }
    
    printf("Calculating PCA...");
    cvCalcPCA(data, *avg, eigenvalues, *eigenvectors, CV_PCA_DATA_AS_ROW);
    printf("done\n");
    
    // save pca data
    savePCAFeatures(filename, *avg, *eigenvectors);
    
    cvReleaseMat(&data);
    cvReleaseMat(&eigenvalues);
}


void loadPCAFeatures(const char* path, vector<IplImage*>& patches, CvSize patch_size)
{
    const int file_count = 2;
    for(int i = 0; i < file_count; i++)
    {
        char buf[1024];
        sprintf(buf, "%s/one_way_train_%04d.jpg", path, i);
        printf("Reading image %s...", buf);
        IplImage* img = cvLoadImage(buf, CV_LOAD_IMAGE_GRAYSCALE);
        printf("done\n");
        
        vector<KeyPoint> features;
        SURF surf_extractor(1.0f);
        printf("Extracting SURF features...");
        surf_extractor(img, Mat(), features);
        printf("done\n");
        
        for(int j = 0; j < (int)features.size(); j++)
        {
            int patch_width = patch_size.width;
            int patch_height = patch_size.height;
            
            CvPoint center = features[j].pt;
            
            CvRect roi = cvRect(center.x - patch_width/2, center.y - patch_height/2, patch_width, patch_height);
            cvSetImageROI(img, roi);
            roi = cvGetImageROI(img);
            if(roi.width != patch_width || roi.height != patch_height)
            {
                continue;
            }
            
            IplImage* patch = cvCreateImage(cvSize(patch_width, patch_height), IPL_DEPTH_8U, 1);
            cvCopy(img, patch);
            patches.push_back(patch);
            cvResetImageROI(img);
            
        }
        
        printf("Completed file %d, extracted %d features\n", i, (int)features.size());
        
        cvReleaseImage(&img);
    }
}

void generatePCAFeatures(const char* img_filename, const char* pca_filename, CvSize patch_size, CvMat** avg, CvMat** eigenvectors)
{
    vector<IplImage*> patches;
    loadPCAFeatures(img_filename, patches, patch_size);
    calcPCAFeatures(patches, pca_filename, avg, eigenvectors);
}

void generatePCADescriptors(const char* img_path, const char* pca_low_filename, const char* pca_high_filename, 
                            const char* pca_desc_filename, CvSize patch_size)
{
    CvMat* avg_hr;
    CvMat* eigenvectors_hr;
    generatePCAFeatures(img_path, pca_high_filename, patch_size, &avg_hr, &eigenvectors_hr);

    CvMat* avg_lr;
    CvMat* eigenvectors_lr;
    generatePCAFeatures(img_path, pca_low_filename, cvSize(patch_size.width/2, patch_size.height/2), 
        &avg_lr, &eigenvectors_lr);
    
    const int pose_count = 500;
    OneWayDescriptorBase descriptors(patch_size, pose_count);
    descriptors.SetPCAHigh(avg_hr, eigenvectors_hr);
    descriptors.SetPCALow(avg_lr, eigenvectors_lr);
    
    printf("Calculating %d PCA descriptors (you can grab a coffee, this will take a while)...\n", descriptors.GetPCADimHigh());
    descriptors.InitializePoseTransforms();
    descriptors.CreatePCADescriptors();
    descriptors.SavePCADescriptors(pca_desc_filename);
    
    cvReleaseMat(&avg_hr);
    cvReleaseMat(&eigenvectors_hr);
    cvReleaseMat(&avg_lr);
    cvReleaseMat(&eigenvectors_lr);
}