16_test_latent_space.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 "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 <filesystem>
 
#include <iostream>
#include <unordered_map>
 
using namespace netdem;
using namespace std;
 
void TestLatentSpace() {
  // 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;
 
  VecXT<Vec3d> searching_points = SphericalVoronoi::Solve(1000, 10000, 1.0e-4);
 
  // loop over all templates
  for (int ii = 0; ii < num_templates; ii++) {
    int num_intervals = 100;
 
    for (int jj = 0; jj <= num_intervals; jj++) {
      double weight = jj * 1.0 / num_intervals;
 
      VecXT<Vec3d> surf_vertices;
 
      for (auto vert : searching_points) {
        vert = vert * 0.5;
 
        for (int iter = 0; iter < 10; iter++) {
          arma::mat test_x_coded(num_latent_code + vert.size(), 1);
          for (int i = 0; i < num_latent_code; i++) {
            test_x_coded(i, 0) =
                latent_code(ii, i) * (1.0 - weight) +
                latent_code((ii + 1) % num_templates, i) * weight;
          }
          for (int i = num_latent_code; i < test_x_coded.n_rows; i++) {
            test_x_coded(i, 0) = vert[i - num_latent_code];
          }
 
          auto sdf = model.Predict(test_x_coded);
 
          if (abs(sdf(0, 0)) > 0.001) {
            auto dydx = model.Gradient(test_x_coded);
            vert[0] -= sdf(0, 0) * dydx(0, 0 + num_latent_code);
            vert[1] -= sdf(0, 0) * dydx(0, 1 + num_latent_code);
            vert[2] -= sdf(0, 0) * dydx(0, 2 + num_latent_code);
          } else {
            break;
          }
        }
 
        surf_vertices.emplace_back(vert);
      }
 
      // using spherical harmonics approach
      SphericalHarmonics sph;
      sph.InitFromSurfacePoints(surf_vertices);
 
      string root_dir = "shape_netsdf_" + IO::ToString(ii) + "_" +
                        IO::ToString((ii + 1) % num_templates);
      filesystem::create_directory(root_dir);
      sph.GetSTLModel(500).SaveAsSTL(root_dir + "/shape_netsdf_" +
                                     IO::ToString(ii) + "_" +
                                     IO::ToString((ii + 1) % num_templates) +
                                     "_" + IO::ToString(jj) + ".stl");
    }
  }
}