Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Storing PCA components and One Way descriptors in one yml file.

Browse Source
pull/13383/head
Ilya Lysenkov 15 years ago
parent 08c377cb48
commit a702e5b2dc
5 changed files with 288 additions and 218 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 34
      modules/features2d/include/opencv2/features2d/features2d.hpp
  2. 10
      modules/features2d/src/descriptors.cpp
  3. 246
      modules/features2d/src/oneway.cpp
  4. 214
      samples/c/one_way_sample.cpp
  5. 2
      samples/c/one_way_train_images.txt

34
modules/features2d/include/opencv2/features2d/features2d.hpp
Unescape View File

@ -1024,6 +1024,12 @@ public:
const char* pca_hr_config = 0, const char* pca_desc_config = 0, int pyr_levels = 1,
int pca_dim_high = 100, int pca_dim_low = 100);
OneWayDescriptorBase(CvSize patch_size, int pose_count, const string &pca_filename, const string &train_path = string(), const string &images_list = string(),
int pyr_levels = 1,
int pca_dim_high = 100, int pca_dim_low = 100);
~OneWayDescriptorBase();
// Allocate: allocates memory for a given number of descriptors
@ -1111,6 +1117,15 @@ public:
// - filename: output filename
void SavePCADescriptors(const char* filename);
// SavePCADescriptors: saves PCA descriptors to a file storage
// - fs: output file storage
void SavePCADescriptors(CvFileStorage* fs);
// GeneratePCA: calculate and save PCA components and descriptors
// - img_path: path to training PCA images directory
// - images_list: filename with filenames of training PCA images
void GeneratePCA(const char* img_path, const char* images_list);
// SetPCAHigh: sets the high resolution pca matrices (copied to internal structures)
void SetPCAHigh(CvMat* avg, CvMat* eigenvectors);
@ -1129,6 +1144,8 @@ public:
void ConvertDescriptorsArrayToTree(); // Converting pca_descriptors array to KD tree
// GetPCAFilename: get default PCA filename
static string GetPCAFilename () { return "pca.yml"; }
protected:
CvSize m_patch_size; // patch size
@ -1151,7 +1168,6 @@ protected:
int m_pca_dim_low;
int m_pyr_levels;
};
class CV_EXPORTS OneWayDescriptorObject : public OneWayDescriptorBase
@ -1168,6 +1184,11 @@ public:
OneWayDescriptorObject(CvSize patch_size, int pose_count, const char* train_path, const char* pca_config,
const char* pca_hr_config = 0, const char* pca_desc_config = 0, int pyr_levels = 1);
OneWayDescriptorObject(CvSize patch_size, int pose_count, const string &pca_filename,
const string &train_path = string (), const string &images_list = string (), int pyr_levels = 1);
~OneWayDescriptorObject();
// Allocate: allocates memory for a given number of features
@ -1690,19 +1711,20 @@ public:
Params( int _poseCount = POSE_COUNT,
Size _patchSize = Size(PATCH_WIDTH, PATCH_HEIGHT),
string _pcaFilename = string (),
string _trainPath = string(),
string _pcaConfig = string(), string _pcaHrConfig = string(),
string _pcaDescConfig = string(),
string _trainImagesList = string(),
float _minScale = GET_MIN_SCALE(), float _maxScale = GET_MAX_SCALE(),
float _stepScale = GET_STEP_SCALE() ) :
poseCount(_poseCount), patchSize(_patchSize), trainPath(_trainPath),
pcaConfig(_pcaConfig), pcaHrConfig(_pcaHrConfig), pcaDescConfig(_pcaDescConfig),
poseCount(_poseCount), patchSize(_patchSize), pcaFilename(_pcaFilename),
trainPath(_trainPath), trainImagesList(_trainImagesList),
minScale(_minScale), maxScale(_maxScale), stepScale(_stepScale) {}
int poseCount;
Size patchSize;
string pcaFilename;
string trainPath;
string pcaConfig, pcaHrConfig, pcaDescConfig;
string trainImagesList;
float minScale, maxScale, stepScale;
};

10
modules/features2d/src/descriptors.cpp
Unescape View File

@ -203,9 +203,8 @@ void OneWayDescriptorMatch::initialize( const Params& _params)
void OneWayDescriptorMatch::add( const Mat& image, vector<KeyPoint>& keypoints )
{
if( base.empty() )
base = new OneWayDescriptorObject( params.patchSize, params.poseCount, params.trainPath.c_str(),
params.pcaConfig.c_str(), params.pcaHrConfig.c_str(),
params.pcaDescConfig.c_str());
base = new OneWayDescriptorObject( params.patchSize, params.poseCount, params.pcaFilename,
params.trainPath, params.trainImagesList);
size_t trainFeatureCount = keypoints.size();
@ -225,9 +224,8 @@ void OneWayDescriptorMatch::add( const Mat& image, vector<KeyPoint>& keypoints )
void OneWayDescriptorMatch::add( KeyPointCollection& keypoints )
{
if( base.empty() )
base = new OneWayDescriptorObject( params.patchSize, params.poseCount, params.trainPath.c_str(),
params.pcaConfig.c_str(), params.pcaHrConfig.c_str(),
params.pcaDescConfig.c_str());
base = new OneWayDescriptorObject( params.patchSize, params.poseCount, params.pcaFilename,
params.trainPath, params.trainImagesList);
size_t trainFeatureCount = keypoints.calcKeypointCount();

246
modules/features2d/src/oneway.cpp
Unescape View File

@ -139,7 +139,14 @@ namespace cv{
}*/
}
void readPCAFeatures(const char* filename, CvMat** avg, CvMat** eigenvectors);
void readPCAFeatures(const char* filename, CvMat** avg, CvMat** eigenvectors, const char *postfix = "");
void savePCAFeatures(FileStorage &fs, const char* postfix, CvMat* avg, CvMat* eigenvectors);
void calcPCAFeatures(vector<IplImage*>& patches, FileStorage &fs, const char* postfix, CvMat** avg,
CvMat** eigenvectors);
void loadPCAFeatures(const char* path, const char* images_list, vector<IplImage*>& patches, CvSize patch_size);
void generatePCAFeatures(const char* path, const char* img_filename, FileStorage& fs, const char* postfix,
CvSize patch_size, CvMat** avg, CvMat** eigenvectors);
void eigenvector2image(CvMat* eigenvector, IplImage* img);
void FindOneWayDescriptor(int desc_count, const OneWayDescriptor* descriptors, IplImage* patch, int& desc_idx, int& pose_idx, float& distance,
@ -1261,7 +1268,49 @@ namespace cv{
// SavePCADescriptors("./pca_descriptors.yml");
}
OneWayDescriptorBase::OneWayDescriptorBase(CvSize patch_size, int pose_count, const string &pca_filename,
const string &train_path, const string &images_list, int pyr_levels,
int pca_dim_high, int pca_dim_low) : m_pca_dim_high(pca_dim_high), m_pca_dim_low(pca_dim_low)
{
// m_pca_descriptors_matrix = 0;
m_patch_size = patch_size;
m_pose_count = pose_count;
m_pyr_levels = pyr_levels;
m_poses = 0;
m_transforms = 0;
m_pca_avg = 0;
m_pca_eigenvectors = 0;
m_pca_hr_avg = 0;
m_pca_hr_eigenvectors = 0;
m_pca_descriptors = 0;
m_descriptors = 0;
CvFileStorage* fs = cvOpenFileStorage(pca_filename.c_str(), NULL, CV_STORAGE_READ);
if (fs != 0)
{
cvReleaseFileStorage(&fs);
readPCAFeatures(pca_filename.c_str(), &m_pca_avg, &m_pca_eigenvectors, "_lr");
readPCAFeatures(pca_filename.c_str(), &m_pca_hr_avg, &m_pca_hr_eigenvectors, "_hr");
m_pca_descriptors = new OneWayDescriptor[m_pca_dim_high + 1];
#if !defined(_GH_REGIONS)
LoadPCADescriptors(pca_filename.c_str());
#endif //_GH_REGIONS
}
else
{
GeneratePCA(train_path.c_str(), images_list.c_str());
m_pca_descriptors = new OneWayDescriptor[m_pca_dim_high + 1];
char pca_default_filename[1024];
sprintf(pca_default_filename, "%s/%s", train_path.c_str(), GetPCAFilename().c_str());
LoadPCADescriptors(pca_default_filename);
}
}
OneWayDescriptorBase::~OneWayDescriptorBase()
{
cvReleaseMat(&m_pca_avg);
@ -1554,20 +1603,170 @@ namespace cv{
return 1;
}
void savePCAFeatures(FileStorage &fs, const char* postfix, CvMat* avg, CvMat* eigenvectors)
{
char buf[1024];
sprintf(buf, "avg_%s", postfix);
fs.writeObj(buf, avg);
sprintf(buf, "eigenvectors_%s", postfix);
fs.writeObj(buf, eigenvectors);
}
void calcPCAFeatures(vector<IplImage*>& patches, FileStorage &fs, const char* postfix, 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(fs, postfix, *avg, *eigenvectors);
cvReleaseMat(&data);
cvReleaseMat(&eigenvalues);
}
void loadPCAFeatures(const char* path, const char* images_list, vector<IplImage*>& patches, CvSize patch_size)
{
char images_filename[1024];
sprintf(images_filename, "%s/%s", path, images_list);
FILE *pFile = fopen(images_filename, "r");
if (pFile == 0)
{
printf("Cannot open images list file %s\n", images_filename);
return;
}
while (!feof(pFile))
{
char imagename[1024];
if (fscanf(pFile, "%s", imagename) <= 0)
{
break;
}
char filename[1024];
sprintf(filename, "%s/%s", path, imagename);
//printf("Reading image %s...", filename);
IplImage* img = cvLoadImage(filename, 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, extracted %d features\n", (int)features.size());
cvReleaseImage(&img);
}
fclose(pFile);
}
void generatePCAFeatures(const char* path, const char* img_filename, FileStorage& fs, const char* postfix,
CvSize patch_size, CvMat** avg, CvMat** eigenvectors)
{
vector<IplImage*> patches;
loadPCAFeatures(path, img_filename, patches, patch_size);
calcPCAFeatures(patches, fs, postfix, avg, eigenvectors);
}
void OneWayDescriptorBase::GeneratePCA(const char* img_path, const char* images_list)
{
char pca_filename[1024];
sprintf(pca_filename, "%s/%s", img_path, GetPCAFilename().c_str());
FileStorage fs = FileStorage(pca_filename, FileStorage::WRITE);
generatePCAFeatures(img_path, images_list, fs, "hr", m_patch_size, &m_pca_hr_avg, &m_pca_hr_eigenvectors);
generatePCAFeatures(img_path, images_list, fs, "lr", cvSize(m_patch_size.width / 2, m_patch_size.height / 2),
&m_pca_avg, &m_pca_eigenvectors);
const int pose_count = 500;
OneWayDescriptorBase descriptors(m_patch_size, pose_count);
descriptors.SetPCAHigh(m_pca_hr_avg, m_pca_hr_eigenvectors);
descriptors.SetPCALow(m_pca_avg, m_pca_eigenvectors);
printf("Calculating %d PCA descriptors (you can grab a coffee, this will take a while)...\n",
descriptors.GetPCADimHigh());
descriptors.InitializePoseTransforms();
descriptors.CreatePCADescriptors();
descriptors.SavePCADescriptors(*fs);
fs.release();
}
void OneWayDescriptorBase::SavePCADescriptors(const char* filename)
{
CvMemStorage* storage = cvCreateMemStorage();
CvFileStorage* fs = cvOpenFileStorage(filename, storage, CV_STORAGE_WRITE);
SavePCADescriptors (fs);
cvReleaseMemStorage(&storage);
cvReleaseFileStorage(&fs);
}
void OneWayDescriptorBase::SavePCADescriptors(CvFileStorage *fs)
{
cvWriteInt(fs, "pca components number", m_pca_dim_high);
cvWriteComment(fs, "The first component is the average Vector, so the total number of components is <pca components number> + 1", 0);
cvWriteComment(
fs,
"The first component is the average Vector, so the total number of components is <pca components number> + 1",
0);
cvWriteInt(fs, "patch width", m_patch_size.width);
cvWriteInt(fs, "patch height", m_patch_size.height);
// pack the affine transforms into a single CvMat and write them
CvMat* poses = cvCreateMat(m_pose_count, 4, CV_32FC1);
for(int i = 0; i < m_pose_count; i++)
for (int i = 0; i < m_pose_count; i++)
{
cvmSet(poses, i, 0, m_poses[i].phi);
cvmSet(poses, i, 1, m_poses[i].theta);
@ -1576,18 +1775,16 @@ namespace cv{
}
cvWrite(fs, "affine poses", poses);
cvReleaseMat(&poses);
for(int i = 0; i < m_pca_dim_high + 1; i++)
for (int i = 0; i < m_pca_dim_high + 1; i++)
{
char buf[1024];
sprintf(buf, "descriptor for pca component %d", i);
m_pca_descriptors[i].Write(fs, buf);
}
cvReleaseMemStorage(&storage);
cvReleaseFileStorage(&fs);
}
void OneWayDescriptorBase::Allocate(int train_feature_count)
{
m_train_feature_count = train_feature_count;
@ -1728,6 +1925,14 @@ namespace cv{
m_part_id = 0;
}
OneWayDescriptorObject::OneWayDescriptorObject(CvSize patch_size, int pose_count, const string &pca_filename,
const string &train_path, const string &images_list, int pyr_levels) :
OneWayDescriptorBase(patch_size, pose_count, pca_filename, train_path, images_list, pyr_levels)
{
m_part_id = 0;
}
OneWayDescriptorObject::~OneWayDescriptorObject()
{
delete []m_part_id;
@ -1771,24 +1976,27 @@ namespace cv{
}
}
void readPCAFeatures(const char* filename, CvMat** avg, CvMat** eigenvectors)
void readPCAFeatures(const char* filename, CvMat** avg, CvMat** eigenvectors, const char* postfix)
{
CvMemStorage* storage = cvCreateMemStorage();
CvFileStorage* fs = cvOpenFileStorage(filename, storage, CV_STORAGE_READ);
if(!fs)
if (!fs)
{
printf("Cannot open file %s! Exiting!", filename);
cvReleaseMemStorage(&storage);
}
CvFileNode* node = cvGetFileNodeByName(fs, 0, "avg");
char buf[1024];
sprintf(buf, "avg%s", postfix);
CvFileNode* node = cvGetFileNodeByName(fs, 0, buf);
CvMat* _avg = (CvMat*)cvRead(fs, node);
node = cvGetFileNodeByName(fs, 0, "eigenvectors");
sprintf(buf, "eigenvectors%s", postfix);
node = cvGetFileNodeByName(fs, 0, buf);
CvMat* _eigenvectors = (CvMat*)cvRead(fs, node);
*avg = cvCloneMat(_avg);
*eigenvectors = cvCloneMat(_eigenvectors);
cvReleaseMat(&_avg);
cvReleaseMat(&_eigenvectors);
cvReleaseFileStorage(&fs);

214
samples/c/one_way_sample.cpp
Unescape View File

@ -15,42 +15,26 @@
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);
IplImage* DrawCorrespondences(IplImage* img1, const vector<KeyPoint>& features1, IplImage* img2,
const vector<KeyPoint>& features2, const vector<int>& desc_idx);
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 char images_list[] = "one_way_train_images.txt";
const CvSize patch_size = cvSize(24, 24);
const int pose_count = 50;
if(argc != 3 && argc != 4)
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);
@ -58,213 +42,69 @@ int main(int argc, char** argv)
// 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");
// 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);
printf("Training one way descriptors... \n");
// create descriptors
OneWayDescriptorBase descriptors(patch_size, pose_count, OneWayDescriptorBase::GetPCAFilename(), path_name,
images_list);
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++)
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* 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);
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++)
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++)
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);
return img_corr;
}

2
samples/c/one_way_train_images.txt
Unescape View File

@ -0,0 +1,2 @@
one_way_train_0000.jpg
one_way_train_0001.jpg
Write Preview
Loading…
Cancel
Save