From 5fab3cefd18c07494643c0db613f9447d2f43734 Mon Sep 17 00:00:00 2001
From: cignoni <paolo.cignoni@isti.cnr.it>
Date: Sat, 9 Aug 2014 00:15:52 +0000
Subject: [PATCH] Added namespaces, copyright and a bit of cleaning...

---
 vcg/complex/algorithms/mesh_to_matrix.h | 372 ++++++++++++------------
 1 file changed, 184 insertions(+), 188 deletions(-)

diff --git a/vcg/complex/algorithms/mesh_to_matrix.h b/vcg/complex/algorithms/mesh_to_matrix.h
index a538d36b..595a1eb0 100644
--- a/vcg/complex/algorithms/mesh_to_matrix.h
+++ b/vcg/complex/algorithms/mesh_to_matrix.h
@@ -1,218 +1,214 @@
+/****************************************************************************
+* VCGLib                                                            o o     *
+* Visual and Computer Graphics Library                            o     o   *
+*                                                                _   O  _   *
+* Copyright(C) 2004                                                \/)\/    *
+* Visual Computing Lab                                            /\/|      *
+* ISTI - Italian National Research Council                           |      *
+*                                                                    \      *
+* All rights reserved.                                                      *
+*                                                                           *
+* This program is free software; you can redistribute it and/or modify      *
+* it under the terms of the GNU General Public License as published by      *
+* the Free Software Foundation; either version 2 of the License, or         *
+* (at your option) any later version.                                       *
+*                                                                           *
+* This program is distributed in the hope that it will be useful,           *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
+* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
+* for more details.                                                         *
+*                                                                           *
+****************************************************************************/
 #ifndef MESH_TO_MATRIX
 #define MESH_TO_MATRIX
 
-#include <vector>
-#include <list>
-#include <utility>
-#include <Eigen/Dense>
-#include <vcg/complex/algorithms/update/topology.h>
 #include <vcg/complex/complex.h>
+#include <vcg/complex/algorithms/update/topology.h>
 
 using namespace std;
 
-namespace vcg{
+namespace vcg {
+namespace tri {
 template < typename TriMeshType >
 class MeshToMatrix
 {
 
-    // define types
+  // define types
 
-    typedef typename TriMeshType::FaceType FaceType;
-    typedef typename TriMeshType::VertexType VertexType;
-    typedef typename TriMeshType::CoordType CoordType;
-    typedef typename TriMeshType::ScalarType ScalarType;
+  typedef typename TriMeshType::FaceType FaceType;
+  typedef typename TriMeshType::VertexType VertexType;
+  typedef typename TriMeshType::CoordType CoordType;
+  typedef typename TriMeshType::ScalarType ScalarType;
 
-    static void GetTriEdgeAdjacency(const Eigen::MatrixXd& V,
-                                    const Eigen::MatrixXi& F,
-                                    Eigen::MatrixXi& EV,
-                                    Eigen::MatrixXi& FE,
-                                    Eigen::MatrixXi& EF)
+  static void GetTriEdgeAdjacency(const Eigen::MatrixXd& V,
+                                  const Eigen::MatrixXi& F,
+                                  Eigen::MatrixXi& EV,
+                                  Eigen::MatrixXi& FE,
+                                  Eigen::MatrixXi& EF)
+  {
+    //assert(igl::is_manifold(V,F));
+    std::vector<std::vector<int> > ETT;
+    for(int f=0;f<F.rows();++f)
+      for (int i=0;i<3;++i)
+      {
+        // v1 v2 f vi
+        int v1 = F(f,i);
+        int v2 = F(f,(i+1)%3);
+        if (v1 > v2) std::swap(v1,v2);
+        std::vector<int> r(4);
+        r[0] = v1; r[1] = v2;
+        r[2] = f;  r[3] = i;
+        ETT.push_back(r);
+      }
+    std::sort(ETT.begin(),ETT.end());
+
+    // count the number of edges (assume manifoldness)
+    int En = 1; // the last is always counted
+    for(unsigned i=0;i<ETT.size()-1;++i)
+      if (!((ETT[i][0] == ETT[i+1][0]) && (ETT[i][1] == ETT[i+1][1])))
+        ++En;
+
+    EV = Eigen::MatrixXi::Constant((int)(En),2,-1);
+    FE = Eigen::MatrixXi::Constant((int)(F.rows()),3,-1);
+    EF = Eigen::MatrixXi::Constant((int)(En),2,-1);
+    En = 0;
+
+    for(unsigned i=0;i<ETT.size();++i)
     {
-        //assert(igl::is_manifold(V,F));
-        std::vector<std::vector<int> > ETT;
-        for(int f=0;f<F.rows();++f)
-            for (int i=0;i<3;++i)
-            {
-                // v1 v2 f vi
-                int v1 = F(f,i);
-                int v2 = F(f,(i+1)%3);
-                if (v1 > v2) std::swap(v1,v2);
-                std::vector<int> r(4);
-                r[0] = v1; r[1] = v2;
-                r[2] = f;  r[3] = i;
-                ETT.push_back(r);
-            }
-        std::sort(ETT.begin(),ETT.end());
-
-        // count the number of edges (assume manifoldness)
-        int En = 1; // the last is always counted
-        for(unsigned i=0;i<ETT.size()-1;++i)
-            if (!((ETT[i][0] == ETT[i+1][0]) && (ETT[i][1] == ETT[i+1][1])))
-                ++En;
-
-        EV = Eigen::MatrixXi::Constant((int)(En),2,-1);
-        FE = Eigen::MatrixXi::Constant((int)(F.rows()),3,-1);
-        EF = Eigen::MatrixXi::Constant((int)(En),2,-1);
-        En = 0;
-
-        for(unsigned i=0;i<ETT.size();++i)
-        {
-            if (i == ETT.size()-1 ||
-                    !((ETT[i][0] == ETT[i+1][0]) && (ETT[i][1] == ETT[i+1][1]))
-                    )
-            {
-                // Border edge
-                std::vector<int>& r1 = ETT[i];
-                EV(En,0)     = r1[0];
-                EV(En,1)     = r1[1];
-                EF(En,0)    = r1[2];
-                FE(r1[2],r1[3]) = En;
-            }
-            else
-            {
-                std::vector<int>& r1 = ETT[i];
-                std::vector<int>& r2 = ETT[i+1];
-                EV(En,0)     = r1[0];
-                EV(En,1)     = r1[1];
-                EF(En,0)    = r1[2];
-                EF(En,1)    = r2[2];
-                FE(r1[2],r1[3]) = En;
-                FE(r2[2],r2[3]) = En;
-                ++i; // skip the next one
-            }
-            ++En;
-        }
-
-        // Sort the relation EF, accordingly to EV
-        // the first one is the face on the left of the edge
-
-        for(unsigned i=0; i<EF.rows(); ++i)
-        {
-            int fid = EF(i,0);
-            bool flip = true;
-            // search for edge EV.row(i)
-            for (unsigned j=0; j<3; ++j)
-            {
-                if ((F(fid,j) == EV(i,0)) && (F(fid,(j+1)%3) == EV(i,1)))
-                    flip = false;
-            }
-
-            if (flip)
-            {
-                int tmp = EF(i,0);
-                EF(i,0) = EF(i,1);
-                EF(i,1) = tmp;
-            }
-        }
+      if (i == ETT.size()-1 ||
+          !((ETT[i][0] == ETT[i+1][0]) && (ETT[i][1] == ETT[i+1][1]))
+          )
+      {
+        // Border edge
+        std::vector<int>& r1 = ETT[i];
+        EV(En,0)     = r1[0];
+        EV(En,1)     = r1[1];
+        EF(En,0)    = r1[2];
+        FE(r1[2],r1[3]) = En;
+      }
+      else
+      {
+        std::vector<int>& r1 = ETT[i];
+        std::vector<int>& r2 = ETT[i+1];
+        EV(En,0)     = r1[0];
+        EV(En,1)     = r1[1];
+        EF(En,0)    = r1[2];
+        EF(En,1)    = r2[2];
+        FE(r1[2],r1[3]) = En;
+        FE(r2[2],r2[3]) = En;
+        ++i; // skip the next one
+      }
+      ++En;
     }
 
+    // Sort the relation EF, accordingly to EV
+    // the first one is the face on the left of the edge
+
+    for(unsigned i=0; i<EF.rows(); ++i)
+    {
+      int fid = EF(i,0);
+      bool flip = true;
+      // search for edge EV.row(i)
+      for (unsigned j=0; j<3; ++j)
+      {
+        if ((F(fid,j) == EV(i,0)) && (F(fid,(j+1)%3) == EV(i,1)))
+          flip = false;
+      }
+
+      if (flip)
+      {
+        int tmp = EF(i,0);
+        EF(i,0) = EF(i,1);
+        EF(i,1) = tmp;
+      }
+    }
+  }
+
 public:
 
-    // return mesh as vactor of vertices and faces
-    static void GetTriMeshData(const TriMeshType &mesh,
-                               Eigen::MatrixXi &faces,
-                               Eigen::MatrixXd &vert)
-    {
-        // create eigen matrix of vertices
-        vert=Eigen::MatrixXd(mesh.VN(), 3);
+  // return mesh as vector of vertices and faces
+  static void GetTriMeshData(const TriMeshType &mesh,
+                             Eigen::MatrixXi &faces,
+                             Eigen::MatrixXd &vert)
+  {
+    tri::RequireCompactness(mesh);
+    // create eigen matrix of vertices
+    vert=Eigen::MatrixXd(mesh.VN(), 3);
 
-        // copy vertices
-        for (int i = 0; i < mesh.VN(); i++)
-            for (int j = 0; j < 3; j++)
-                vert(i,j) = mesh.vert[i].cP()[j];
+    // copy vertices
+    for (int i = 0; i < mesh.VN(); i++)
+      for (int j = 0; j < 3; j++)
+        vert(i,j) = mesh.vert[i].cP()[j];
 
-        // create eigen matrix of faces
-        faces=Eigen::MatrixXi(mesh.FN(), 3);
+    // create eigen matrix of faces
+    faces=Eigen::MatrixXi(mesh.FN(), 3);
 
-        // copy faces
-        const VertexType *v0 = &mesh.vert[0];
-        for (int i = 0; i < mesh.FN(); i++)
-            for (int j = 0; j < 3; j++)
-            {
-                faces(i,j) = (int)(mesh.face[i].cV(j) - v0);
-                assert(faces(i,j) >= 0 && faces(i,j) < mesh.VN());
-            }
-    }
+    // copy faces
+    for (int i = 0; i < mesh.FN(); i++)
+      for (int j = 0; j < 3; j++)
+        faces(i,j) = (int)tri::Index(mesh,mesh.face[i].cV(j));
+  }
 
-    // return normals of the mesh
-    static void GetNormalData(const TriMeshType &mesh,
-                              Eigen::MatrixXd &Nvert,
-                              Eigen::MatrixXd &Nface)
-    {
-        // create eigen matrix of vertices
-        Nvert=Eigen::MatrixXd(mesh.VN(), 3);
-        Nface=Eigen::MatrixXd(mesh.FN(), 3);
+  // return normals of the mesh
+  static void GetNormalData(const TriMeshType &mesh,
+                            Eigen::MatrixXd &Nvert,
+                            Eigen::MatrixXd &Nface)
+  {
+    // create eigen matrix of vertices
+    Nvert=Eigen::MatrixXd(mesh.VN(), 3);
+    Nface=Eigen::MatrixXd(mesh.FN(), 3);
 
-        // per vertices normals
-        for (int i = 0; i < mesh.VN(); i++)
-            for (int j = 0; j < 3; j++)
-                Nvert(i,j) = mesh.vert[i].cN()[j];
+    // per vertices normals
+    for (int i = 0; i < mesh.VN(); i++)
+      for (int j = 0; j < 3; j++)
+        Nvert(i,j) = mesh.vert[i].cN()[j];
 
-        // per vertices normals
-        for (int i = 0; i < mesh.FN(); i++)
-            for (int j = 0; j < 3; j++)
-                Nface(i,j) = mesh.face[i].cN()[j];
-    }
+    // per vertices normals
+    for (int i = 0; i < mesh.FN(); i++)
+      for (int j = 0; j < 3; j++)
+        Nface(i,j) = mesh.face[i].cN()[j];
+  }
 
-    // get face to face adjacency
-    static void GetTriFFAdjacency(TriMeshType &mesh,
-                                  Eigen::MatrixXi &FFp,
-                                  Eigen::MatrixXi &FFi)
-    {
-        vcg::tri::UpdateTopology<TriMeshType>::FaceFace(mesh);
-//        FFp = Eigen::PlainObjectBase<int>::Constant(mesh.FN(),3,-1);
-//        FFi = Eigen::PlainObjectBase<int>::Constant(mesh.FN(),3,-1);
+  // get face to face adjacency
+  static void GetTriFFAdjacency(TriMeshType &mesh,
+                                Eigen::MatrixXi &FFp,
+                                Eigen::MatrixXi &FFi)
+  {
+    tri::UpdateTopology<TriMeshType>::FaceFace(mesh);
+    FFp = Eigen::MatrixXi(mesh.FN(),3);
+    FFi = Eigen::MatrixXi(mesh.FN(),3);
 
-        FFp = Eigen::MatrixXi(mesh.FN(),3);
-        FFi = Eigen::MatrixXi(mesh.FN(),3);
-
-        for (int i = 0; i < mesh.FN(); i++)
-            for (int j = 0; j < 3; j++)
-            {
-                FaceType *AdjF=mesh.face[i].FFp(j);
-                if (AdjF==&mesh.face[i])
-                {
-                    FFp(i,j)=-1;
-                    FFi(i,j)=-1;
-                    continue;
-                }
-
-                int AdjF_Index=vcg::tri::Index(mesh,AdjF);
-                int OppF_Index=mesh.face[i].FFi(j);
-
-
-                FFp(i,j)=AdjF_Index;
-                FFi(i,j)=OppF_Index;
-
-                assert(AdjF_Index >= 0 && AdjF_Index < mesh.FN());
-            }
-    }
-
-    // get edge to face and edge to vertex adjacency
-    static void GetTriEdgeAdjacency(const TriMeshType &mesh,
-                                    Eigen::MatrixXi& EV,
-                                    Eigen::MatrixXi& FE,
-                                    Eigen::MatrixXi& EF)
-    {
-        Eigen::MatrixXi faces;
-        Eigen::MatrixXd vert;
-        GetTriMeshData(mesh,faces,vert);
-        GetTriEdgeAdjacency(vert,faces,EV,FE,EF);
-    }
-
-    static Eigen::Vector3d VectorFromCoord(const CoordType &v)
-    {
-        // create eigen vector
-        Eigen::Vector3d c;
-
-        // copy coordinates
-        for (int i = 0; i < 3; i++)
-            c(i) = v[i];
-
-        return c;
-    }
+    for (int i = 0; i < mesh.FN(); i++)
+      for (int j = 0; j < 3; j++)
+      {
+        FaceType *AdjF=mesh.face[i].FFp(j);
+        if (AdjF==&mesh.face[i])
+        {
+          FFp(i,j)=-1;
+          FFi(i,j)=-1;
+        }
+        else
+        {
+          FFp(i,j)=tri::Index(mesh,AdjF);
+          FFi(i,j)=mesh.face[i].FFi(j);
+        }
+      }
+  }
 
+  // get edge to face and edge to vertex adjacency
+  static void GetTriEdgeAdjacency(const TriMeshType &mesh,
+                                  Eigen::MatrixXi& EV,
+                                  Eigen::MatrixXi& FE,
+                                  Eigen::MatrixXi& EF)
+  {
+    Eigen::MatrixXi faces;
+    Eigen::MatrixXd vert;
+    GetTriMeshData(mesh,faces,vert);
+    GetTriEdgeAdjacency(vert,faces,EV,FE,EF);
+  }
 };
-}
 
+} // end namespace tri
+} // end namespace vcg
 #endif // MESH_TO_MATRIX_CONVERTER