void MainWindow::loadInitFile(const string filename){
this->init_filename = filename;
if(boost::filesystem::exists(filename)){
DEBUG_LOG("begin to load vol_obj");
bool succ = _volObjCtrl->initialize(filename);
DEBUG_LOG("begin to init _dataModel");
succ &= _dataModel->loadSetting(filename);
_dataModel->prepareSimulation();
JsonFilePaser jsonf;
jsonf.open(filename);
double collision_k_stiffness, collision_k_limit, con_penalty;
jsonf.read("con_penalty", con_penalty, 1.0);
_perturb->setPerturCompilance(con_penalty);
INFO_LOG("con_penalty: "<<con_penalty );
_fileDialog->warning(succ);
string passive_obj_file;
if (_passiveObject&&jsonf.readFilePath("passive_object", passive_obj_file, true)){
_passiveObject->load(passive_obj_file);
double collision_penalty = 1.0f;
if (jsonf.read("collision_penalty", collision_penalty)){
_passiveObject->setCollisionPenalty(collision_penalty);
}
if (jsonf.read("collision_k_stiffness", collision_k_stiffness)){
_passiveObject->setKStiffness(collision_k_stiffness);
}
if (jsonf.read("collision_k_limit", collision_k_limit)){
_passiveObject->setKLimit(collision_k_limit);
}
}
}else{
ERROR_LOG("file " << filename <<" is not exist!" );
_fileDialog->warning(false);
}
}
void simulateAndSave(const string ini_file){
INFO_LOG("init file: "<< ini_file);
JsonFilePaser jsonf;
bool succ = jsonf.open(ini_file); assert(succ);
string save_to;
int num_frames;
succ = jsonf.readFilePath("save_to",save_to,false); assert(succ);
succ = jsonf.read("num_frames",num_frames,200); assert_ge(num_frames,0);
INFO_LOG("total frames: "<<num_frames);
pTetMesh tet_mesh = pTetMesh(new TetMesh());
{ // load tet mesh
string tet_file;
succ = jsonf.readFilePath("vol_file",tet_file); assert(succ);
succ = tet_mesh->load(tet_file); assert(succ);
INFO_LOG("number of nodes: " << tet_mesh->nodes().size());
INFO_LOG("number of tets: " << tet_mesh->tets().size());
vector<double> move;
if (jsonf.read("move_mesh",move)){
assert_eq(move.size(),3);
VectorXd u(tet_mesh->nodes().size()*3);
for (int i = 0; i < u.size()/3; ++i){
u[i*3+0] = move[0];
u[i*3+1] = move[1];
u[i*3+2] = move[2];
}
tet_mesh->applyDeformation(u);
}
string mtl_file;
succ = jsonf.readFilePath("elastic_mtl",mtl_file); assert(succ);
succ = tet_mesh->loadElasticMtl(mtl_file); assert(succ);
}
pFullStVKSimModel def_model = pFullStVKSimModel(new FullStVKSimModel());
def_model->setTetMesh(tet_mesh);
// BoxCollisionHandling collision_sim(def_model);
PlaneCollisionHandling collision_sim(def_model);
succ = collision_sim.prepare(); assert(succ);
succ = collision_sim.init(ini_file); assert(succ);
// set gravity
vector<double> gravity;
succ &= jsonf.read("gravity",gravity);
assert_eq(gravity.size(),3);
VectorXd gravity_forces;
tet_mesh->computeGravity(gravity, gravity_forces);
collision_sim.setExtForce(gravity_forces);
{// simulation, save results
vector<VectorXd> record_u;
Timer timer;
timer.start();
for (int i = 0; i < num_frames; ++i){
INFO_LOG("step: " << i);
collision_sim.forward();
record_u.push_back(collision_sim.getU());
}
timer.stop("total simulation time: ");
bool succ = tet_mesh->writeVTK(save_to, record_u);
assert(succ);
}
}
void case_one()
{
// open init json file
const string ini_file = "/home/wegatron/workspace/embedded_thin_shell/branches/chenjiong/dat/simple_cube/simu_full.ini";
JsonFilePaser jsonf;
bool succ = jsonf.open(ini_file);
assert(succ);
pTetMesh tet_mesh = pTetMesh(new TetMesh());
{ // init tetrahedron mesh.
string vol_file;
succ = jsonf.readFilePath("vol_file",vol_file);
assert(succ);
succ = tet_mesh->load(vol_file);
assert(succ);
string mtl_file;
jsonf.readFilePath("elastic_mtl",mtl_file);
succ = tet_mesh->loadElasticMtl(mtl_file);
assert(succ);
}
pSimulator simulator = pSimulator(new FullStVKSimulator());
{ // init simulator
succ = simulator->init(ini_file);
assert(succ);
simulator->setVolMesh(tet_mesh);
simulator->precompute();
}
{ // load and set fixed nodes
vector<int> nodes;
succ = UTILITY::loadVec("/home/wegatron/workspace/embedded_thin_shell/branches/chenjiong/dat/simple_cube/model/con_nodes.bou", nodes,UTILITY::TEXT);
assert(succ);
cout << "num of fixed nodes: " << nodes.size() << endl;
simulator->setConNodes(nodes);
VectorXd uc(nodes.size()*3);
uc.setZero();
simulator->setUc(uc);
}
// simulation for 200 steps, record displacements
vector<VectorXd> record_u;
{ // set external forces, then simulate 50 steps
const double f[3] = {0, 0, 700000};
simulator->setExtForceOfNode(0, f);
simulator->setExtForceOfNode(1, f);
simulator->setExtForceOfNode(2, f);
simulator->setExtForceOfNode(3, f);
for (int i = 0; i < 800; ++i){
cout << "step " << i << endl;
simulator->forward();
VectorXd &v = simulator->getV();
VectorXd &u = simulator->getModifyFullDisp();
collision_plane(tet_mesh->nodes(), v, u, 0.6, 1.8, true);
record_u.push_back(simulator->getFullDisp());
}
}
{ // save as vtk files.
succ = tet_mesh->writeVTK("/home/wegatron/tempt/test_collision", record_u);
if (!succ)
{
cout << "error output" << endl;
}
assert(succ);
}
cout << "[INFO]DONE!\n";
}
/**
* Required input (using a json file):
*
* B: basis matrix, generated by model derivative or by extending MA basis.
* tet_mesh: tetrahedron mesh.
* training_full_disp: displacements in full space, e.g. u[i].
* training_full_forces: forces in full sapce, e.g. f[i].
* rel_err_tol: relative error tolerance, usually set as 0.05.
* max_points: desired number of samples, usually set as 80.
* cands_per_iter: usually set as 400.
* iters_per_full_nnls: usually set as 10.
* samples_per_subtrain: usually set as 100.
*
* @see 1. An efficient construction of reduced deformable objects, asia 2013.
* 2. Optimizing Cubature for Efficient Integration of Subspace Deformations. asia 2008.
*
*/
int main(int argc, char *argv[]){
// check
if (argc < 2){
ERROR_LOG("ussage: ./cubature json_file_name");
return -1;
}
JsonFilePaser jsonf;
if(!jsonf.open(argv[1])){
ERROR_LOG("failed to open json file: " << argv[1]);
return -1;
}
// load basis
INFO_LOG("loading data....");
MatrixXd B;
jsonf.readMatFile("subspace_basis",B);
// load tetrahedron mesh, and elastic material
pTetMesh tet_mesh = pTetMesh(new TetMesh());
string tet_file, elastic_mtl;
if(jsonf.readFilePath("vol_file", tet_file)){
if(!tet_mesh->load(tet_file)){
ERROR_LOG("failed to load tet mesh file: " << tet_file);
return -1;
}else if(jsonf.readFilePath("elastic_mtl", elastic_mtl)){
const bool s = tet_mesh->loadElasticMtl(elastic_mtl);
ERROR_LOG_COND("failed to load the elastic material from: "<<elastic_mtl,s);
}
}
assert_eq(B.rows(), tet_mesh->nodes().size()*3);
// load training data
MatrixXd training_full_disp, training_full_forces;
jsonf.readMatFile("training_full_u", training_full_disp);
jsonf.readMatFile("training_full_f", training_full_forces);
// load other parameters
double rel_err_tol;
int max_points, cands_per_iter, iters_per_full_nnls, samples_per_subtrain;
jsonf.read("rel_err_tol", rel_err_tol,0.05);
jsonf.read("max_samples", max_points,80);
jsonf.read("cands_per_iter", cands_per_iter,400);
jsonf.read("iters_per_full_nnls", iters_per_full_nnls,10);
jsonf.read("samples_per_subtrain", samples_per_subtrain,100);
// run cubature
INFO_LOG("running cubature....");
ReducedSimCubature cuba(B, tet_mesh);
cuba.run(training_full_disp,
training_full_forces,
rel_err_tol,
max_points,
cands_per_iter,
iters_per_full_nnls,
samples_per_subtrain);
// save cubature
cout<< "cubature weights:\n " << cuba.getWeights().transpose() << endl << endl;;
string save_points;
jsonf.readFilePath("cubature_points", save_points,string("cubpoints.txt"),false);
INFO_LOG("save samples to: "<< save_points);
UTILITY::writeVec(save_points,cuba.getSelectedTets(),UTILITY::TEXT);
string save_weights;
jsonf.readFilePath("cubature_weights", save_weights,string("cubweights.b"),false);
INFO_LOG("save weights to: "<< save_weights);
UTILITY::writeVec(save_weights,cuba.getWeights());
bool succ = cuba.saveAsVTK(save_points+".vtk");
ERROR_LOG_COND("failed to save as vtk: "<< save_points+".vtk",succ);
return 0;
}
MtlOptModel::MtlOptModel(const string initf){
// load mtl
JsonFilePaser jsonf;
TEST_ASSERT ( jsonf.open(initf) );
TEST_ASSERT ( jsonf.read("T",T) );
TEST_ASSERT ( jsonf.read("h",h) );
TEST_ASSERT ( jsonf.read("alpha_k",alphaK) );
TEST_ASSERT ( jsonf.read("alpha_m",alphaM) );
// read modes, and lambda
VectorXd t_lambda;
TEST_ASSERT ( jsonf.readVecFile("eigenvalues",t_lambda) );
double lambda0_scale = 1.0f;
if ( jsonf.read("lambda0_scale", lambda0_scale) ){
assert_gt(lambda0_scale,0);
t_lambda *= lambda0_scale;
}
int number_modes = 0;
TEST_ASSERT ( jsonf.read("rw", number_modes) );
if (number_modes <= 0)
number_modes = t_lambda.size();
testModeId.resize(number_modes);
for (int i = 0; i < number_modes; ++i)
testModeId[i] = i;
lambda.resize(testModeId.size());
ASSERT_LE(testModeId.size(),t_lambda.size());
for (int i = 0; i < testModeId.size(); ++i)
lambda[i] = t_lambda[testModeId[i]];
if(!jsonf.read("rs",r_s)){
r_s = lambda.size();
}
// keyframe constraints
int fix_head = 0, fix_end = 0;
TEST_ASSERT ( jsonf.read("fix_head", fix_head) );
TEST_ASSERT ( jsonf.read("fix_end", fix_end) );
Kid.clear();
for (int i = 0; i < fix_head; ++i){
Kid.push_back(i);
}
for (int i = T-fix_end; i < T; ++i){
Kid.push_back(i);
}
this->Kz.resize(selectedRedDim(),Kid.size());
this->Kz.setZero();
// partial constraints
partialConPenalty = 10.0f;
string partial_con_str;
if (jsonf.readFilePath("partial_con",partial_con_str)){
TEST_ASSERT ( jsonf.read("con_penalty",partialConPenalty) );
PartialConstraintsSet AllConNodes;
TEST_ASSERT ( AllConNodes.load(partial_con_str) );
const set<pPartialConstraints> &con_groups=AllConNodes.getPartialConSet();
BOOST_FOREACH(pPartialConstraints pc, con_groups){
if ( pc != NULL && !pc->isEmpty() ) {
vector<int> conNod;
VectorXd conPos;
pc->getPartialCon(conNod,conPos);
conFrames.push_back(pc->getFrameId());
conNodes.push_back(conNod);
uc.push_back(conPos);
}
}
}
int main(int argc, char *argv[]){
// check
if (argc < 2){
ERROR_LOG("ussage: extend_basis ini_json_file_name");
return -1;
}
JsonFilePaser jsonf;
if(!jsonf.open(argv[1])){
ERROR_LOG("failed to open json file: " << argv[1]);
return -1;
}
// load data
INFO_LOG("loading data....");
pTetMesh tet_mesh = pTetMesh(new TetMesh());
string tet_file, elastic_mtl;
if(jsonf.readFilePath("vol_file", tet_file)){
if(!tet_mesh->load(tet_file)){
ERROR_LOG("failed to load tet mesh file: " << tet_file);
return -1;
}else if(jsonf.readFilePath("elastic_mtl", elastic_mtl)){
const bool s = tet_mesh->loadElasticMtl(elastic_mtl);
ERROR_LOG_COND("failed to load the elastic material from: "<<elastic_mtl,s);
}
}
set<int> fixed_nodes;
jsonf.readVecFile("fixed_nodes", fixed_nodes,UTILITY::TEXT);
INFO_LOG("number of fixed nodes: " << fixed_nodes.size());
int num_linear_modes = fixed_nodes.size()>0 ? 15:20;
jsonf.read("num_linear_modes",num_linear_modes,num_linear_modes);
INFO_LOG("number of linear modes: " << num_linear_modes);
/// compute full K, M
INFO_LOG("computing full K, M....");
ElasticForceTetFullStVK ela(tet_mesh);
ela.prepare();
VectorXd x0;
tet_mesh->nodes(x0);
SparseMatrix<double> K = ela.K(x0)*(-1.0f);
MassMatrix mass;
DiagonalMatrix<double,-1> diagM;
mass.compute(diagM,*tet_mesh);
/// remove fixed nodes
INFO_LOG("remove fixed dofs in K, M....");
SparseMatrix<double> P;
EIGEN3EXT::genReshapeMatrix(K.rows(),3,fixed_nodes,P);
K = P*(K*P.transpose());
const SparseMatrix<double> M = P*(diagM*P.transpose());
/// solve general eigen value problem for W, lambda
INFO_LOG("solving general eigen value problem K*x = la*M*x....");
MatrixXd W;
VectorXd lambda;
const SparseMatrix<double> Klower = getLower(K);
if(!EigenSparseGenEigenSolver::solve(Klower,M,W,lambda,num_linear_modes)){
ERROR_LOG("failed to solve the general eigen value problem.");
return -1;
}
if (fixed_nodes.size() > 0){
W = P.transpose()*W;
}
// extend basis W to obtain B
INFO_LOG("extending basis....");
MatrixXd B;
if (fixed_nodes.size() > 0){
ExtendModalBasis::construct(W, B);
}else{
ExtendModalBasis::construct(W, x0, B);
}
// save
string save_b;
jsonf.readFilePath("subspace_basis",save_b,string("B.b"),false);
INFO_LOG("save extended basis to: "<< save_b);
if(!write(save_b, B)){
ERROR_LOG("failed to save the extended basis to: " << save_b);
}
return 0;
}