void EigsGen::findMatchedIndex(const Eigen::VectorXcd &target,
const Eigen::VectorXcd &collection,
Eigen::VectorXi &result)
{
int nfound = 0;
int maxn = target.size();
if(result.size() < maxn)
result.resize(maxn);
for(int i = 0; i < collection.size(); i++)
{
int j;
for(j = 0; j < maxn; j++)
{
if(abs(collection[i] - target[j]) < 1e-8 * abs(target[j]))
break;
}
if(j < maxn)
{
result[nfound] = i;
nfound++;
if(collection[i].imag() != 0)
{
i++;
result[nfound] = i;
nfound++;
}
}
if(nfound >= maxn) break;
}
if(result.size() > nfound)
result.conservativeResize(nfound);
}
int main(int argc, char *argv[])
{
using namespace Eigen;
using namespace std;
igl::readOBJ(TUTORIAL_SHARED_PATH "/bump-domain.obj",V,F);
U=V;
// Find boundary vertices outside annulus
typedef Matrix<bool,Dynamic,1> VectorXb;
VectorXb is_outer = (V.rowwise().norm().array()-1.0)>-1e-15;
VectorXb is_inner = (V.rowwise().norm().array()-0.15)<1e-15;
VectorXb in_b = is_outer.array() || is_inner.array();
igl::colon<int>(0,V.rows()-1,b);
b.conservativeResize(stable_partition( b.data(), b.data()+b.size(),
[&in_b](int i)->bool{return in_b(i);})-b.data());
bc.resize(b.size(),1);
for(int bi = 0;bi<b.size();bi++)
{
bc(bi) = (is_outer(b(bi))?0.0:1.0);
}
// Pseudo-color based on selection
MatrixXd C(F.rows(),3);
RowVector3d purple(80.0/255.0,64.0/255.0,255.0/255.0);
RowVector3d gold(255.0/255.0,228.0/255.0,58.0/255.0);
for(int f = 0;f<F.rows();f++)
{
if( in_b(F(f,0)) && in_b(F(f,1)) && in_b(F(f,2)))
{
C.row(f) = purple;
}else
{
C.row(f) = gold;
}
}
// Plot the mesh with pseudocolors
igl::viewer::Viewer viewer;
viewer.data.set_mesh(U, F);
viewer.core.show_lines = false;
viewer.data.set_colors(C);
viewer.core.trackball_angle = Eigen::Quaternionf(0.81,-0.58,-0.03,-0.03);
viewer.core.trackball_angle.normalize();
viewer.callback_pre_draw = &pre_draw;
viewer.callback_key_down = &key_down;
viewer.core.is_animating = true;
viewer.core.animation_max_fps = 30.;
cout<<
"Press [space] to toggle animation."<<endl<<
"Press '.' to increase k."<<endl<<
"Press ',' to decrease k."<<endl;
viewer.launch();
}
int main(int argc, char *argv[])
{
using namespace Eigen;
using namespace std;
igl::readOFF("../shared/decimated-knight.off",V,F);
U=V;
igl::readDMAT("../shared/decimated-knight-selection.dmat",S);
// vertices in selection
igl::colon<int>(0,V.rows()-1,b);
b.conservativeResize(stable_partition( b.data(), b.data()+b.size(),
[](int i)->bool{return S(i)>=0;})-b.data());
// Centroid
mid = 0.5*(V.colwise().maxCoeff() + V.colwise().minCoeff());
// Precomputation
arap_data.max_iter = 100;
igl::arap_precomputation(V,F,V.cols(),b,arap_data);
// Set color based on selection
MatrixXd C(F.rows(),3);
RowVector3d purple(80.0/255.0,64.0/255.0,255.0/255.0);
RowVector3d gold(255.0/255.0,228.0/255.0,58.0/255.0);
for(int f = 0;f<F.rows();f++)
{
if( S(F(f,0))>=0 && S(F(f,1))>=0 && S(F(f,2))>=0)
{
C.row(f) = purple;
}else
{
C.row(f) = gold;
}
}
// Plot the mesh with pseudocolors
igl::viewer::Viewer viewer;
viewer.data.set_mesh(U, F);
viewer.data.set_colors(C);
viewer.callback_pre_draw = &pre_draw;
viewer.callback_key_down = &key_down;
viewer.core.is_animating = false;
viewer.core.animation_max_fps = 30.;
cout<<
"Press [space] to toggle animation"<<endl;
viewer.launch();
}
int main(int argc, char** argv)
{
std::string path;
po::options_description desc("Calculates one point cloud for classification\n======================================\n**Allowed options");
desc.add_options()
("help,h", "produce help message")
("path,p", po::value<std::string>(&path)->required(), "Path to folders with pics")
;
po::variables_map vm;
po::parsed_options parsed = po::command_line_parser(argc,argv).options(desc).allow_unregistered().run();
po::store(parsed, vm);
if (vm.count("help"))
{
std::cout << desc << std::endl;
return false;
}
try
{
po::notify(vm);
}
catch(std::exception& e)
{
std::cerr << "Error: " << e.what() << std::endl << std::endl << desc << std::endl;
return false;
}
// std::string pretrained_binary_proto = "/home/martin/github/caffe/models/bvlc_alexnet/bvlc_alexnet.caffemodel";
// std::string feature_extraction_proto = "/home/martin/github/caffe/models/bvlc_alexnet/deploy.prototxt";
std::string pretrained_binary_proto = "/home/martin/github/caffe/models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel";
std::string feature_extraction_proto = "/home/martin/github/caffe/models/bvlc_reference_caffenet/deploy.prototxt";
std::string mean_file = "/home/martin/github/caffe/data/ilsvrc12/imagenet_mean.binaryproto";
// std::vector<std::string> extract_feature_blob_names;
// extract_feature_blob_names.push_back("fc7");
Eigen::MatrixXf all_model_signatures_, test;
v4r::CNN_Feat_Extractor<pcl::PointXYZRGB,float>::Parameter estimator_param;
//estimator_param.init(argc, argv);
v4r::CNN_Feat_Extractor<pcl::PointXYZRGB,float>::Ptr estimator;
//v4r::CNN_Feat_Extractor<pcl::PointXYZRGB,float> estimator;
estimator.reset(new v4r::CNN_Feat_Extractor<pcl::PointXYZRGB, float>(estimator_param));
//estimator.reset();
//estimator->setExtractFeatureBlobNames(extract_feature_blob_names);
estimator->setFeatureExtractionProto(feature_extraction_proto);
estimator->setPretrainedBinaryProto(pretrained_binary_proto);
estimator->setMeanFile(mean_file);
//estimator->init();
pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
//pcl::PointCloud<pcl::PointXYZRGB> test(new pcl::PointCloud<pcl::PointXYZRGB>);
char end = path.back();
if(end!='/')
path.append("/");
std::vector<std::string> objects(v4r::io::getFoldersInDirectory(path));
objects.erase(find(objects.begin(),objects.end(),"svm"));
std::vector<std::string> paths,Files;
std::vector<std::string> Temp;
std::string fs, fp, fo;
Eigen::VectorXi models;
std::vector<std::string> modelnames;
std::vector<int> indices;
v4r::svmClassifier::Parameter paramSVM;
paramSVM.knn_=1;
paramSVM.do_cross_validation_=0;
v4r::svmClassifier classifier(paramSVM);
if(!(v4r::io::existsFile(path+"svm/Signatures.txt")&&v4r::io::existsFile(path+"svm/Labels.txt"))){
for(size_t o=0;o<objects.size();o++){
//for(size_t o=0;o<1;o++){
fo = path;
fo.append(objects[o]);
fo.append("/");
paths.clear();
paths = v4r::io::getFilesInDirectory(fo,".*.JPEG",false);
modelnames.push_back(objects[o]);
int old_rows = all_model_signatures_.rows();
all_model_signatures_.conservativeResize(all_model_signatures_.rows()+paths.size(),4096);
for(size_t i=0;i<paths.size();i++){
// for(size_t i=0;i<3;i++){
fp = fo;
fp.append(paths[i]);
std::cout << "Teaching File: " << fp << std::endl;
// int rows = image.rows;
// int cols = image.cols;
// int a,b;
// if(rows>256)
// a = floor(rows/2)-128;
// else
// a=0;
// if(cols<256)
// b = floor(cols/2)-128;
// else
// b=0;
// if(rows<256||cols<256)
// continue;
//cv::Rect r(b,a,256,256);
// cv::namedWindow( "Display window", cv::WINDOW_AUTOSIZE );// Create a window for display.
// cv::imshow( "Display window", image );
// cv::waitKey();
//estimator.setIm(image);
//estimator.setIndices(indices);
//estimator->compute(image,signature);
//test = signature.transpose();
cv::Mat image = cv::imread(fp);
Eigen::MatrixXf signature;
if(image.rows != 256 || image.cols != 256)
cv::resize( image, image, cv::Size(256, 256));
//bool success = estimator->computeCNN(signature);
estimator->compute(image,signature);
//all_model_signatures_.conservativeResize(all_model_signatures_.rows()+1,4096);
all_model_signatures_.row(old_rows+i) = signature.row(0);
models.conservativeResize(models.rows()+1);
models(models.rows()-1) = o;
// std::cout<<all_model_signatures_ <<std::endl;
std::cout<<"ok" <<std::endl;
}
}
std::string f_file = path;
v4r::io::writeDescrToFile(f_file.append("svm/Signatures.txt"),all_model_signatures_);
f_file = path;
v4r::io::writeLabelToFile(f_file.append("svm/Labels.txt"),models);
}
else{
all_model_signatures_ = v4r::io::readDescrFromFile(path+"svm/Signatures.txt",0,4096);
models = v4r::io::readLabelFromFile(path+"svm/Labels.txt",0);
std::cout << "Loading Descriptors and Labels from " << path << "svm." <<std::endl;
}
fs = path;
fs.append("svm/Class.model");
classifier.setOutFilename(fs);
//test.resize(all_model_signatures_.cols(),all_model_signatures_.rows());
//test = all_model_signatures_.transpose();
//classifier.shuffleTrainingData(all_model_signatures_, models);
classifier.param_.do_cross_validation_=0;
int testC = classifier.param_.svm_.C;
classifier.param_.svm_.probability=1;
classifier.setNumClasses(objects.size());
classifier.train(all_model_signatures_, models);
classifier.saveModel(fs);
}
IGL_INLINE bool igl::decimate(
const Eigen::MatrixXd & OV,
const Eigen::MatrixXi & OF,
const std::function<void(
const int,
const Eigen::MatrixXd &,
const Eigen::MatrixXi &,
const Eigen::MatrixXi &,
const Eigen::VectorXi &,
const Eigen::MatrixXi &,
const Eigen::MatrixXi &,
double &,
Eigen::RowVectorXd &)> & cost_and_placement,
const std::function<bool(
const Eigen::MatrixXd &,
const Eigen::MatrixXi &,
const Eigen::MatrixXi &,
const Eigen::VectorXi &,
const Eigen::MatrixXi &,
const Eigen::MatrixXi &,
const std::set<std::pair<double,int> > &,
const std::vector<std::set<std::pair<double,int> >::iterator > &,
const Eigen::MatrixXd &,
const int,
const int,
const int,
const int,
const int)> & stopping_condition,
const std::function<bool(
const Eigen::MatrixXd & ,/*V*/
const Eigen::MatrixXi & ,/*F*/
const Eigen::MatrixXi & ,/*E*/
const Eigen::VectorXi & ,/*EMAP*/
const Eigen::MatrixXi & ,/*EF*/
const Eigen::MatrixXi & ,/*EI*/
const std::set<std::pair<double,int> > & ,/*Q*/
const std::vector<std::set<std::pair<double,int> >::iterator > &,/*Qit*/
const Eigen::MatrixXd & ,/*C*/
const int /*e*/
)> & pre_collapse,
const std::function<void(
const Eigen::MatrixXd & , /*V*/
const Eigen::MatrixXi & , /*F*/
const Eigen::MatrixXi & , /*E*/
const Eigen::VectorXi & ,/*EMAP*/
const Eigen::MatrixXi & , /*EF*/
const Eigen::MatrixXi & , /*EI*/
const std::set<std::pair<double,int> > & , /*Q*/
const std::vector<std::set<std::pair<double,int> >::iterator > &, /*Qit*/
const Eigen::MatrixXd & , /*C*/
const int , /*e*/
const int , /*e1*/
const int , /*e2*/
const int , /*f1*/
const int , /*f2*/
const bool /*collapsed*/
)> & post_collapse,
const Eigen::MatrixXi & OE,
const Eigen::VectorXi & OEMAP,
const Eigen::MatrixXi & OEF,
const Eigen::MatrixXi & OEI,
Eigen::MatrixXd & U,
Eigen::MatrixXi & G,
Eigen::VectorXi & J,
Eigen::VectorXi & I
)
{
// Decimate 1
using namespace Eigen;
using namespace std;
// Working copies
Eigen::MatrixXd V = OV;
Eigen::MatrixXi F = OF;
Eigen::MatrixXi E = OE;
Eigen::VectorXi EMAP = OEMAP;
Eigen::MatrixXi EF = OEF;
Eigen::MatrixXi EI = OEI;
typedef std::set<std::pair<double,int> > PriorityQueue;
PriorityQueue Q;
std::vector<PriorityQueue::iterator > Qit;
Qit.resize(E.rows());
// If an edge were collapsed, we'd collapse it to these points:
MatrixXd C(E.rows(),V.cols());
for(int e = 0;e<E.rows();e++)
{
double cost = e;
RowVectorXd p(1,3);
cost_and_placement(e,V,F,E,EMAP,EF,EI,cost,p);
C.row(e) = p;
Qit[e] = Q.insert(std::pair<double,int>(cost,e)).first;
}
int prev_e = -1;
bool clean_finish = false;
while(true)
{
if(Q.empty())
{
break;
}
if(Q.begin()->first == std::numeric_limits<double>::infinity())
{
// min cost edge is infinite cost
break;
}
int e,e1,e2,f1,f2;
if(collapse_edge(
cost_and_placement, pre_collapse, post_collapse,
V,F,E,EMAP,EF,EI,Q,Qit,C,e,e1,e2,f1,f2))
{
if(stopping_condition(V,F,E,EMAP,EF,EI,Q,Qit,C,e,e1,e2,f1,f2))
{
clean_finish = true;
break;
}
}else
{
if(prev_e == e)
{
assert(false && "Edge collapse no progress... bad stopping condition?");
break;
}
// Edge was not collapsed... must have been invalid. collapse_edge should
// have updated its cost to inf... continue
}
prev_e = e;
}
// remove all IGL_COLLAPSE_EDGE_NULL faces
MatrixXi F2(F.rows(),3);
J.resize(F.rows());
int m = 0;
for(int f = 0;f<F.rows();f++)
{
if(
F(f,0) != IGL_COLLAPSE_EDGE_NULL ||
F(f,1) != IGL_COLLAPSE_EDGE_NULL ||
F(f,2) != IGL_COLLAPSE_EDGE_NULL)
{
F2.row(m) = F.row(f);
J(m) = f;
m++;
}
}
F2.conservativeResize(m,F2.cols());
J.conservativeResize(m);
VectorXi _1;
remove_unreferenced(V,F2,U,G,_1,I);
return clean_finish;
}
int main(int argc, char *argv[])
{
using namespace Eigen;
using namespace std;
igl::readOBJ(TUTORIAL_SHARED_PATH "/decimated-max.obj",V,F);
U=V;
// S(i) = j: j<0 (vertex i not in handle), j >= 0 (vertex i in handle j)
VectorXi S;
igl::readDMAT(TUTORIAL_SHARED_PATH "/decimated-max-selection.dmat",S);
igl::colon<int>(0,V.rows()-1,b);
b.conservativeResize(stable_partition( b.data(), b.data()+b.size(),
[&S](int i)->bool{return S(i)>=0;})-b.data());
// Boundary conditions directly on deformed positions
U_bc.resize(b.size(),V.cols());
V_bc.resize(b.size(),V.cols());
for(int bi = 0;bi<b.size();bi++)
{
V_bc.row(bi) = V.row(b(bi));
switch(S(b(bi)))
{
case 0:
// Don't move handle 0
U_bc.row(bi) = V.row(b(bi));
break;
case 1:
// move handle 1 down
U_bc.row(bi) = V.row(b(bi)) + RowVector3d(0,-50,0);
break;
case 2:
default:
// move other handles forward
U_bc.row(bi) = V.row(b(bi)) + RowVector3d(0,0,-25);
break;
}
}
// Pseudo-color based on selection
MatrixXd C(F.rows(),3);
RowVector3d purple(80.0/255.0,64.0/255.0,255.0/255.0);
RowVector3d gold(255.0/255.0,228.0/255.0,58.0/255.0);
for(int f = 0;f<F.rows();f++)
{
if( S(F(f,0))>=0 && S(F(f,1))>=0 && S(F(f,2))>=0)
{
C.row(f) = purple;
}else
{
C.row(f) = gold;
}
}
// Plot the mesh with pseudocolors
igl::opengl::glfw::Viewer viewer;
viewer.data().set_mesh(U, F);
viewer.data().show_lines = false;
viewer.data().set_colors(C);
viewer.core().trackball_angle = Eigen::Quaternionf(sqrt(2.0),0,sqrt(2.0),0);
viewer.core().trackball_angle.normalize();
viewer.callback_pre_draw = &pre_draw;
viewer.callback_key_down = &key_down;
//viewer.core().is_animating = true;
viewer.core().animation_max_fps = 30.;
cout<<
"Press [space] to toggle deformation."<<endl<<
"Press 'd' to toggle between biharmonic surface or displacements."<<endl;
viewer.launch();
}
