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);
  }
}
Beispiel #2
0
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);
  }
}
Beispiel #3
0
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";

}
Beispiel #4
0
/**
 * 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;
}
Beispiel #5
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);
  	  }
  	}
  }
Beispiel #6
0
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;
}