int main(int argc, char** argv)
{
float a[]={ 0.234400724097, 0.445210153051, 0.420883079381, 0.0584111370634, 0.930917795284, 0.463946380108, 0.827477442854, 0.195052690912,
0.224843236267, 0.011674592046, 0.778465234345, 0.795119566607, 0.834330061452, 0.250878254601, 0.907848368295, 0.159768191396,
0.359447753375, 0.694377176768, 0.323279688498, 0.590454463022, 0.32053508251, 0.25926247011, 0.473382632749, 0.680857359827,
0.871843303433, 0.347550207092, 0.807721675262, 0.51342440135, 0.633862634367, 0.588847708996, 0.604920986251, 0.9485023141,
0.511286105241, 0.780677021392, 0.346168472115, 0.408572254219, 0.977881372787, 0.994457177414, 0.553713182589, 0.181657338197,
0.188679332574, 0.138351555791, 0.549762090688, 0.763422732648, 0.270469815182, 0.368094710756, 0.28652717945, 0.344130955251,
0.808703681865, 0.48242375244, 0.0961390490465, 0.585178232015, 0.0947071702324, 0.00663925147531, 0.409282147388, 0.865532591897,
0.233760414088, 0.399258033215, 0.547551739688, 0.078241816204, 0.672857401346, 0.083814529556, 0.68575517509, 0.213487218459 };
vector<int> labels = {1,1,1,1,1,2,1,2};
Mat data(Size(8,8), CV_32F, a);
//cout << data << endl;
PCA pca;
LDA lda;
pca(data, Mat(), CV_PCA_DATA_AS_ROW, 7);
//cout << pca.project(data) << endl;
lda.compute(pca.project(data), labels);
cout << lda.project(pca.project(data)) << endl;
//cout << lda.reconstruct(lda.project(pca.project(data))) << endl;
return 0;
}
//Rate a location on how likely it is to be a bubble
double rateBubble(Mat& det_img_gray, Point bubble_location, PCA& my_PCA){
Mat query_pixels, pca_components;
getRectSubPix(det_img_gray, Point(14,18), bubble_location, query_pixels);
query_pixels.reshape(0,1).convertTo(query_pixels, CV_32F);
pca_components = my_PCA.project(query_pixels);
//The rating is the SSD of query pixels and their back projection
Mat out = my_PCA.backProject(pca_components)- query_pixels;
return sum(out.mul(out)).val[0];
}
void columbiaTest(int testId = 0)
{
CascadeClassifier classifier;
classifier.load("haarcascades/haarcascade_frontalface_alt_tree.xml");
ShapePredictor predictor;
predictor.load("model/helen.txt");
PCA pca;
FileStorage fs("model/pca.xml", FileStorage::READ);
fs["mean"] >> pca.mean;
fs["eigenvals"] >> pca.eigenvalues;
fs["eigenvecs"] >> pca.eigenvectors;
fs.release();
/*LDA lda;
lda.load("model/lda.xml");*/
SVM svm;
svm.load("model/svm.xml");
cout << "\nmodel loaded" << endl;
// test prediction
cout << "\nbegin test" << endl;
int corr = 0, total = 0;
Mat_<float> labels, multihog, ldmks;
collectData(testId, classifier, predictor,
labels, multihog, ldmks);
for (int i = 0; i < multihog.rows; i++) {
Mat_<float> pcaVec = pca.project(multihog.row(i));
Mat_<float> datVec(1, pcaVec.cols + ldmks.cols);
for (int j = 0; j < pcaVec.cols; j++)
datVec(0, j) = pcaVec(0, j);
for (int j = 0; j < ldmks.cols; j++)
datVec(0, j + pcaVec.cols) = ldmks(i, j);
//Mat_<float> ldaVec = lda.project(datVec);
float pred = svm.predict(datVec);
if ((int)pred == (int)labels(i, 0))
corr++;
total++;
}
cout << "testId = " << testId << endl;
cout << "corr = " << corr << " , total = " << total << endl;
cout << "percentage: " << (double)corr / total << endl;
ofstream fout("data/testId" + to_string(testId) + ".txt");
fout << "corr = " << corr << " , total = " << total << endl;
fout << "percentage: " << (double)corr / total << endl;
fout.close();
}
void test_pca9685(PCA & pca)
{
//Rise
float val = 0.0f;
for(; val < 1.0; val += 0.001f)
{
for(unsigned i = 0; i < 15; ++i)
pca.set_channel_pulse_width(i, val);
}
//Fall
for(; val > 0.0; val -= 0.001f)
for(unsigned i = 0; i < 15; ++i)
pca.set_channel_pulse_width(i, val);
}
int
predict(PCA &pca, Mat &train, Mat face, double threshold = 0.3, double distance = 44000){
Mat w = pca.project(face);
Mat predicted = pca.backProject(w);
int label = -1;
double min = distance * threshold;
for(int i = 0; i < 15; i++){
for(int j = 0; j < 8; j++){
double d = norm(predicted, train.row((i*8) + j));
if(d < min){
min = d;
label = i;
}
}
}
return label;
}
void compressFeature( string filename, std::vector< std::vector<float> > &models, const int dim, bool ascii ){
PCA pca;
pca.read( filename.c_str(), ascii );
VectorXf variance = pca.getVariance();
MatrixXf tmpMat = pca.getAxis();
MatrixXf tmpMat2 = tmpMat.block(0,0,tmpMat.rows(),dim);
const int num = (int)models.size();
for( int i=0; i<num; i++ ){
Map<VectorXf> vec( &(models[i][0]), models[i].size() );
//vec = tmpMat2.transpose() * vec;
VectorXf tmpvec = tmpMat2.transpose() * vec;
models[i].resize( dim );
if( WHITENING ){
for( int t=0; t<dim; t++ )
models[i][t] = tmpvec[t] / sqrt( variance( t ) );
}
else{
for( int t=0; t<dim; t++ )
models[i][t] = tmpvec[t];
}
}
}
void PCANormalEstimator::estimateNormals(vtkPolyData* data, double neighRadius)
{
vtkPointLocator* locator = vtkPointLocator::New();
locator->SetDataSet(data);
locator->BuildLocator();
int i, numOfPoints = data->GetNumberOfPoints();
vtkDoubleArray* normals = vtkDoubleArray::New();
normals->SetNumberOfComponents(3);
normals->SetNumberOfTuples(numOfPoints);
PCA pca;
double p[3], com[3], eigenvals[3], eigenvecs[3][3];
vtkPoints* points = data->GetPoints();
vtkIdList* neighs = vtkIdList::New();
for ( i = 0 ; i < numOfPoints ; ++i )
{
points->GetPoint(i, p);
neighs->Reset();
locator->FindPointsWithinRadius(neighRadius, p, neighs);
if ( neighs->GetNumberOfIds() < 3 )
{
normals->SetTuple3(i, 0.0, 0.0, 0.0);
continue;
}
// Perform PCA
pca.doPCA(points, neighs, eigenvecs, eigenvals, com);
// Save the normal
normals->SetTuple3(i, eigenvecs[0][2], eigenvecs[1][2], eigenvecs[2][2]);
}
data->GetPointData()->SetNormals(normals);
// Clean up
locator->Delete();
normals->Delete();
neighs->Delete();
}
//We should probably encapsulate the PCA stuff...
void train_PCA_classifier(Mat& train_img_gray, PCA& my_PCA, Mat& comparison_vectors){
//Goes though all the selected bubble locations and puts their pixels into rows of
//a giant matrix called so we can perform PCA on them (we need at least 3 locations to do this)
Mat PCA_set = Mat::zeros(bubble_locations.size(), 18*14, CV_32F);
for(size_t i = 0; i < bubble_locations.size(); i+=1) {
Mat PCA_set_row;
getRectSubPix(train_img_gray, Point(14,18), bubble_locations[i], PCA_set_row);
PCA_set_row.convertTo(PCA_set_row, CV_32F);
PCA_set.row(i) += PCA_set_row.reshape(0,1);
}
my_PCA = PCA(PCA_set, Mat(), CV_PCA_DATA_AS_ROW, 5);
comparison_vectors = my_PCA.project(PCA_set);
}
void MTT::doPCA(RoadGraph* roads, PCA& pca) {
// 頂点データを使って行列を生成する
cv::Mat vmat = cv::Mat(GraphUtil::getNumVertices(roads), 2, CV_64FC1);
int count = 0;
RoadVertexIter vi, vend;
for (boost::tie(vi, vend) = boost::vertices(roads->graph); vi != vend; ++vi) {
if (!roads->graph[*vi]->valid) continue;
vmat.at<double>(count, 0) = roads->graph[*vi]->getPt().x();
vmat.at<double>(count, 1) = roads->graph[*vi]->getPt().y();
count++;
}
// PCAを実施
pca.pca(vmat, false);
}
// according to http://www.pcl-users.org/Finding-oriented-bounding-box-of-a-cloud-td4024616.html
FitCube PCLTools::fitBox(PointCloud<PointXYZ>::Ptr cloud) {
FitCube retCube;
PCA<PointXYZ> pca;
PointCloud<PointXYZ> proj;
pca.setInputCloud(cloud);
pca.project(*cloud, proj);
PointXYZ proj_min;
PointXYZ proj_max;
getMinMax3D(proj, proj_min, proj_max);
PointXYZ min;
PointXYZ max;
pca.reconstruct(proj_min, min);
pca.reconstruct(proj_max, max);
// Rotation of PCA
Eigen::Matrix3f rot_mat = pca.getEigenVectors();
// Translation of PCA
Eigen::Vector3f cl_translation = pca.getMean().head(3);
Eigen::Matrix3f affine_trans;
// Reordering of principal components
affine_trans.col(2) << (rot_mat.col(0).cross(rot_mat.col(1))).normalized();
affine_trans.col(0) << rot_mat.col(0);
affine_trans.col(1) << rot_mat.col(1);
retCube.rotation = Eigen::Quaternionf(affine_trans);
Eigen::Vector4f t = pca.getMean();
retCube.translation = Eigen::Vector3f(t.x(), t.y(), t.z());
retCube.width = fabs(proj_max.x - proj_min.x);
retCube.height = fabs(proj_max.y - proj_min.y);
retCube.depth = fabs(proj_max.z - proj_min.z);
return retCube;
}
vector<float> ReconnaissanceHandler::recognisePCA(vector<float>& caracteristicVector, PCA pca, vector<vector<float>>& classes)
{
Mat v(caracteristicVector.size(),1, CV_32F);
int i = 0;
for (float f : caracteristicVector) {
v.at<float>(i, 0) = f;
++i;
}
Mat reduceVector = pca.project(v);
vector<float> caractReduced;
for (i = 0; i < reduceVector.rows; ++i) {
caractReduced.push_back(reduceVector.at<float>(i, 0));
}
vector<float> dist;
for (int i = 0; i < classes.size(); ++i)
{
dist.push_back(distanceVector(caractReduced, classes.at(i)));
}
return dist;
}
//Compare the bubbles with all the bubbles used in the classifier.
bubble_val checkBubble(Mat& det_img_gray, Point bubble_location, PCA& my_PCA, Mat& comparison_vectors, Point search_window=Point(5,5)){
Mat query_pixels;
//This bit of code finds the location in the search_window most likely to be a bubble
//then it checks that rather than the exact specified location.
Mat out = Mat::zeros(Size(search_window.y, search_window.x) , CV_32FC1);
Point offset = Point(bubble_location.x - search_window.x/2, bubble_location.y - search_window.y/2);
for(size_t i = 0; i < search_window.y; i+=1) {
for(size_t j = 0; j < search_window.x; j+=1) {
out.row(i).col(j) += rateBubble(det_img_gray, Point(j,i) + offset, my_PCA);
}
}
Point min_location;
minMaxLoc(out, NULL,NULL, &min_location);
getRectSubPix(det_img_gray, Point(14,18), min_location + offset, query_pixels);
query_pixels.reshape(0,1).convertTo(query_pixels, CV_32F);
Point max_location;
matchTemplate(comparison_vectors, my_PCA.project(query_pixels), out, CV_TM_CCOEFF_NORMED);
minMaxLoc(out, NULL,NULL,NULL, &max_location);
return bubble_values[max_location.y];
}
//********************************
//* main
int main(int argc, char* argv[]) {
if( (argc != 13) && (argc != 15) ){
std::cerr << "usage: " << argv[0] << " [path] <rank_num> <exist_voxel_num_threshold> [model_pca_filename] <dim_model> <size1> <size2> <size3> <detect_th> <distance_th> <model_num> /input:=/camera/rgb/points" << std::endl;
exit( EXIT_FAILURE );
}
char tmpname[ 1000 ];
ros::init (argc, argv, "detect_object_vosch_multi", ros::init_options::AnonymousName);
// read the length of voxel side
sprintf( tmpname, "%s/param/parameters.txt", argv[1] );
voxel_size = Param::readVoxelSize( tmpname );
detect_th = atof( argv[9] );
distance_th = atof( argv[10] );
model_num = atoi( argv[11] );
rank_num = atoi( argv[2] );
// set marker color
const int marker_model_num = 6;
if( model_num > marker_model_num ){
std::cerr << "Please set more marker colors for detection of more than " << marker_model_num << " objects." << std::endl;
exit( EXIT_FAILURE );
}
marker_color_r = new float[ marker_model_num ];
marker_color_g = new float[ marker_model_num ];
marker_color_b = new float[ marker_model_num ];
marker_color_r[ 0 ] = 1.0; marker_color_g[ 0 ] = 0.0; marker_color_b[ 0 ] = 0.0; // red
marker_color_r[ 1 ] = 0.0; marker_color_g[ 1 ] = 1.0; marker_color_b[ 1 ] = 0.0; // green
marker_color_r[ 2 ] = 0.0; marker_color_g[ 2 ] = 0.0; marker_color_b[ 2 ] = 1.0; // blue
marker_color_r[ 3 ] = 1.0; marker_color_g[ 3 ] = 1.0; marker_color_b[ 3 ] = 0.0; // yellow
marker_color_r[ 4 ] = 0.0; marker_color_g[ 4 ] = 1.0; marker_color_b[ 4 ] = 1.0; // cyan
marker_color_r[ 5 ] = 1.0; marker_color_g[ 5 ] = 0.0; marker_color_b[ 5 ] = 1.0; // magenta
// marker_color_r[ 0 ] = 0.0; marker_color_g[ 0 ] = 1.0; marker_color_b[ 0 ] = 0.0; // green
// marker_color_r[ 1 ] = 0.0; marker_color_g[ 1 ] = 0.0; marker_color_b[ 1 ] = 1.0; // blue
// marker_color_r[ 2 ] = 0.0; marker_color_g[ 2 ] = 1.0; marker_color_b[ 2 ] = 1.0; // cyan
// marker_color_r[ 3 ] = 1.0; marker_color_g[ 3 ] = 0.0; marker_color_b[ 3 ] = 0.0; // pink
// read the number of voxels in each subdivision's side of scene
box_size = Param::readBoxSizeScene( tmpname );
// read the dimension of compressed feature vectors
dim = Param::readDim( tmpname );
const int dim_model = atoi(argv[5]);
if( dim <= dim_model ){
std::cerr << "ERR: dim_model should be less than dim(in dim.txt)" << std::endl;
exit( EXIT_FAILURE );
}
// read the threshold for RGB binalize
sprintf( tmpname, "%s/param/color_threshold.txt", argv[1] );
Param::readColorThreshold( color_threshold_r, color_threshold_g, color_threshold_b, tmpname );
// determine the size of sliding box
region_size = box_size * voxel_size;
float tmp_val = atof(argv[6]) / region_size;
int size1 = (int)tmp_val;
if( ( ( tmp_val - size1 ) >= 0.5 ) || ( size1 == 0 ) ) size1++;
tmp_val = atof(argv[7]) / region_size;
int size2 = (int)tmp_val;
if( ( ( tmp_val - size2 ) >= 0.5 ) || ( size2 == 0 ) ) size2++;
tmp_val = atof(argv[8]) / region_size;
int size3 = (int)tmp_val;
if( ( ( tmp_val - size3 ) >= 0.5 ) || ( size3 == 0 ) ) size3++;
sliding_box_size_x = size1 * region_size;
sliding_box_size_y = size2 * region_size;
sliding_box_size_z = size3 * region_size;
// set variables
search_obj.setModelNum( model_num );
#ifdef CCHLAC_TEST
sprintf( tmpname, "%s/param/max_c.txt", argv[1] );
#else
sprintf( tmpname, "%s/param/max_r.txt", argv[1] );
#endif
search_obj.setNormalizeVal( tmpname );
search_obj.setRange( size1, size2, size3 );
search_obj.setRank( rank_num * model_num ); // for removeOverlap()
search_obj.setThreshold( atoi(argv[3]) );
// read projection axes of the target objects' subspace
FILE *fp = fopen( argv[4], "r" );
char **model_file_names = new char* [ model_num ];
char line[ 1000 ];
for( int i=0; i<model_num; i++ ){
model_file_names[ i ] = new char [ 1000 ];
if( fgets( line, sizeof(line), fp ) == NULL ) std::cerr<<"fgets err"<<std::endl;
line[ strlen( line ) - 1 ] = '\0';
//fscanf( fp, "%s\n", model_file_names + i );
//model_file_names[ i ] = line;
sprintf( model_file_names[ i ], "%s", line );
//std::cout << model_file_names[ i ] << std::endl;
}
fclose(fp);
search_obj.readAxis( model_file_names, dim, dim_model, ASCII_MODE_P, MULTIPLE_SIMILARITY );
// read projection axis for feature compression
PCA pca;
sprintf( tmpname, "%s/models/compress_axis", argv[1] );
pca.read( tmpname, ASCII_MODE_P );
Eigen::MatrixXf tmpaxis = pca.getAxis();
Eigen::MatrixXf axis = tmpaxis.block( 0,0,tmpaxis.rows(),dim );
Eigen::MatrixXf axis_t = axis.transpose();
Eigen::VectorXf variance = pca.getVariance();
if( WHITENING )
search_obj.setSceneAxis( axis_t, variance, dim );
else
search_obj.setSceneAxis( axis_t );
// object detection
VoxelizeAndDetect vad;
vad.loop();
ros::spin();
return 0;
}
int main(int argc, char** argv)
{
string filter = "Gaussian";
string descriptor = "HAOG";
string database = "CUFSF";
uint count = 0;
vector<string> extraPhotos, photos, sketches;
loadImages(argv[1], photos);
loadImages(argv[2], sketches);
//loadImages(argv[7], extraPhotos);
uint nPhotos = photos.size(),
nSketches = sketches.size(),
nExtra = extraPhotos.size();
uint nTraining = 2*nPhotos/3;
cout << "Read " << nSketches << " sketches." << endl;
cout << "Read " << nPhotos + nExtra << " photos." << endl;
vector<Mat*> sketchesDescriptors(nSketches), photosDescriptors(nPhotos), extraDescriptors(nExtra);
Mat img, temp;
int size=32, delta=16;
#pragma omp parallel for private(img, temp)
for(uint i=0; i<nSketches; i++){
img = imread(sketches[i],0);
sketchesDescriptors[i] = new Mat();
#pragma omp critical
temp = extractDescriptors(img, size, delta, filter, descriptor);
*(sketchesDescriptors[i]) = temp.clone();
}
#pragma omp parallel for private(img, temp)
for(uint i=0; i<nPhotos; i++){
img = imread(photos[i],0);
photosDescriptors[i] = new Mat();
#pragma omp critical
temp = extractDescriptors(img, size, delta, filter, descriptor);
*(photosDescriptors[i]) = temp.clone();
}
#pragma omp parallel for private(img, temp)
for(uint i=0; i<nExtra; i++){
img = imread(extraPhotos[i],0);
extraDescriptors[i] = new Mat();
#pragma omp critical
temp = extractDescriptors(img, size, delta, filter, descriptor);
*(extraDescriptors[i]) = temp.clone();
}
auto seed = unsigned(count);
srand(seed);
random_shuffle(sketchesDescriptors.begin(), sketchesDescriptors.end());
srand(seed);
random_shuffle(photosDescriptors.begin(), photosDescriptors.end());
//training
vector<Mat*> trainingSketchesDescriptors, trainingPhotosDescriptors;
trainingSketchesDescriptors.insert(trainingSketchesDescriptors.end(), sketchesDescriptors.begin(), sketchesDescriptors.begin()+nTraining);
trainingPhotosDescriptors.insert(trainingPhotosDescriptors.end(), photosDescriptors.begin(), photosDescriptors.begin()+nTraining);
//testing
vector<Mat*> testingSketchesDescriptors, testingPhotosDescriptors;
testingSketchesDescriptors.insert(testingSketchesDescriptors.end(), sketchesDescriptors.begin()+nTraining, sketchesDescriptors.end());
testingPhotosDescriptors.insert(testingPhotosDescriptors.end(), photosDescriptors.begin()+nTraining, photosDescriptors.end());
testingPhotosDescriptors.insert(testingPhotosDescriptors.end(), extraDescriptors.begin(), extraDescriptors.end());
PCA pca;
LDA lda;
vector<int> labels;
uint nTestingSketches = testingSketchesDescriptors.size(),
nTestingPhotos = testingPhotosDescriptors.size();
for(uint i=0; i<nTraining; i++){
labels.push_back(i);
}
labels.insert(labels.end(),labels.begin(),labels.end());
//bags
vector<Mat*> testingSketchesDescriptorsBag(nTestingSketches), testingPhotosDescriptorsBag(nTestingPhotos);
for(int b=0; b<200; b++){
vector<int> bag_indexes = gen_bag(154, 0.1);
uint dim = (bag(*(trainingPhotosDescriptors[0]), bag_indexes, 154)).total();
Mat X(dim, 2*nTraining, CV_32F);
#pragma omp parallel for private(temp)
for(uint i=0; i<nTraining; i++){
temp = *(trainingSketchesDescriptors[i]);
temp = bag(temp, bag_indexes, 154);
temp.copyTo(X.col(i));
}
#pragma omp parallel for private(temp)
for(uint i=0; i<nTraining; i++){
temp = *(trainingPhotosDescriptors[i]);
temp = bag(temp, bag_indexes, 154);
temp.copyTo(X.col(i+nTraining));
}
Mat Xs = X(Range::all(), Range(0,nTraining));
Mat Xp = X(Range::all(), Range(nTraining,2*nTraining));
Mat meanX = Mat::zeros(dim, 1, CV_32F), instance;
Mat meanXs = Mat::zeros(dim, 1, CV_32F);
Mat meanXp = Mat::zeros(dim, 1, CV_32F);
// calculate sums
for (int i = 0; i < X.cols; i++) {
instance = X.col(i);
add(meanX, instance, meanX);
}
for (int i = 0; i < Xs.cols; i++) {
instance = Xs.col(i);
add(meanXs, instance, meanXs);
}
for (int i = 0; i < Xp.cols; i++) {
instance = Xp.col(i);
add(meanXp, instance, meanXp);
}
// calculate total mean
meanX.convertTo(meanX, CV_32F, 1.0/static_cast<double>(X.cols));
meanXs.convertTo(meanXs, CV_32F, 1.0/static_cast<double>(Xs.cols));
meanXp.convertTo(meanXp, CV_32F, 1.0/static_cast<double>(Xp.cols));
// subtract the mean of matrix
for(int i=0; i<X.cols; i++) {
Mat c_i = X.col(i);
subtract(c_i, meanX.reshape(1,dim), c_i);
}
for(int i=0; i<Xs.cols; i++) {
Mat c_i = Xs.col(i);
subtract(c_i, meanXs.reshape(1,dim), c_i);
}
for(int i=0; i<Xp.cols; i++) {
Mat c_i = Xp.col(i);
subtract(c_i, meanXp.reshape(1,dim), c_i);
}
if(meanX.total() >= nTraining)
pca(X, Mat(), CV_PCA_DATA_AS_COL, nTraining-1);
else
pca.computeVar(X, Mat(), CV_PCA_DATA_AS_COL, .99);
Mat W1 = pca.eigenvectors.t();
Mat ldaData = (W1.t()*X).t();
lda.compute(ldaData, labels);
Mat W2 = lda.eigenvectors();
W2.convertTo(W2, CV_32F);
Mat projectionMatrix = (W2.t()*W1.t()).t();
//testing
#pragma omp parallel for private(temp)
for(uint i=0; i<nTestingSketches; i++){
temp = *(testingSketchesDescriptors[i]);
temp = bag(temp, bag_indexes, 154);
temp = projectionMatrix.t()*(temp-meanX);
if(b==0){
testingSketchesDescriptorsBag[i] = new Mat();
*(testingSketchesDescriptorsBag[i]) = temp.clone();
}
else{
vconcat(*(testingSketchesDescriptorsBag[i]), temp, *(testingSketchesDescriptorsBag[i]));
}
}
#pragma omp parallel for private(temp)
for(uint i=0; i<nTestingPhotos; i++){
temp = *(testingPhotosDescriptors[i]);
temp = bag(temp, bag_indexes, 154);
temp = projectionMatrix.t()*(temp-meanX);
if(b==0){
testingPhotosDescriptorsBag[i] = new Mat();
*(testingPhotosDescriptorsBag[i]) = temp.clone();
}
else{
vconcat(*(testingPhotosDescriptorsBag[i]), temp, *(testingPhotosDescriptorsBag[i]));
}
}
}
Mat distancesChi = Mat::zeros(nTestingSketches,nTestingPhotos,CV_64F);
Mat distancesL2 = Mat::zeros(nTestingSketches,nTestingPhotos,CV_64F);
Mat distancesCosine = Mat::zeros(nTestingSketches,nTestingPhotos,CV_64F);
#pragma omp parallel for
for(uint i=0; i<nTestingSketches; i++){
for(uint j=0; j<nTestingPhotos; j++){
distancesChi.at<double>(i,j) = chiSquareDistance(*(testingSketchesDescriptorsBag[i]),*(testingPhotosDescriptorsBag[j]));
distancesL2.at<double>(i,j) = norm(*(testingSketchesDescriptorsBag[i]),*(testingPhotosDescriptorsBag[j]));
distancesCosine.at<double>(i,j) = abs(1-cosineDistance(*(testingSketchesDescriptorsBag[i]),*(testingPhotosDescriptorsBag[j])));
}
}
string file1name = "kernel-drs-" + descriptor + database + to_string(nTraining) + string("chi") + to_string(count) + string(".xml");
string file2name = "kernel-drs-" + descriptor + database + to_string(nTraining) + string("l2") + to_string(count) + string(".xml");
string file3name = "kernel-drs-" + descriptor + database + to_string(nTraining) + string("cosine") + to_string(count) + string(".xml");
FileStorage file1(file1name, FileStorage::WRITE);
FileStorage file2(file2name, FileStorage::WRITE);
FileStorage file3(file3name, FileStorage::WRITE);
file1 << "distanceMatrix" << distancesChi;
file2 << "distanceMatrix" << distancesL2;
file3 << "distanceMatrix" << distancesCosine;
file1.release();
file2.release();
file3.release();
return 0;
}
void
FMR_FNMR(PCA &pca, Mat &train, Mat &test, double step = 0.05, double distance = 44000.0){
struct stat {
double total{0}, match{0};
double res() { return match/total; }
};
Mat w, r;
cout << "Threshold;" << "FMR;" << "FNMR;" << "ROC TP;" << "ROC FP" << endl;
for(double t = 0.0; t <= 1.000001; t += step) {
double min = distance * t;
stat fmr, fnmr;
for(int i = 0; i < 15; i++){
for(int j = 0; j < 3; j++){
Mat face = test.row((i*3) + j);
pca.project(face, w);
pca.backProject(w, r);
for(int k = 0; k < 15; k++) {
if(k == i){
// FNMR
for(int l = 0; l < 8; l++) {
double d = norm(r, train.row((k*8) + l));
if(d > min){
fnmr.match++;
}
// else {
// ROC TP
// }
fnmr.total++;
}
} else {
// FMR
for(int l = 0; l < 8; l++){
double d = norm(r, train.row((k*8) + l));
if(d < min){
fmr.match++;
// ROC FP
}
fmr.total++;
}
}
}
}
}
cout << 1-t << ";"
<< fmr.res() << ";"
<< fnmr.res() << ";"
<< ((fnmr.total-fnmr.match)/fnmr.total) << ";"
<< fmr.res() << endl;
}
}
Melder_help (L"CrossCorrelationTable");
END
DIRECT (CrossCorrelationTable_to_PCA)
LOOP {
iam (CrossCorrelationTable);
praat_new (SSCP_to_PCA (me), my name);
}
END
FORM (Sound_and_PCA_projectChannels, L"Sound & PCA: To Sound (project channels)", 0)
NATURAL (L"Number of components", L"10")
OK
DO
Sound me = FIRST (Sound);
PCA thee = FIRST (PCA);
praat_new (Sound_and_PCA_projectChannels (me, thee, GET_INTEGER (L"Number of components")), Thing_getName (me), L"_projected");
END
FORM (Sound_and_PCA_whitenChannels, L"Sound & PCA: To Sound (whiten channels)", 0)
NATURAL (L"Number of components", L"10")
OK
DO
Sound me = FIRST (Sound);
PCA thee = FIRST (PCA);
praat_new (Sound_and_PCA_whitenChannels (me, thee, GET_INTEGER (L"Number of components")), Thing_getName (me), L"_white");
END
DIRECT (CrossCorrelationTable_to_CrossCorrelationTables)
autoCrossCorrelationTables thee = CrossCorrelationTables_create ();
long nrows = 0, ncols = 0, nselected = 0;
void run(int)
{
const Size sz(200, 500);
double diffPrjEps, diffBackPrjEps,
prjEps, backPrjEps,
evalEps, evecEps;
int maxComponents = 100;
double retainedVariance = 0.95;
Mat rPoints(sz, CV_32FC1), rTestPoints(sz, CV_32FC1);
RNG& rng = ts->get_rng();
rng.fill( rPoints, RNG::UNIFORM, Scalar::all(0.0), Scalar::all(1.0) );
rng.fill( rTestPoints, RNG::UNIFORM, Scalar::all(0.0), Scalar::all(1.0) );
PCA rPCA( rPoints, Mat(), CV_PCA_DATA_AS_ROW, maxComponents ), cPCA;
// 1. check C++ PCA & ROW
Mat rPrjTestPoints = rPCA.project( rTestPoints );
Mat rBackPrjTestPoints = rPCA.backProject( rPrjTestPoints );
Mat avg(1, sz.width, CV_32FC1 );
reduce( rPoints, avg, 0, CV_REDUCE_AVG );
Mat Q = rPoints - repeat( avg, rPoints.rows, 1 ), Qt = Q.t(), eval, evec;
Q = Qt * Q;
Q = Q /(float)rPoints.rows;
eigen( Q, eval, evec );
/*SVD svd(Q);
evec = svd.vt;
eval = svd.w;*/
Mat subEval( maxComponents, 1, eval.type(), eval.data ),
subEvec( maxComponents, evec.cols, evec.type(), evec.data );
#ifdef CHECK_C
Mat prjTestPoints, backPrjTestPoints, cPoints = rPoints.t(), cTestPoints = rTestPoints.t();
CvMat _points, _testPoints, _avg, _eval, _evec, _prjTestPoints, _backPrjTestPoints;
#endif
// check eigen()
double eigenEps = 1e-6;
double err;
for(int i = 0; i < Q.rows; i++ )
{
Mat v = evec.row(i).t();
Mat Qv = Q * v;
Mat lv = eval.at<float>(i,0) * v;
err = cvtest::norm( Qv, lv, NORM_L2 );
if( err > eigenEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of eigen(); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
}
// check pca eigenvalues
evalEps = 1e-6, evecEps = 1e-3;
err = cvtest::norm( rPCA.eigenvalues, subEval, NORM_L2 );
if( err > evalEps )
{
ts->printf( cvtest::TS::LOG, "pca.eigenvalues is incorrect (CV_PCA_DATA_AS_ROW); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
// check pca eigenvectors
for(int i = 0; i < subEvec.rows; i++)
{
Mat r0 = rPCA.eigenvectors.row(i);
Mat r1 = subEvec.row(i);
err = cvtest::norm( r0, r1, CV_L2 );
if( err > evecEps )
{
r1 *= -1;
double err2 = cvtest::norm(r0, r1, CV_L2);
if( err2 > evecEps )
{
Mat tmp;
absdiff(rPCA.eigenvectors, subEvec, tmp);
double mval = 0; Point mloc;
minMaxLoc(tmp, 0, &mval, 0, &mloc);
ts->printf( cvtest::TS::LOG, "pca.eigenvectors is incorrect (CV_PCA_DATA_AS_ROW); err = %f\n", err );
ts->printf( cvtest::TS::LOG, "max diff is %g at (i=%d, j=%d) (%g vs %g)\n",
mval, mloc.y, mloc.x, rPCA.eigenvectors.at<float>(mloc.y, mloc.x),
subEvec.at<float>(mloc.y, mloc.x));
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
}
}
prjEps = 1.265, backPrjEps = 1.265;
for( int i = 0; i < rTestPoints.rows; i++ )
{
// check pca project
Mat subEvec_t = subEvec.t();
Mat prj = rTestPoints.row(i) - avg; prj *= subEvec_t;
err = cvtest::norm(rPrjTestPoints.row(i), prj, CV_RELATIVE_L2);
if( err > prjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of project() (CV_PCA_DATA_AS_ROW); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
// check pca backProject
Mat backPrj = rPrjTestPoints.row(i) * subEvec + avg;
err = cvtest::norm( rBackPrjTestPoints.row(i), backPrj, CV_RELATIVE_L2 );
if( err > backPrjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of backProject() (CV_PCA_DATA_AS_ROW); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
}
// 2. check C++ PCA & COL
cPCA( rPoints.t(), Mat(), CV_PCA_DATA_AS_COL, maxComponents );
diffPrjEps = 1, diffBackPrjEps = 1;
Mat ocvPrjTestPoints = cPCA.project(rTestPoints.t());
err = cvtest::norm(cv::abs(ocvPrjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 );
if( err > diffPrjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of project() (CV_PCA_DATA_AS_COL); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
err = cvtest::norm(cPCA.backProject(ocvPrjTestPoints), rBackPrjTestPoints.t(), CV_RELATIVE_L2 );
if( err > diffBackPrjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of backProject() (CV_PCA_DATA_AS_COL); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
// 3. check C++ PCA w/retainedVariance
cPCA( rPoints.t(), Mat(), CV_PCA_DATA_AS_COL, retainedVariance );
diffPrjEps = 1, diffBackPrjEps = 1;
Mat rvPrjTestPoints = cPCA.project(rTestPoints.t());
if( cPCA.eigenvectors.rows > maxComponents)
err = cvtest::norm(cv::abs(rvPrjTestPoints.rowRange(0,maxComponents)), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 );
else
err = cvtest::norm(cv::abs(rvPrjTestPoints), cv::abs(rPrjTestPoints.colRange(0,cPCA.eigenvectors.rows).t()), CV_RELATIVE_L2 );
if( err > diffPrjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of project() (CV_PCA_DATA_AS_COL); retainedVariance=0.95; err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
err = cvtest::norm(cPCA.backProject(rvPrjTestPoints), rBackPrjTestPoints.t(), CV_RELATIVE_L2 );
if( err > diffBackPrjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of backProject() (CV_PCA_DATA_AS_COL); retainedVariance=0.95; err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
#ifdef CHECK_C
// 4. check C PCA & ROW
_points = rPoints;
_testPoints = rTestPoints;
_avg = avg;
_eval = eval;
_evec = evec;
prjTestPoints.create(rTestPoints.rows, maxComponents, rTestPoints.type() );
backPrjTestPoints.create(rPoints.size(), rPoints.type() );
_prjTestPoints = prjTestPoints;
_backPrjTestPoints = backPrjTestPoints;
cvCalcPCA( &_points, &_avg, &_eval, &_evec, CV_PCA_DATA_AS_ROW );
cvProjectPCA( &_testPoints, &_avg, &_evec, &_prjTestPoints );
cvBackProjectPCA( &_prjTestPoints, &_avg, &_evec, &_backPrjTestPoints );
err = cvtest::norm(prjTestPoints, rPrjTestPoints, CV_RELATIVE_L2);
if( err > diffPrjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of cvProjectPCA() (CV_PCA_DATA_AS_ROW); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
err = cvtest::norm(backPrjTestPoints, rBackPrjTestPoints, CV_RELATIVE_L2);
if( err > diffBackPrjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of cvBackProjectPCA() (CV_PCA_DATA_AS_ROW); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
// 5. check C PCA & COL
_points = cPoints;
_testPoints = cTestPoints;
avg = avg.t(); _avg = avg;
eval = eval.t(); _eval = eval;
evec = evec.t(); _evec = evec;
prjTestPoints = prjTestPoints.t(); _prjTestPoints = prjTestPoints;
backPrjTestPoints = backPrjTestPoints.t(); _backPrjTestPoints = backPrjTestPoints;
cvCalcPCA( &_points, &_avg, &_eval, &_evec, CV_PCA_DATA_AS_COL );
cvProjectPCA( &_testPoints, &_avg, &_evec, &_prjTestPoints );
cvBackProjectPCA( &_prjTestPoints, &_avg, &_evec, &_backPrjTestPoints );
err = cvtest::norm(cv::abs(prjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 );
if( err > diffPrjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of cvProjectPCA() (CV_PCA_DATA_AS_COL); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
err = cvtest::norm(backPrjTestPoints, rBackPrjTestPoints.t(), CV_RELATIVE_L2);
if( err > diffBackPrjEps )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of cvBackProjectPCA() (CV_PCA_DATA_AS_COL); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return;
}
#endif
// Test read and write
FileStorage fs( "PCA_store.yml", FileStorage::WRITE );
rPCA.write( fs );
fs.release();
PCA lPCA;
fs.open( "PCA_store.yml", FileStorage::READ );
lPCA.read( fs.root() );
err = cvtest::norm( rPCA.eigenvectors, lPCA.eigenvectors, CV_RELATIVE_L2 );
if( err > 0 )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of write/load functions (YML); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
}
err = cvtest::norm( rPCA.eigenvalues, lPCA.eigenvalues, CV_RELATIVE_L2 );
if( err > 0 )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of write/load functions (YML); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
}
err = cvtest::norm( rPCA.mean, lPCA.mean, CV_RELATIVE_L2 );
if( err > 0 )
{
ts->printf( cvtest::TS::LOG, "bad accuracy of write/load functions (YML); err = %f\n", err );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
}
}
int main(int argc , char **argv) {
GetPot cl(argc,argv);
if(cl.search("-h")) {USAGE(); exit(0);}
string line;
if(cl.search("-E")) {
cout << "Estimating PCA" << endl;
ifstream filelist(cl.follow("filelist","-E"));
ImageFeature img;
getline(filelist,line);
img.load(line,true);
cout << line << endl;
PCA pca(img.size());
cout << img.size() << endl;
pca.putData(img.layerVector(0));
while(getline(filelist,line)) {
cout << line << endl;
img.load(line,true);
pca.putData(img.layerVector(0));
}
pca.dataEnd();
pca.save(cl.follow("covariance.pca","-c"));
pca.calcPCA();
pca.save(cl.follow("transformation.pca","-t"));
filelist.close();
} else if(cl.search("-T")) {
PCA pca;
pca.load(cl.follow("transformation.pca","-t"));
int dim=cl.follow(20,"-d");
ifstream filelist(cl.follow("filelist","-T"));
vector<double> tmp;
ImageFeature img;
while(getline(filelist,line)) {
cout << line << endl;
img.load(line,true);
tmp=pca.transform(img.layerVector(0),img.size());
tmp.resize(dim);
VectorFeature tmpvec(tmp);
tmpvec.save(line+".pca.vec.gz");
}
filelist.close();
} else if(cl.search("-B")) {
PCA pca;
pca.load(cl.follow("transformation.pca","-t"));
int x=cl.follow(16,"-x");
int y=cl.follow(16,"-y");
ifstream filelist(cl.follow("filelist","-B"));
vector<double> tmp;
VectorFeature tmpvec;
while(getline(filelist,line)) {
cout << line << endl;
tmpvec.load(line);
vector<double> tmp;
tmp=pca.backTransform(tmpvec.data());
ImageFeature img(tmp,x,y);
cutoff(img);
img.save(line+".backpca.png");
}
filelist.close();
} else if(cl.search("-M")) {
ImageFeature img; img.load(cl.follow("image.png","-M"),true);
PCA pca;
vector<double> backproj,vec;
pca.load(cl.follow("transformation.pca","-t"));
int w=cl.follow(16,"-x");
int h=cl.follow(16,"-y");
double scalefac=cl.follow(0.8333,"-s");
int dim=cl.follow(20,"-d");
ImageFeature scimg(img);
ImageFeature patch;
uint minX=100000, minY=100000;
uint maxX=100000, maxY=100000;
while(int(scimg.xsize())>=w and int(scimg.ysize())>=h) {
DBG(10) << VAR(scimg.xsize()) << " x " << VAR(scimg.ysize()) << endl;
ImageFeature faceprobmap(scimg.xsize(),scimg.ysize(),1);
double maxDist=0.0;
double minDist=numeric_limits<double>::max();
vector<double> tmpvec;
for(uint x=0;x<scimg.xsize();++x) {
DBG(10) << VAR(x) << endl;
for(uint y=0;y<scimg.ysize();++y) {
patch=getPatch(scimg,x,y,x+w,y+h);
vec=patch.layerVector(0);
vector<double> imgMinMean=vec;
for(uint i=0;i<imgMinMean.size();++i) {
imgMinMean[i]-=pca.mean()[i];
}
double energyImg=getEnergy(imgMinMean);
tmpvec=pca.transform(vec,dim);
double energyTrans=getEnergy(tmpvec);
backproj=pca.backTransform(tmpvec);
double energyBack=getEnergy(backproj);
double d=0;
double tmp;
for(uint i=0;i<backproj.size();++i) {
tmp=backproj[i]-vec[i];
d+=tmp*tmp;
}
faceprobmap(x,y,0)=d;
DBG(10) << VAR(energyImg) << " "
<< VAR(energyTrans) << " "
<< VAR(energyBack) << " "
<< VAR(energyImg-energyTrans) << " "
<< VAR(d) << endl;
if(minDist>d) {
minDist=d;
minX=x; minY=y;
}
if(maxDist<d) {
maxDist=d;
maxX=x; maxY=y;
}
}
}
DBG(10) << VAR(scimg.xsize()) << " " << VAR(scimg.ysize()) << endl;
DBG(10) << VAR(minDist) << " " << VAR(minX) << " " << VAR(minY) << endl;
DBG(10) << VAR(maxDist) << " " << VAR(maxX) << " " << VAR(maxY) << endl << endl;
normalize(faceprobmap);
ostringstream filenamestream;
filenamestream << cl.follow("image.png","-M") << ".fpm." << (scimg.xsize()) <<".png";
faceprobmap.save(filenamestream.str());
uint newW=int(scimg.xsize()*scalefac);
uint newH=int(scimg.ysize()*scalefac);
scimg=scale(scimg,newW,newH);
}
} else if(cl.search("-F")) {
#ifdef HAVE_FFT_LIBRARY
ImageFeature img; img.load(cl.follow("image.png","-F"),true);
PCA pca; pca.load(cl.follow("transformation.pca","-t"));
int w=cl.follow(16,"-x");
int h=cl.follow(16,"-y");
double scalefac=cl.follow(0.8333,"-s");
uint dim=cl.follow(20,"-d");
DBG(10) << "Eigenfaces loaded" << endl;
ImageFeature scimg=img;
while(int(scimg.xsize())>w and int(scimg.ysize())>h) {
ImageFeature fpm=detect(scimg,pca,dim,w,h);
pair<uint,uint> p;
p=argmax(fpm);
DBG(10) << scimg.xsize() << "x" << scimg.ysize() << " (" <<p.first<<", "<< p.second << ") " << VAR(maximum(fpm)) ;
p=argmin(fpm);
BLINK(10) << " (" <<p.first<<", "<< p.second << ") " << VAR(minimum(fpm)) << endl;
normalize(fpm);
ostringstream filenamestream;
filenamestream << cl.follow("image.png","-F") << ".fpm." << (scimg.xsize()) <<".png";
fpm.save(filenamestream.str());
scimg=scale(scimg,int(scimg.xsize()*scalefac),int(scimg.ysize()*scalefac));
}
#else
DBG(10) << "compiled without FFT lib. this does not work. use -M option" << endl;
#endif
} else {
USAGE();
exit(20);
}
}
double startTime = GET_REAL (U"left Time range"), endTime = GET_REAL (U"right Time range");
const char32 *channelRanges = GET_STRING (U"Channel ranges");
bool useCorrelation = GET_INTEGER (U"Use") == 2;
LOOP {
iam (EEG);
autoPCA pca = EEG_to_PCA (me, startTime, endTime, channelRanges, useCorrelation);
praat_new (pca.move(), my name);
}
END
FORM (EEG_and_PCA_to_EEG_principalComponents, U"EEG & PCA: To EEG (principal components)", U"EEG & PCA: To EEG (principal components)...")
INTEGER (U"Number of components", U"0 (=all)")
OK
DO
EEG me = FIRST (EEG);
PCA thee = FIRST (PCA);
autoEEG him = EEG_and_PCA_to_EEG_principalComponents (me, thee, GET_INTEGER (U"Number of components"));
praat_new (him.move(), my name, U"_pc");
END
FORM (EEG_and_PCA_to_EEG_whiten, U"EEG & PCA: To EEG (whiten)", U"EEG & PCA: To EEG (whiten)...")
INTEGER (U"Number of components", U"0 (=all)")
OK
DO
EEG me = FIRST (EEG);
PCA thee = FIRST (PCA);
autoEEG him = EEG_and_PCA_to_EEG_whiten (me, thee, GET_INTEGER (U"Number of components"));
praat_new (him.move(), my name, U"_white");
END
FORM (EEG_to_Sound_modulated, U"EEG: To Sound (modulated)", 0)
int main(int argc, char** argv)
{
string filter = "Gaussian";
string descriptor = "SIFT";
string database = "Forensic-extra";
uint count = 1;
vector<string> extraPhotos, photos, sketches;
loadImages(argv[5], photos);
loadImages(argv[6], sketches);
loadImages(argv[7], extraPhotos);
uint nPhotos = photos.size(),
nSketches = sketches.size(),
nExtra = extraPhotos.size();
uint nTraining = 2*nPhotos/3;
cout << "Read " << nSketches << " sketches." << endl;
cout << "Read " << nPhotos + nExtra << " photos." << endl;
vector<Mat*> sketchesDescriptors(nSketches), photosDescriptors(nPhotos), extraDescriptors(nExtra);
Mat img, temp;
int size=32, delta=16;
#pragma omp parallel for private(img, temp)
for(uint i=0; i<nSketches; i++){
img = imread(sketches[i],0);
sketchesDescriptors[i] = new Mat();
#pragma omp critical
temp = extractDescriptors(img, size, delta, filter, descriptor);
*(sketchesDescriptors[i]) = temp.clone();
}
#pragma omp parallel for private(img, temp)
for(uint i=0; i<nPhotos; i++){
img = imread(photos[i],0);
photosDescriptors[i] = new Mat();
#pragma omp critical
temp = extractDescriptors(img, size, delta, filter, descriptor);
*(photosDescriptors[i]) = temp.clone();
}
#pragma omp parallel for private(img, temp)
for(uint i=0; i<nExtra; i++){
img = imread(extraPhotos[i],0);
extraDescriptors[i] = new Mat();
#pragma omp critical
temp = extractDescriptors(img, size, delta, filter, descriptor);
*(extraDescriptors[i]) = temp.clone();
}
auto seed = unsigned(count);
srand(seed);
random_shuffle(sketchesDescriptors.begin(), sketchesDescriptors.end());
srand(seed);
random_shuffle(photosDescriptors.begin(), photosDescriptors.end());
//training
vector<Mat*> trainingSketchesDescriptors1, trainingPhotosDescriptors1,
trainingSketchesDescriptors2, trainingPhotosDescriptors2;
trainingSketchesDescriptors1.insert(trainingSketchesDescriptors1.end(), sketchesDescriptors.begin(), sketchesDescriptors.begin()+nTraining/2);
trainingPhotosDescriptors1.insert(trainingPhotosDescriptors1.end(), photosDescriptors.begin(), photosDescriptors.begin()+nTraining/2);
trainingSketchesDescriptors2.insert(trainingSketchesDescriptors2.end(), sketchesDescriptors.begin()+nTraining/2, sketchesDescriptors.begin()+nTraining);
trainingPhotosDescriptors2.insert(trainingPhotosDescriptors2.end(), photosDescriptors.begin()+nTraining/2, photosDescriptors.begin()+nTraining);
uint nTraining1 = trainingPhotosDescriptors1.size(),
nTraining2 = trainingPhotosDescriptors2.size();
//testing
vector<Mat*> testingSketchesDescriptors, testingPhotosDescriptors;
testingSketchesDescriptors.insert(testingSketchesDescriptors.end(), sketchesDescriptors.begin()+nTraining, sketchesDescriptors.end());
testingPhotosDescriptors.insert(testingPhotosDescriptors.end(), photosDescriptors.begin()+nTraining, photosDescriptors.end());
testingPhotosDescriptors.insert(testingPhotosDescriptors.end(), extraDescriptors.begin(), extraDescriptors.end());
uint nTestingSketches = testingSketchesDescriptors.size(),
nTestingPhotos = testingPhotosDescriptors.size();
PCA pca;
LDA lda;
vector<int> labels;
for(uint i=0; i<nTraining2; i++){
labels.push_back(i);
}
labels.insert(labels.end(),labels.begin(),labels.end());
//bags
vector<Mat*> testingSketchesDescriptorsBag(nTestingSketches), testingPhotosDescriptorsBag(nTestingPhotos),
trainingPhotosDescriptors1Temp(nTraining1), trainingSketchesDescriptors1Temp(nTraining1);
for(int b=0; b<30; b++){
vector<int> bag_indexes = gen_bag(154, 0.1);
#pragma omp parallel for private(temp)
for(uint i=0; i<nTraining1; i++){
temp = *(trainingSketchesDescriptors1[i]);
temp = bag(temp, bag_indexes, 154);
trainingSketchesDescriptors1Temp[i] = new Mat();
*(trainingSketchesDescriptors1Temp[i]) = temp.clone();
}
#pragma omp parallel for private(temp)
for(uint i=0; i<nTraining1; i++){
temp = *(trainingPhotosDescriptors1[i]);
temp = bag(temp, bag_indexes, 154);
trainingPhotosDescriptors1Temp[i] = new Mat();
*(trainingPhotosDescriptors1Temp[i]) = temp.clone();
}
Kernel k(trainingPhotosDescriptors1Temp, trainingSketchesDescriptors1Temp);
k.compute();
uint dim = (k.projectGallery(bag(*(trainingPhotosDescriptors1[0]), bag_indexes, 154))).total();
Mat X(dim, 2*nTraining2, CV_32F);
#pragma omp parallel for private(temp)
for(uint i=0; i<nTraining2; i++){
temp = *(trainingSketchesDescriptors2[i]);
temp = bag(temp, bag_indexes, 154);
temp = k.projectProbe(temp);
temp.copyTo(X.col(i));
}
#pragma omp parallel for private(temp)
for(uint i=0; i<nTraining2; i++){
temp = *(trainingPhotosDescriptors2[i]);
temp = bag(temp, bag_indexes, 154);
temp = k.projectGallery(temp);
temp.copyTo(X.col(i+nTraining2));
}
Mat meanX = Mat::zeros(dim, 1, CV_32F), instance;
// calculate sums
for (int i = 0; i < X.cols; i++) {
instance = X.col(i);
add(meanX, instance, meanX);
}
// calculate total mean
meanX.convertTo(meanX, CV_32F, 1.0/static_cast<double>(X.cols));
// subtract the mean of matrix
for(int i=0; i<X.cols; i++) {
Mat c_i = X.col(i);
subtract(c_i, meanX.reshape(1,dim), c_i);
}
pca.computeVar(X, Mat(), CV_PCA_DATA_AS_COL, .99);
Mat W1 = pca.eigenvectors.t();
Mat ldaData = (W1.t()*X).t();
lda.compute(ldaData, labels);
Mat W2 = lda.eigenvectors();
W2.convertTo(W2, CV_32F);
Mat projectionMatrix = (W2.t()*W1.t()).t();
//testing
#pragma omp parallel for private(temp)
for(uint i=0; i<nTestingSketches; i++){
temp = *(testingSketchesDescriptors[i]);
temp = bag(temp, bag_indexes, 154);
temp = k.projectProbe(temp);
temp = projectionMatrix.t()*(temp-meanX);
if(b==0){
testingSketchesDescriptorsBag[i] = new Mat();
*(testingSketchesDescriptorsBag[i]) = temp.clone();
}
else{
vconcat(*(testingSketchesDescriptorsBag[i]), temp, *(testingSketchesDescriptorsBag[i]));
}
}
#pragma omp parallel for private(temp)
for(uint i=0; i<nTestingPhotos; i++){
temp = *(testingPhotosDescriptors[i]);
temp = bag(temp, bag_indexes, 154);
temp = k.projectGallery(temp);
temp = projectionMatrix.t()*(temp-meanX);
if(b==0){
testingPhotosDescriptorsBag[i] = new Mat();
*(testingPhotosDescriptorsBag[i]) = temp.clone();
}
else{
vconcat(*(testingPhotosDescriptorsBag[i]), temp, *(testingPhotosDescriptorsBag[i]));
}
}
}
Mat distancesCosine = Mat::zeros(nTestingSketches,nTestingPhotos,CV_64F);
#pragma omp parallel for
for(uint i=0; i<nTestingSketches; i++){
for(uint j=0; j<nTestingPhotos; j++){
distancesCosine.at<double>(i,j) = abs(1-cosineDistance(*(testingSketchesDescriptorsBag[i]),*(testingPhotosDescriptorsBag[j])));
}
}
string file1name = "kernel-prs-" + filter + descriptor + database + to_string(nTraining) + string("cosine") + to_string(count) + string(".xml");
FileStorage file1(file1name, FileStorage::WRITE);
file1 << "distanceMatrix" << distancesCosine;
file1.release();
return 0;
}
void LocalFeatureExtractor::pcaTransform(const PCA &pca, LocalFeatures &lf) {
for(uint l=0;l<lf.numberOfFeatures_;++l) {
lf[l]=pca.transform(lf[l],settings_.pcadim);
}
lf.dim_=settings_.pcadim;
}
ImageFeature detect(const ImageFeature& img, const PCA& pca,uint dim, uint w, uint h) {
uint imgdim=img.xsize()*img.ysize();
uint padx=img.xsize()+w; uint pady=img.ysize()+h;
uint paddim=padx*pady;
#ifdef HAVE_FFT_LIBRARY
// get memory for calculations
fftw_complex *FIMG=NULL, **FFILTER=NULL, **FMULT=NULL;
FIMG=new fftw_complex[paddim];
for(uint i=0;i<paddim;++i) {FIMG[i].re=0.0;FIMG[i].im=0.0;}
FFILTER=new fftw_complex*[dim];
FMULT=new fftw_complex*[dim];
for(uint i=0;i<dim;++i) {
FFILTER[i]=new fftw_complex[paddim];
for(uint j=0;j<imgdim;++j) {FFILTER[i][j].re=0.0;FFILTER[i][j].im=0.0;}
FMULT[i]=new fftw_complex[paddim];
for(uint j=0;j<imgdim;++j) {FMULT[i][j].re=0.0;FMULT[i][j].im=0.0;}
}
DBG(10) << "Memory allocated" << endl;
vector<double> meanTrans=pca.transform(pca.mean(),dim);
// create strategy for fft
fftwnd_plan plan = fftw2d_create_plan(padx,pady, FFTW_FORWARD, FFTW_ESTIMATE | FFTW_IN_PLACE);
fftwnd_plan planb = fftw2d_create_plan(padx,pady, FFTW_BACKWARD, FFTW_ESTIMATE | FFTW_IN_PLACE);
DBG(10) << "Strategies for FFT created" << endl;
//copy image into fourier transform data structure
for(uint x=0;x<img.xsize();++x) { for(uint y=0;y<img.ysize();++y) { FIMG[y*padx+x].re=img(x,y,0); } }
// fourier transform the image
fftwnd_one(plan,FIMG,NULL);
DBG(10) << "Image Transformed" << endl;
// fourier transform the filters
for(uint d=0;d<dim;++d) {
for(uint x=0;x<w;++x) {
for(uint y=0;y<h;++y) {
uint i=y*padx+x;
FFILTER[d][i].re=pca.eigenvector(d)[y*w+x];
}
}
fftwnd_one(plan,FFILTER[d],NULL);
DBG(10) << "Filter " << d << " transformed." << endl;
}
// multiplication in fourier domain
for(uint d=0;d<dim;++d) {
for(uint i=0;i<paddim;++i) {
FMULT[d][i].re=FIMG[i].re*FFILTER[d][i].re-FIMG[i].im*FFILTER[d][i].im;
FMULT[d][i].im=FIMG[i].re*FFILTER[d][i].im+FIMG[i].im*FFILTER[d][i].re;
}
DBG(10) << "Filter " << d << " applied." ;
//fourier back transform
fftwnd_one(planb,FMULT[d],NULL);
BLINK(10) << "... backtransformed.." ;
// subtract transformed mean
for(uint i=0;i<paddim;++i) {
FMULT[d][i].re=FMULT[d][i].re/paddim-meanTrans[d];
}
BLINK(10) << ". Mean subtracted." << endl;
}
double energyTrans, energyImg;
ImageFeature fpm(img.xsize(),img.ysize(),1);
for(uint x=0;x<img.xsize();++x) {
for(uint y=0;y<img.ysize();++y) {
uint i=y*padx+x;
energyTrans=energTrans(FMULT,i,dim);
energyImg=energImg(img,x,y,w,h,pca.mean());
DBG(25) << VAR(x) << " " << VAR(y) << " " << VAR(energyTrans) << " " << VAR(energyImg) << endl;
fpm(x,y,0)=energyImg-energyTrans;
}
}
DBG(10) << "fpm generation." << endl;
return fpm;
#endif
}
//********************************
//* main
int main(int argc, char* argv[]) {
if( (argc != 12) && (argc != 14) ){
std::cerr << "usage: " << argv[0] << " [path] <rank_num> <exist_voxel_num_threshold> [model_pca_filename] <dim_model> <size1> <size2> <size3> <detect_th> <distance_th> /input:=/camera/rgb/points" << std::endl;
exit( EXIT_FAILURE );
}
char tmpname[ 1000 ];
ros::init (argc, argv, "detectObj", ros::init_options::AnonymousName);
// read the length of voxel side
sprintf( tmpname, "%s/param/parameters.txt", argv[1] );
voxel_size = Param::readVoxelSize( tmpname );
detect_th = atof( argv[9] );
distance_th = atof( argv[10] );
rank_num = atoi( argv[2] );
// read the number of voxels in each subdivision's side of scene
box_size = Param::readBoxSizeScene( tmpname );
// read the dimension of compressed feature vectors
dim = Param::readDim( tmpname );
// set the dimension of the target object's subspace
const int dim_model = atoi(argv[5]);
if( dim <= dim_model ){
std::cerr << "ERR: dim_model should be less than dim(in dim.txt)" << std::endl;
exit( EXIT_FAILURE );
}
// read the threshold for RGB binalize
sprintf( tmpname, "%s/param/color_threshold.txt", argv[1] );
Param::readColorThreshold( color_threshold_r, color_threshold_g, color_threshold_b, tmpname );
// determine the size of sliding box
region_size = box_size * voxel_size;
float tmp_val = atof(argv[6]) / region_size;
int size1 = (int)tmp_val;
if( ( ( tmp_val - size1 ) >= 0.5 ) || ( size1 == 0 ) ) size1++;
tmp_val = atof(argv[7]) / region_size;
int size2 = (int)tmp_val;
if( ( ( tmp_val - size2 ) >= 0.5 ) || ( size2 == 0 ) ) size2++;
tmp_val = atof(argv[8]) / region_size;
int size3 = (int)tmp_val;
if( ( ( tmp_val - size3 ) >= 0.5 ) || ( size3 == 0 ) ) size3++;
sliding_box_size_x = size1 * region_size;
sliding_box_size_y = size2 * region_size;
sliding_box_size_z = size3 * region_size;
// set variables
search_obj.setRange( size1, size2, size3 );
search_obj.setRank( rank_num );
search_obj.setThreshold( atoi(argv[3]) );
search_obj.readAxis( argv[4], dim, dim_model, ASCII_MODE_P, MULTIPLE_SIMILARITY );
// read projection axis of the target object's subspace
PCA pca;
sprintf( tmpname, "%s/models/compress_axis", argv[1] );
pca.read( tmpname, ASCII_MODE_P );
Eigen::MatrixXf tmpaxis = pca.getAxis();
Eigen::MatrixXf axis = tmpaxis.block( 0,0,tmpaxis.rows(),dim );
Eigen::MatrixXf axis_t = axis.transpose();
Eigen::VectorXf variance = pca.getVariance();
if( WHITENING )
search_obj.setSceneAxis( axis_t, variance, dim );
else
search_obj.setSceneAxis( axis_t );
// object detection
VoxelizeAndDetect vad;
vad.loop();
ros::spin();
return 0;
}
void test(set<int> &testSet, int code)
{
CascadeClassifier classifier;
classifier.load("haarcascades/haarcascade_frontalface_alt_tree.xml");
ShapePredictor predictor;
predictor.load("model/helen.txt");
PCA pca;
FileStorage fs("model/girl_pca.xml", FileStorage::READ);
fs["mean"] >> pca.mean;
fs["eigenvals"] >> pca.eigenvalues;
fs["eigenvecs"] >> pca.eigenvectors;
SVM svm;
svm.load("model/girl_svm.xml");
cout << "\nmodel loaded" << endl;
ifstream fin("img/labels.txt");
ofstream fout("data/out_" +
to_string(code) + ".txt");
VideoWriter writer("data/out.avi", 0, 10, Size(1920, 1080), true);
string line;
int corr = 0, total = 0;
while (getline(fin, line)) {
stringstream ss(line);
int frame, label;
ss >> frame >> label;
label -= 49;
if (testSet.find(frame) == testSet.end())
continue;
Mat vis = imread("img/" + to_string(frame) + ".jpg",
CV_LOAD_IMAGE_UNCHANGED);
Mat_<uchar> img;
cvtColor(vis, img, COLOR_BGR2GRAY);
BBox bbox = getTestBBox(img, classifier);
if (EmptyBox(bbox)) continue;
Mat_<double> shape = predictor(img, bbox);
Geom G; initGeom(shape, G);
Pose P; calcPose(G, P);
Mat_<uchar> lEye, rEye;
regularize(img, bbox, P, shape, lEye, rEye);
vector<float> lRlt;
vector<float> rRlt;
calcMultiHog(lEye, lRlt);
calcMultiHog(rEye, rRlt);
Mat_<float> pcaVec, ldmks;
vector<float> _hog2nd_vec;
for (int k = 0; k < lRlt.size(); k++)
_hog2nd_vec.push_back(lRlt[k]);
for (int k = 0; k < rRlt.size(); k++)
_hog2nd_vec.push_back(rRlt[k]);
Mat_<float> multihog = Mat_<float>(_hog2nd_vec).reshape(1, 1);
pcaVec = pca.project(multihog);
vector<float> _ldmks;
for (int i = 28; i < 48; i++) {
_ldmks.push_back((shape(i, 0) - bbox.cx) / bbox.w);
_ldmks.push_back((shape(i, 1) - bbox.cy) / bbox.h);
}
float mouthx = (shape(51, 0) + shape(62, 0) + shape(66, 0) + shape(57, 0)) / 4;
float mouthy = (shape(51, 1) + shape(62, 1) + shape(66, 1) + shape(57, 1)) / 4;
_ldmks.push_back((mouthx - bbox.cx) / bbox.w);
_ldmks.push_back((mouthy - bbox.cy) / bbox.h);
float maxVal = *std::max_element(_ldmks.begin(), _ldmks.end());
for (int i = 0; i < _ldmks.size(); i++) _ldmks[i] *= 1.0 / maxVal; // scale to [-1, 1]
ldmks = Mat_<float>(_ldmks).reshape(1, 1);
Mat_<float> sample(1, pcaVec.cols + ldmks.cols);
for (int j = 0; j < pcaVec.cols; j++)
sample(0, j) = pcaVec(0, j);
for (int j = 0; j < ldmks.cols; j++)
sample(0, j + pcaVec.cols) = ldmks(0, j);
int pred = svm.predict(sample);
if (pred == label) corr++;
total++;
fout << frame << ' ' << label << ' ' << pred << endl;
string s1, s2;
switch (label) {
case 0: s1 = "annotation: Eye"; break;
case 1: s1 = "annotation: Face"; break;
case 2: s1 = "annotation: NOF"; break;
}
switch (pred) {
case 0: s2 = "prediction: Eye"; break;
case 1: s2 = "prediction: Face"; break;
case 2: s2 = "prediction: NOF"; break;
}
Scalar c1, c2;
c1 = CV_RGB(255, 255, 0); // yellow
if (pred == label) c2 = CV_RGB(0, 255, 0); // green
else c2 = CV_RGB(255, 0, 0); // red
putText(vis, s1, Point(1280, 100), CV_FONT_HERSHEY_PLAIN, 4.0, c1, 3);
putText(vis, s2, Point(1280, 200), CV_FONT_HERSHEY_PLAIN, 4.0, c2, 3);
/*imshow("glance", vis);
waitKey(0);*/
writer.write(vis);
}
cout << corr << ' ' << total << endl;
cout << (double)corr / total << endl;
fin.close();
fout.close();
writer.release();
}
int main(int argc, char* argv[])
{
string trainlistfile;
string testlistfile;
string modelfile;
string rawfeaturefile;
string resultpath;
string kmeansfilepath;
int maxComponent = 32;
int cluster_num = 512;
int feature_dimention = 128;
if (argc == 1)
{
help();
return -1;
}
for (int i = 1; i < argc;++i)
{
if (string(argv[i])=="--trainlist")
{
trainlistfile = argv[++i];
}
else if (string(argv[i]) == "--testlist")
{
testlistfile = argv[++i];
}
else if (string(argv[i]) == "--clusternum")
{
cluster_num = std::stoi(argv[++i]);
}
else if (string(argv[i]) == "--featuredim")
{
feature_dimention = std::stoi(argv[++i]);
}
else if (string(argv[i]) == "--modelfile")
{
modelfile = argv[++i];
}
else if (string(argv[i]) == "--rawfeature")
{
rawfeaturefile = argv[++i];
}
else if (string(argv[i])=="--resultpath")
{
resultpath = argv[++i];
}
else if (string(argv[i]) == "--maxComponent")
{
maxComponent = std::stoi(argv[++i]);
}
else if (string(argv[i]) == "--kmeansfilepath")
{
kmeansfilepath = argv[++i];
}
}
#ifdef kmeans_pca
vlad::configure(256,128);
PCA pca;
vlad::loadPCAmodel("pca_model.yml",pca);
cout<<pca.eigenvalues<<endl;
#endif
#ifdef kmeans
vlad::getKmeansModel(cluster_num,feature_dimention,rawfeaturefile,resultpath);
#endif
#ifdef VLAD
Stopwatch watch;
watch.Start();
vlad::GetVladFeatureFromSift(kmeansfilepath,testlistfile);
watch.Stop();
cout<<"getkmeans use "<<watch.GetTime()<<endl;
getchar();
#endif
#ifdef ReduceMatrix
ifstream rawfeature(rawfeaturefile.c_str());
ofstream outPut(resultpath.c_str());
string single_raw_fea;
PCA pca;
vlad::loadPCAmodel(modelfile, pca);
while (getline(rawfeature,single_raw_fea))
{
vector<string> ww;
cv::Mat rawfeature_mat = cv::Mat(1,LENGTH_OF_SINGLE_DATA, CV_32F);
split_words(single_raw_fea, " ", ww);
for (int j = 0; j < LENGTH_OF_SINGLE_DATA; ++j){
rawfeature_mat.at<float>(0, j) = atof(ww[j].c_str());
}
cv::Mat matric_reduced;
matric_reduced = pca.project(rawfeature_mat);
for (int i=0;i<matric_reduced.cols;++i)
{
outPut<<matric_reduced.at<float>(0,i);
}
outPut <<endl;
}
rawfeature.close();
outPut.close();
#else
#ifdef ALL
vlad::configure(cluster_num,feature_dimention);
//vlad::getPCAmodel(trainlistfile,32);
vlad::ExitTheSiftFeature(trainlistfile);
// vlad::GetVladFeature(testlistfile);
// FV::GetGMMModel(32, 512);
vector<float> feature{ 1, 1, 1, 1, 1, 1 };
RootNormFeature(feature);
Mat a = Mat::ones(4, 6,CV_32FC1);
for (float a:feature)
{
cout << a << endl;
}
a.at<float>(0, 0) = 0;
RootNormFeature(a);
cout << a;
getchar();
/*Mat rawdata = Mat(1, 3, CV_32FC1);
rawdata.setTo(1);
cout << rawdata << endl;
Mat result;
Mat model = (Mat_<float>(3, 2) << 1, 1, 1, -1, -1, -1);
encode2Binary(rawdata, model, result);
cout << "work has been down"<< rawdata << endl << model << endl << result << endl;
vector<float> rawdata2{ 1.0, 1.0, 1.0 };
Mat result2;
encode2Binary(rawdata2, model, result2);
cout << result2 << endl;
Mat model2 = (Mat_<uchar>(3, 2) << 1, 1, 1, 1, 1, 1);
model2.assignTo(model2, CV_32FC1);
cout << model2<<endl<<model2.type();
for (int i = 0; i < 10;i++)
{
for (int i = 0; i < 10;i++)
{
cout << i << endl;
}
}*/
//MethodTimeResume timetest("time.log");
//timetest.test();
//getchar();
//vlad::getPCAmodel(trainlistfile, 32);
#endif
#endif // ReduceMatrix
}
int main(int argc, char**argv) {
GetPot cl(argc, argv);
if(cl.search(2,"-h","--help")) {USAGE(); exit(0);}
string pcafile=cl.follow("pca.pca",2,"-p","--pca");
string imagefile=cl.follow("image",2,"-i","--img");
VectorFeature vec;
PCA pca; pca.load(pcafile);
uint width, height, depth;
if(cl.search(2,"-c","--color")) {
depth=3;
} else {
depth=1;
}
if(!cl.search(2,"-w","--width") && !cl.search(2,"-h","--height")) {
width=uint(sqrt(double(pca.dim())));
height=width;
if(int(height*width)!=pca.dim()) {
ERR << "pca not for squared images, specify width or height" << endl
<< "height=" << height << "* width=" << width << "!= size=" << pca.dim() << endl;
exit(20);
}
} else {
if(cl.search(2,"-w","--width") && !cl.search(2,"-h","--height")) {
width=cl.follow(10,2,"-w","--width");
height=pca.dim()/width;
if(int(height*width)!=pca.dim()) {
ERR << "pca images of this width, specify valid values" << endl
<< "height=" << height << "* width=" << width << "!= size=" << pca.dim() << endl;
exit(20);
}
} else if(!cl.search(2,"-w","--width") && cl.search(2,"-h","--height")) {
height=cl.follow(10,2,"-j","--height");
width=pca.dim()/height;
if(int(height*width)!=pca.dim()) {
ERR << "pca images of this height, specify valid values" << endl
<< "height=" << height << "* width=" << width << "!= size=" << pca.dim() << endl;
exit(20);
}
} else {
height=cl.follow(10,2,"-j","--height");
width=cl.follow(10,2,"-w","--width");
if(int(height*width)!=pca.dim()) {
ERR << "pca images of this height and width, specify valid values" << endl
<< "height=" << height << "* width=" << width << "!= size=" << pca.dim() << endl;
exit(20);
}
}
}
vector<double> backtransformed;
if(cl.search(2,"-v","--vec") && !cl.search(2,"-b","--base") && !cl.search(2,"-M","--mean")) {
string vecfile=cl.follow("vec.vec",2,"-v","--vec");
DBG(10) << "Loading Vectorfile " << vecfile << endl;
vec.load(vecfile);
DBG(10) << "Vector to be backtransformed" ;
for(uint i=0;i<vec.size();++i) {
BLINK(10) << " "<< vec[i];
}
BLINK(10) << endl;
if(cl.search("-n1st")) vec[0]=0;
if(cl.search("--nopca")) {
backtransformed=vec.data();
} else {
backtransformed=pca.backTransform(vec.data());
}
DBG(10) << "Backtransformed Vector" ;
for(uint i=0;i<backtransformed.size();++i) {
BLINK(10) << " " <<backtransformed[i];
}
BLINK(10) << endl;
} else if(cl.search(2,"-b","--base") && !cl.search(2,"-v","--vec") && !cl.search(2,"-M","--mean")) {
uint base=cl.follow(0,2,"-b","--base");
backtransformed=pca.eigenvector(base);
} else if(!cl.search(2,"-b","--base") && !cl.search(2,"-v","--vec") && cl.search(2,"-M","--mean")) {
backtransformed=pca.mean();
} else {
USAGE();
exit(20);
}
ImageFeature image(width,height,depth);
if(cl.search(2,"-m","--minMean")) {
DBG(10) << "Subtracting mean" << endl;
for(uint i=0;i<backtransformed.size();++i) {
backtransformed[i]-pca.mean()[i];
}
}
for(uint i=0;i<backtransformed.size();++i) {
image[i]=backtransformed[i];
}
if(cl.search(2,"-n","--norm")) {
DBG(10) << "normalization" << endl;
normalize(image);
}
// //make values positive
// shift(image,-minimum(image,0));
//
cutoff(image);
//
DBG(10) << "Going to save:" ;
for(uint i=0;i<image.size();++i) {
BLINK(10) << " " <<image[i];
}
BLINK(10) << endl;
image.save(imagefile);
DBG(10) << "cmdline was: "; printCmdline(argc,argv);
}
int main(int argc, char**argv) {
GetPot cl(argc, argv);
if(cl.search(2,"-h","--help") or !cl.search("-lf")) {USAGE(); exit(0);}
bool nonorm = cl.search(1, "-nonorm");
LocalFeatures lf; lf.load(cl.follow("test.lf.gz","-lf"));
uint sc = cl.follow(1, "-scale");
uint w=uint(lf.winsize()*2+1);
ImageFeature img(w,w,lf.zsize());
string savefilename = cl.follow("", "-save");
bool backtransform = false;
PCA pca;
if(cl.search("-unpca"))
{
if( !pca.load(cl.follow("", "-unpca")) )
{
ERR << "Error loading PCA file!" << endl;
abort();
}
backtransform = true;
}
bool dontshow = cl.search("-dontshow");
for(uint i=0;i<lf.size();++i) {
DBG(10) << "lf " << i << endl;
if(!backtransform) {
for(uint j=0;j<lf.dim();++j) {
img[j] = lf.getData()[i][j];
}
} else {
vector<double> backtransformed = pca.backTransform(lf.getData()[i]);
for(uint j=0;j<(uint)pca.dim();++j) {
img[j] = backtransformed[j];
}
}
if (sc != 1) {
img = scale(img, w * sc, w * sc);
}
if (!nonorm) {
normalize(img);
}
if(!dontshow) {
if(cl.search("-layerwise")) {
for(uint c=0;c<img.zsize();++c) {
BLINK(10) << " " << c;
img.display(c,c,c);
}
BLINK(10) << endl;
} else {
BLINK(10) << "all layers" << endl;;
img.display();
}
}
if (savefilename != "") {
std::ostringstream filenamewithnr;
filenamewithnr << savefilename << "_" << setw(3) << setfill('0') << i << ".png";
img.save(filenamewithnr.str());
}
}
}
