15_test_coded_shape.cpp

This is an example of how to use the netdem library.

#include "cgal_wrapper.hpp"
#include "contact_solver_factory.hpp"
#include "data_dumper.hpp"
#include "gen_pack.hpp"
#include "gen_wall_box_plane.hpp"
#include "golden_spiral_sampler.hpp"
#include "gravity.hpp"
#include "model_linear_spring.hpp"
#include "model_volume_based.hpp"
#include "shape_netsdf.hpp"
#include "shape_plane.hpp"
#include "shape_spherical_harmonics.hpp"
#include "shape_trimesh.hpp"
#include "simulation.hpp"
#include "spherical_voronoi.hpp"
#include "stl_model.hpp"
#include "wscvt_sampler.hpp"
 
#include <iostream>
#include <unordered_map>
 
using namespace netdem;
using namespace std;
 
void TestCodedShape() {
  // imporat the name list of templates
  vector<string> template_names;
  ifstream file("template_dict.txt");
  if (file.is_open()) {
    string line;
    while (getline(file, line)) {
      template_names.push_back(line);
    }
    file.close();
  } else {
    cout << "file template_dict.txt not exist" << endl;
    return;
  }
  int num_templates = template_names.size();
 
  // loading latent code
  arma::mat latent_code;
  mlpack::data::Load("latent_code.txt", latent_code, false, false);
  int num_latent_code = latent_code.n_cols;
 
  // loading ann model
  RegressionNet model;
  model.Load("ann_SDF.xml", "SDF");
  cout << "finished loading ann model ..." << endl;
 
  auto searching_points = GoldenSpiralSampler::GetInstance().Get(2000);
 
  STLModel stl_model;
  IGLWrapper::ConvexHull(searching_points, &(stl_model.vertices),
                         &(stl_model.facets));
  searching_points = stl_model.vertices;
 
  int num_samples = searching_points.size();
  VecXd sdf_list(num_samples);
 
  // loop over all templates
  for (int ii = 0; ii < num_templates; ii++) {
    for (int jj = 0; jj < num_samples; jj++) {
      auto search_point = searching_points[jj] * 0.5;
      auto surf_point = stl_model.vertices[jj] * 0.5;
 
      for (int iter = 0; iter < 100; iter++) {
        arma::mat test_x_coded(num_latent_code + surf_point.size(), 1);
        for (int i = 0; i < num_latent_code; i++) {
          test_x_coded(i, 0) = latent_code(ii, i);
        }
        for (int i = num_latent_code; i < test_x_coded.n_rows; i++) {
          test_x_coded(i, 0) = surf_point[i - num_latent_code];
        }
 
        auto sdf = model.Predict(test_x_coded);
        sdf_list[jj] = sdf(0, 0);
 
        if (abs(sdf(0, 0)) > 0.001) {
          // // using gradient
          // auto dydx = model.Gradient(test_x_coded);
          // surf_point[0] -= sdf(0, 0) * dydx(0, 0 + num_latent_code);
          // surf_point[1] -= sdf(0, 0) * dydx(0, 1 + num_latent_code);
          // surf_point[2] -= sdf(0, 0) * dydx(0, 2 + num_latent_code);
 
          // using sdf
          surf_point[0] += sdf(0, 0) * search_point[0];
          surf_point[1] += sdf(0, 0) * search_point[1];
          surf_point[2] += sdf(0, 0) * search_point[2];
        } else {
          break;
        }
      }
 
      stl_model.vertices[jj] = surf_point;
    }
 
    stl_model.SaveAsSTL(template_names[ii] + "/shape_netsdf.stl");
 
    /* using alpha-shape approach
    CGALWrapper::GetAlphaShape(&(stl_model.vertices), &(stl_model.facets),
                               stl_model.vertices, 0.7);
    stl_model.SaveAsSTL(template_names[ii] + "/shape_netsdf.stl"); // */
 
    /* using spherical harmonics approach
    SphericalHarmonics sph;
    sph.InitFromSurfacePoints(stl_model.vertices);
 
    sph.GetSTLModel(500).SaveAsSTL(template_names[ii] + "/shape_netsdf.stl");
    // */
 
    // save the data points
    stringbuf buf;
    ostream os(&buf);
    int os_width = 24;
    os.setf(ios::scientific);
    os.precision(15);
 
    for (int i = 0; i < num_samples; i++) {
      // write the data as one sample one row
      for (int i_inputs = 0; i_inputs < 3; i_inputs++) {
        os.width(os_width);
        os << stl_model.vertices[i][i_inputs] << ", ";
      }
      os.width(os_width);
      os << sdf_list[i] << endl;
    }
 
    string filename = template_names[ii] + "/surface_points.txt";
    ofstream outfile;
    outfile.open(filename);
    if (!outfile) {
      cout << "cannot open file: " << filename << endl;
    }
    outfile << buf.str();
    outfile.close();
    cout << "data saved to: " << filename << endl;
  }
}