Completes transition to mesh agnostic implementation

Author: cheind

CMakeLists.txt

@@ -20,15 +20,14 @@ include_directories("inc" ${OPENMESH_INCLUDE_DIR} ${EIGEN_INCLUDE_DIR})
 list(APPEND DEFORM_LINK_TARGETS ${OPENMESH_LIBRARIES})
 
 add_library(deform
- inc/deform/mesh.h
- inc/deform/cotan_matrix.h
  inc/deform/arap.h
- src/arap.cpp
- src/cotan_matrix.cpp
+ inc/deform/openmesh_adapter.h
 )
+set_target_properties(deform PROPERTIES LINKER_LANGUAGE CXX)
 
 add_executable(deform_tests
  tests/catch.hpp
+ tests/accessor.h
  tests/test_cotan.cpp
 )
 target_link_libraries(deform_tests deform ${DEFORM_LINK_TARGETS})

examples/deform_sphere.cpp

@@ -10,6 +10,7 @@
 
 
 #include <deform/arap.h>
+#include <deform/openmesh_adapter.h>
 #include <string>
 #include <iostream>
 
@@ -20,37 +21,38 @@ int main(int argc, char **argv) {
 
  std::string pathToSource = std::string(DEFORM_ETC_DIR) + std::string("/sphere.obj");
 
- deform::Mesh mesh;
+ typedef OpenMesh::TriMesh_ArrayKernelT<> Mesh;
+ 
+ Mesh mesh;
  if (!OpenMesh::IO::read_mesh(mesh, pathToSource)) {
  std::cerr << "Failed to read mesh" << std::endl;
  return -1;
  }
 
 
- deform::Mesh::Point p = mesh.point(mesh.vertex_handle(32));
+ Mesh::Point p = mesh.point(mesh.vertex_handle(32));
  double pi = -M_PI_2;
  double add = 0.01;
- deform::example::OSGViewer viewer(argc, argv, &mesh, [&p, &pi, &add](deform::Mesh *mesh, double time) {
+ 
+ deform::OpenMeshAdapter<> ma(mesh);
+ deform::AsRigidAsPossibleDeformation< deform::OpenMeshAdapter<> > arap(ma);
+ 
+ // Set anchors
+ Mesh::VertexHandle va = mesh.vertex_handle(37);
+ arap.setConstraint(va.idx(), deform::convert::toEigen(mesh.point(va)));
+ 
+ deform::example::OSGViewer viewer(argc, argv, mesh, [&p, &pi, &add, &arap](Mesh &mesh, double time) {
 
  pi += add;
  if (std::abs(pi) > M_PI_2) {
  add *= -1.0;
  pi += add;
  }
 
- deform::OpenMeshAdapter ma(*mesh);
- deform::AsRigidAsPossibleDeformation2<deform::OpenMeshAdapter> arap(ma);
- 
- // Set anchors
- deform::Mesh::VertexHandle va = mesh->vertex_handle(37);
- arap.setConstraint(va.idx(), deform::toEigenF(mesh->point(va)));
- 
- deform::Mesh::VertexHandle vh = mesh->vertex_handle(32);
- arap.setConstraint(vh.idx(), deform::toEigenF(p + deform::Mesh::Point(0, 0, (float)(std::sin(pi)))));
+ Mesh::VertexHandle vh = mesh.vertex_handle(32);
+ arap.setConstraint(vh.idx(), deform::convert::toEigen(p + Mesh::Point(0, 0, (float)(std::sin(pi)))));
  arap.deform(3);
 
- ma.vertices(arap.updatedPositions());
- 
  return true;
  });
  viewer.run();

examples/osg_viewer.cpp

@@ -23,7 +23,7 @@ namespace deform {
  namespace example {
 
  struct OSGViewer::data {
- deform::Mesh *mesh;
+ OSGViewer::Mesh *mesh;
  DeformCallback dc;
  osg::ref_ptr<osgViewer::Viewer> viewer;
  osg::ref_ptr<osg::Group> root;
@@ -33,13 +33,13 @@ namespace deform {
  {
  public:
 
- OSGUpdateCallback(deform::Mesh *mesh, OSGViewer::DeformCallback *dc)
+ OSGUpdateCallback(OSGViewer::Mesh *mesh, OSGViewer::DeformCallback *dc)
  :_mesh(mesh), _dc(dc)
  {}
 
  virtual void operator()(osg::Node* node, osg::NodeVisitor* nv)
  {
- if ((*_dc)(_mesh, nv->getFrameStamp()->getReferenceTime())) {
+ if ((*_dc)(*_mesh, nv->getFrameStamp()->getReferenceTime())) {
  _mesh->update_normals();
 
  // Update vertex and normal buffer
@@ -50,10 +50,10 @@ namespace deform {
  osg::Vec3Array *normals = static_cast<osg::Vec3Array*>(geo->getNormalArray());
 
  for (auto v = _mesh->vertices_begin(); v != _mesh->vertices_end(); ++v) {
- deform::Mesh::Point p = _mesh->point(*v);
+ OSGViewer::Mesh::Point p = _mesh->point(*v);
  vertices->at(v->idx()) = osg::Vec3(p[0], p[1], p[2]);
 
- deform::Mesh::Point n = _mesh->normal(*v);
+ OSGViewer::Mesh::Point n = _mesh->normal(*v);
  normals->at(v->idx()) = osg::Vec3(n[0], n[1], n[2]);
  }
 
@@ -67,14 +67,14 @@ namespace deform {
  }
 
  private:
- deform::Mesh *_mesh;
+ OSGViewer::Mesh *_mesh;
  OSGViewer::DeformCallback *_dc;
  };
 
- OSGViewer::OSGViewer(int argc, char **argv, deform::Mesh *mesh, DeformCallback dc)
+ OSGViewer::OSGViewer(int argc, char **argv, OSGViewer::Mesh &mesh, DeformCallback dc)
  : _data(new data())
  {
- _data->mesh = mesh;
+ _data->mesh = &mesh;
  _data->mesh->request_face_normals();
  _data->mesh->request_vertex_normals();
  _data->mesh->update_normals();
@@ -117,10 +117,10 @@ namespace deform {
  osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array();
 
  for (auto v = _data->mesh->vertices_begin(); v != _data->mesh->vertices_end(); ++v) {
- deform::Mesh::Point p = _data->mesh->point(*v);
+ Mesh::Point p = _data->mesh->point(*v);
  vertices->push_back(osg::Vec3(p[0], p[1], p[2]));
 
- deform::Mesh::Point n = _data->mesh->normal(*v);
+ Mesh::Point n = _data->mesh->normal(*v);
  normals->push_back(osg::Vec3(n[0], n[1], n[2]));
  }
 
@@ -132,7 +132,7 @@ namespace deform {
  faces->push_back(v->idx()); ++v;
  faces->push_back(v->idx());
 
- deform::Mesh::Point p = _data->mesh->normal(*f);
+ Mesh::Point p = _data->mesh->normal(*f);
  normals->push_back(osg::Vec3(p[0], p[1], p[2]));
  }
 

examples/osg_viewer.h

@@ -11,7 +11,7 @@
 #ifndef DEFORM_OSG_VIEWER_H
 #define DEFORM_OSG_VIEWER_H
 
-#include <deform/mesh.h>
+#include <deform/openmesh_adapter.h>
 #include <memory>
 #include <functional>
 
@@ -20,9 +20,11 @@ namespace deform {
 
  class OSGViewer {
  public:
- typedef std::function<bool(deform::Mesh *, double)> DeformCallback;
+ typedef OpenMesh::TriMesh_ArrayKernelT<> Mesh;
 
- OSGViewer(int argc, char **argv, deform::Mesh *mesh, DeformCallback dc);
+ typedef std::function<bool(Mesh&, double)> DeformCallback;
+ 
+ OSGViewer(int argc, char **argv, Mesh &mesh, DeformCallback dc);
  OSGViewer(const OSGViewer &other) = delete;
  OSGViewer &operator=(const OSGViewer &other) = delete;
  ~OSGViewer();

inc/deform/arap.h

@@ -11,30 +11,28 @@
 #ifndef DEFORM_ARAP_H
 #define DEFORM_ARAP_H
 
-#include <deform/mesh.h>
-
 #include <Eigen/Core>
 #include <Eigen/Dense>
 #include <Eigen/Sparse>
 #include <Eigen/SVD>
 #include <vector>
 #include <unordered_map>
 
-#include <memory>
-
 namespace deform {
 
- template<class MeshAdapter>
- class AsRigidAsPossibleDeformation2 {
+ template<class T> class PrivateAccessor;
+ 
+ template<class Mesh>
+ class AsRigidAsPossibleDeformation {
  public:
- typedef typename MeshAdapter::Scalar Scalar;
+ typedef typename Mesh::Scalar Scalar;
  typedef int Index;
  typedef typename Eigen::Matrix<Scalar, 3, 1> Point;
 
- AsRigidAsPossibleDeformation2(const MeshAdapter &mesh)
- : _mesh(mesh), _dirty(false)
+ AsRigidAsPossibleDeformation(Mesh &mesh)
+ : _mesh(mesh), _dirty(true)
  {
- setupMeshTopology();
+ initializeMeshTopology();
  }
 
  void setConstraint(Index vidx, Eigen::Ref<const Point> loc) {
@@ -44,14 +42,16 @@ namespace deform {
 
  bool deform(Index numberOfIterations) {
  if (_dirty) {
- _pprime = _mesh.vertices();
- _p = _pprime;
 
+ initializeMeshGeometry();
  computeCotanWeights();
  initializeRotations();
  initializeFreeVariableMapping();
  initializeConstraints();
 
+ if (_numberOfFreeVariables == _mesh.numberOfVertices())
+ return true;
+ 
  if (!setupLinearSystem())
  return false;
 
@@ -66,6 +66,12 @@ namespace deform {
  // Estimate positions
  estimatePositions();
  }
+ 
+ // Update vertex locations at mesh
+ 
+ for (Index i = 0; i < _mesh.numberOfVertices(); ++i) {
+ _mesh.vertexLocation(i, _pprime.col(i));
+ }
 
  return true;
  }
@@ -75,10 +81,22 @@ namespace deform {
  }
 
  private:
+ template<class> friend class PrivateAccessor;
 
- void setupMeshTopology() {
+ void initializeMeshTopology() {
 
- _faces = _mesh.faces();
+ _faces.resize(3, _mesh.numberOfFaces());
+ for (Index f = 0; f < _mesh.numberOfFaces(); ++f) {
+ _faces.col(f) = _mesh.face(f);
+ }
+ }
+ 
+ void initializeMeshGeometry() {
+ _p.resize(3, _mesh.numberOfVertices());
+ for (Index v = 0; v < _mesh.numberOfVertices(); ++v) {
+ _p.col(v) = _mesh.vertexLocation(v);
+ }
+ _pprime = _p;
  }
 
  void computeCotanWeights() {
@@ -96,6 +114,7 @@ namespace deform {
  auto v1 = _p.col(vids(1));
  auto v2 = _p.col(vids(2));
 
+ 
  const Scalar l0 = (v1 - v0).norm();
  const Scalar l1 = (v2 - v1).norm();
  const Scalar l2 = (v0 - v2).norm();
@@ -285,7 +304,7 @@ namespace deform {
  typedef Eigen::Matrix<Scalar, 3, 3> RotationMatrix;
  typedef Eigen::SparseMatrix<Scalar, Eigen::RowMajor> SparseMatrix;
 
- const MeshAdapter &_mesh;
+ Mesh &_mesh;
  Eigen::Matrix<Scalar, 3, Eigen::Dynamic> _p, _pprime;
  Eigen::Matrix<Index, 3, Eigen::Dynamic> _faces;
  SparseMatrix _edgeWeights;
@@ -301,41 +320,10 @@ namespace deform {
  typedef Eigen::SparseMatrix<Scalar> LMatrixType;
  LMatrixType _L;
 
- 
  Eigen::Matrix<Scalar, 3, Eigen::Dynamic> _bFixed, _b;
  Eigen::SimplicialLDLT<LMatrixType> _solver;
 
  };
- 
- 
- class AsRigidAsPossibleDeformation {
- public:
- AsRigidAsPossibleDeformation(Mesh * mesh);
- ~AsRigidAsPossibleDeformation();
- AsRigidAsPossibleDeformation(const AsRigidAsPossibleDeformation &other) = delete;
- AsRigidAsPossibleDeformation &operator=(const AsRigidAsPossibleDeformation &other) = delete;
-
- void setConstraint(Mesh::VertexHandle v, const Mesh::Point &pos);
- void deform(size_t nIterations);
-
- private:
- void restorePositions();
- void attachMeshProperties();
- void releaseMeshProperties();
-
- void setupFreeVariableMap();
- void estimateRotations();
- void estimatePositions();
- void prepareLinearSystem();
-
-
-
-
-
- struct data;
- std::unique_ptr<data> _data;
- };
-
 }
 
 #endif