shape.hpp

Go to the documentation of this file.

#pragma once
 
#include "stl_model.hpp"
#include "utils_math.hpp"
#include <iostream>
#include <nlohmann/json.hpp>
#include <string>
 
namespace netdem {
 
class Shape {
public:
  enum Type {
    none,
    point_sphere,
    sphere,
    spherical_harmonics,
    trimesh,
    trimesh_convex,
    ellipsoid,
    polybezier,
    triangle,
    plane,
    cylinder,
    poly_super_ellipsoid,
    poly_super_quadrics,
    level_set,
    netsdf,
    coded_netsdf,
    num_shapes
  };
  int id{0};
 
  std::string label{"default"};
 
  Type shape_type{Type::none};
 
  std::string shape_name{"shape"};
 
protected:
  double size{1.0};
 
  double volume{0.5236};
 
  Mat3d inertia{{{0.05236, 0, 0}, {0, 0.05236, 0}, {0, 0, 0.05236}}};
 
  double bound_sphere_radius{0.5};
 
  double skin{0.025};
 
  double skin_factor{0.05};
 
  Vec3d bound_aabb_min{-0.5, -0.5, -0.5};
 
  Vec3d bound_aabb_max{0.5, 0.5, 0.5};
 
  bool is_convex{true};
 
public:
  bool use_customized_solver{false};
 
protected:
  bool use_surface_nodes{false};
 
  int surface_node_num{1000};
 
  double surface_node_spacing{std::sqrt(Math::PI / 1000.0)};
 
  VecXT<Vec3d> surface_nodes;
 
  VecXT<double> surface_node_areas;
 
public:
  STLModel render_mesh;
 
public:
  virtual nlohmann::json PackJson();
 
  virtual void InitFromJson(nlohmann::json const &js);
 
  virtual void InitFromJsonFile(std::string const &js_file);
 
  virtual double GetSize() const;
 
  virtual double GetVolume() const;
 
  virtual Mat3d const &GetInertia() const;
 
  Vec3d GetInertiaPrincipal() const;
 
  virtual double GetBoundSphereRadius() const;
 
  virtual std::tuple<Vec3d, Vec3d> GetBoundAABB() const;
 
  virtual std::tuple<Vec3d, Vec3d> GetBoundAABB(Vec3d const &pos,
                                                Vec4d const &quat) const;
 
  virtual double GetSkin() const;
 
  virtual double GetSkinFactor() const;
 
  virtual double GetSurfaceNodeNum() const;
 
  virtual VecXT<Vec3d> const &GetSurfaceNodes() const;
 
  virtual VecXT<double> const &GetSurfaceNodeAreas() const;
 
  virtual double GetSurfaceNodeSpacing() const;
 
  const STLModel &GetRenderMesh() const;
 
  bool CheckConvexity();
 
  virtual void Translate(Vec3d const &pos);
 
  virtual void UpdateSurfaceNodes();
 
  virtual void UpdateRenderMesh(int num_nodes = 200);
 
  virtual void UpdateShapeProperties();
 
  virtual void SetSize(double d);
 
  virtual void SetSkin(double sk);
 
  virtual void SetSkinFactor(double sk_factor);
 
  virtual void EnableSurfaceNodes();
 
  virtual void DisableSurfaceNodes();
 
  virtual bool IsSurfaceNodesEnabled();
 
  virtual void SetSurfaceNodeNum(int num);
 
  virtual void SetSurfaceNodes(VecXT<Vec3d> const &nodes);
 
  virtual void SetSurfaceNodes(STLModel const &surf_stl);
 
  virtual Shape *Clone() const;
 
  virtual STLModel GetSTLModel(int num_nodes = 200);
 
  virtual void SaveAsVTK(std::string const &filename);
 
  virtual void SaveAsSTL(std::string const &filename);
 
  virtual Vec3d SupportPoint(Vec3d const &dir);
 
  virtual VecXT<Vec3d> SupportPoints(Vec3d const &dir);
 
  virtual double SignedDistance(Vec3d const &pos) const;
 
  virtual Vec3d SurfacePoint(Vec3d const &pos);
 
  virtual bool CheckEnclose(Vec3d const &pos) const;
 
  virtual bool CheckPrincipal() const;
 
  virtual void Print();
 
  virtual ~Shape();
 
  static MatNd<8, 3> VerticesOfAABB(Vec3d const &bmin, Vec3d const &bmax);
};
 
} // namespace netdem