moved comiso functions in copyleft

Former-commit-id: b27a97ccbb3a1cc467179c8aff8340d2960895e9

include/igl/comiso/frame_field.cpp → include/igl/copyleft/comiso/frame_field.cpp

@@ -10,11 +10,13 @@
 #include <igl/triangle_triangle_adjacency.h>
 #include <igl/edge_topology.h>
 #include <igl/per_face_normals.h>
-#include <igl/comiso/nrosy.h>
+#include <igl/copyleft/comiso/nrosy.h>
 #include <iostream>
 
 namespace igl
 {
+namespace copyleft
+{
 namespace comiso
 {
 
@@ -229,7 +231,7 @@ void FrameInterpolator::interpolateCross()
   b.conservativeResize(num,Eigen::NoChange);
   bc.conservativeResize(num,Eigen::NoChange);
 
-  igl::comiso::nrosy(V, F, b, bc, 4, R, S);
+  igl::copyleft::comiso::nrosy(V, F, b, bc, 4, R, S);
   //olga:end
   assert(R.rows() == F.rows());
 
@@ -647,10 +649,11 @@ Eigen::MatrixXd FrameInterpolator::getFieldPerFace()
   P = svd.matrixV() * svd.singularValues().asDiagonal() * svd.matrixV().transpose();
 }
 
+}
 }
 }
 
-IGL_INLINE void igl::comiso::frame_field(
+IGL_INLINE void igl::copyleft::comiso::frame_field(
                                  const Eigen::MatrixXd& V,
                                  const Eigen::MatrixXi& F,
                                  const Eigen::VectorXi& b,

include/igl/comiso/frame_field.h → include/igl/copyleft/comiso/frame_field.h

@@ -14,6 +14,8 @@
 
 namespace igl
 {
+namespace copyleft
+{
 namespace comiso
 {
 // Generate a piecewise-constant frame-field field from a sparse set of constraints on faces
@@ -45,6 +47,7 @@ IGL_INLINE void frame_field(
   );
 }
 }
+}
 
 #ifndef IGL_STATIC_LIBRARY
 #  include "frame_field.cpp"

include/igl/comiso/miq.cpp → include/igl/copyleft/comiso/miq.cpp

@@ -6,7 +6,7 @@
 // v. 2.0. If a copy of the MPL was not distributed with this file, You can
 // obtain one at http://mozilla.org/MPL/2.0/.
 
-#include <igl/comiso/miq.h>
+#include <igl/copyleft/comiso/miq.h>
 #include <igl/local_basis.h>
 #include <igl/triangle_triangle_adjacency.h>
 #include <igl/cut_mesh.h>
@@ -45,6 +45,7 @@
 
 
 namespace igl {
+namespace copyleft {
 namespace comiso {
   struct SeamInfo
   {
@@ -350,9 +351,10 @@ namespace comiso {
 
   };
 };
+};
 }
 
-IGL_INLINE igl::comiso::SeamInfo::SeamInfo(int _v0,
+IGL_INLINE igl::copyleft::comiso::SeamInfo::SeamInfo(int _v0,
                                    int _v0p,
                                    int _MMatch,
                                    int _integerVar)
@@ -363,7 +365,7 @@ IGL_INLINE igl::comiso::SeamInfo::SeamInfo(int _v0,
   MMatch=_MMatch;
 }
 
-IGL_INLINE igl::comiso::SeamInfo::SeamInfo(const SeamInfo &S1)
+IGL_INLINE igl::copyleft::comiso::SeamInfo::SeamInfo(const SeamInfo &S1)
 {
   v0=S1.v0;
   v0p=S1.v0p;
@@ -373,7 +375,7 @@ IGL_INLINE igl::comiso::SeamInfo::SeamInfo(const SeamInfo &S1)
 
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE igl::comiso::VertexIndexing<DerivedV, DerivedF>::VertexIndexing(const Eigen::PlainObjectBase<DerivedV> &_V,
+IGL_INLINE igl::copyleft::comiso::VertexIndexing<DerivedV, DerivedF>::VertexIndexing(const Eigen::PlainObjectBase<DerivedV> &_V,
                                                                    const Eigen::PlainObjectBase<DerivedF> &_F,
                                                                    const Eigen::PlainObjectBase<DerivedV> &_Vcut,
                                                                    const Eigen::PlainObjectBase<DerivedF> &_Fcut,
@@ -402,7 +404,7 @@ Handle_Seams(_Handle_Seams)
 }
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::VertexIndexing<DerivedV, DerivedF>::GetSeamInfo(const int f0,
+IGL_INLINE void igl::copyleft::comiso::VertexIndexing<DerivedV, DerivedF>::GetSeamInfo(const int f0,
                                                                      const int f1,
                                                                      const int indexE,
                                                                      int &v0,int &v1,
@@ -424,7 +426,7 @@ IGL_INLINE void igl::comiso::VertexIndexing<DerivedV, DerivedF>::GetSeamInfo(con
 }
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE std::vector<std::vector<typename igl::comiso::VertexIndexing<DerivedV, DerivedF>::VertexInfo> > igl::comiso::VertexIndexing<DerivedV, DerivedF>::GetVerticesPerSeam()
+IGL_INLINE std::vector<std::vector<typename igl::copyleft::comiso::VertexIndexing<DerivedV, DerivedF>::VertexInfo> > igl::copyleft::comiso::VertexIndexing<DerivedV, DerivedF>::GetVerticesPerSeam()
 {
   // Return value
   std::vector<std::vector<VertexInfo> >verticesPerSeam;
@@ -524,7 +526,7 @@ IGL_INLINE std::vector<std::vector<typename igl::comiso::VertexIndexing<DerivedV
 }
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::VertexIndexing<DerivedV, DerivedF>::InitSeamInfo()
+IGL_INLINE void igl::copyleft::comiso::VertexIndexing<DerivedV, DerivedF>::InitSeamInfo()
 {
   auto verticesPerSeam = GetVerticesPerSeam();
   Handle_SystemInfo.EdgeSeamInfo.clear();
@@ -590,7 +592,7 @@ IGL_INLINE void igl::comiso::VertexIndexing<DerivedV, DerivedF>::InitSeamInfo()
 
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::SolvePoisson(Eigen::VectorXd Stiffness,
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::SolvePoisson(Eigen::VectorXd Stiffness,
                                                                      double vector_field_scale,
                                                                      double grid_res,
                                                                      bool direct_round,
@@ -662,7 +664,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::SolvePoisson(Eig
 }
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE igl::comiso::PoissonSolver<DerivedV, DerivedF>
+IGL_INLINE igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>
 ::PoissonSolver(const Eigen::PlainObjectBase<DerivedV> &_V,
                 const Eigen::PlainObjectBase<DerivedF> &_F,
                 const Eigen::PlainObjectBase<DerivedV> &_Vcut,
@@ -695,7 +697,7 @@ Handle_SystemInfo(_Handle_SystemInfo)
 ///return the complex encoding the rotation
 ///for a given missmatch interval
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE std::complex<double> igl::comiso::PoissonSolver<DerivedV, DerivedF>::GetRotationComplex(int interval)
+IGL_INLINE std::complex<double> igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::GetRotationComplex(int interval)
 {
   assert((interval>=0)&&(interval<4));
 
@@ -713,7 +715,7 @@ IGL_INLINE std::complex<double> igl::comiso::PoissonSolver<DerivedV, DerivedF>::
 ///START FIXING VERTICES
 ///set a given vertex as fixed
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::AddFixedVertex(int v)
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::AddFixedVertex(int v)
 {
   n_fixed_vars++;
   Hard_constraints.push_back(v);
@@ -722,7 +724,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::AddFixedVertex(i
 ///find vertex to fix in case we're using
 ///a vector field NB: multiple components not handled
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::FindFixedVertField()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::FindFixedVertField()
 {
   Hard_constraints.clear();
 
@@ -747,21 +749,21 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::FindFixedVertFie
 ///find hard constraint depending if using or not
 ///a vector field
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::FindFixedVert()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::FindFixedVert()
 {
   Hard_constraints.clear();
   FindFixedVertField();
 }
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE int igl::comiso::PoissonSolver<DerivedV, DerivedF>::GetFirstVertexIndex(int v)
+IGL_INLINE int igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::GetFirstVertexIndex(int v)
 {
   return Fcut(VF[v][0],VFi[v][0]);
 }
 
 ///fix the vertices which are flagged as fixed
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::FixBlockedVertex()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::FixBlockedVertex()
 {
   int offset_row = num_cut_constraint*2;
 
@@ -798,7 +800,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::FixBlockedVertex
 ///HANDLING SINGULARITY
 //set the singularity round to integer location
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::AddSingularityRound()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::AddSingularityRound()
 {
   for (unsigned int v=0;v<V.rows();v++)
   {
@@ -812,7 +814,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::AddSingularityRo
 }
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::AddToRoundVertices(std::vector<int> ids)
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::AddToRoundVertices(std::vector<int> ids)
 {
   for (size_t i = 0; i < ids.size(); ++i)
   {
@@ -826,7 +828,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::AddToRoundVertic
 
 ///START GENERIC SYSTEM FUNCTIONS
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::BuildLaplacianMatrix(double vfscale)
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::BuildLaplacianMatrix(double vfscale)
 {
   Eigen::VectorXi idx  = Eigen::VectorXi::LinSpaced(Vcut.rows(), 0, 2*Vcut.rows()-2);
   Eigen::VectorXi idx2 = Eigen::VectorXi::LinSpaced(Vcut.rows(), 1, 2*Vcut.rows()-1);
@@ -863,7 +865,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::BuildLaplacianMa
 
 ///find different sized of the system
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::FindSizes()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::FindSizes()
 {
   ///find the vertex that need to be fixed
   FindFixedVert();
@@ -902,7 +904,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::FindSizes()
 }
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::AllocateSystem()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::AllocateSystem()
 {
   Lhs.resize(n_vert_vars * 2, n_vert_vars * 2);
   Constraints.resize(num_constraint_equations, num_total_vars);
@@ -917,7 +919,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::AllocateSystem()
 
 ///intitialize the whole matrix
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::InitMatrix()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::InitMatrix()
 {
   FindSizes();
   AllocateSystem();
@@ -926,7 +928,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::InitMatrix()
 ///map back coordinates after that
 ///the system has been solved
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::MapCoords()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::MapCoords()
 {
   ///map coords to faces
   for (unsigned int f=0;f<Fcut.rows();f++)
@@ -956,7 +958,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::MapCoords()
 
 ///set the constraints for the inter-range cuts
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::BuildSeamConstraintsExplicitTranslation()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::BuildSeamConstraintsExplicitTranslation()
 {
   ///current constraint row
   int constr_row = 0;
@@ -1006,7 +1008,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::BuildSeamConstra
 
 ///set the constraints for the inter-range cuts
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::BuildUserDefinedConstraints()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::BuildUserDefinedConstraints()
 {
   /// the user defined constraints are at the end
   int offset_row = num_cut_constraint*2 + n_fixed_vars*2;
@@ -1030,7 +1032,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::BuildUserDefined
 
 ///call of the mixed integer solver
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::MixedIntegerSolve(double cone_grid_res,
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::MixedIntegerSolve(double cone_grid_res,
                                                                           bool direct_round,
                                                                           int localIter)
 {
@@ -1120,14 +1122,14 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::MixedIntegerSolv
 }
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::clearUserConstraint()
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::clearUserConstraint()
 {
   num_userdefined_constraint = 0;
   userdefined_constraints.clear();
 }
 
 template <typename DerivedV, typename DerivedF>
-IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::addSharpEdgeConstraint(int fid, int vid)
+IGL_INLINE void igl::copyleft::comiso::PoissonSolver<DerivedV, DerivedF>::addSharpEdgeConstraint(int fid, int vid)
 {
   // prepare constraint
   std::vector<int> c(Handle_SystemInfo.num_vert_variables*2 + 1);
@@ -1167,7 +1169,7 @@ IGL_INLINE void igl::comiso::PoissonSolver<DerivedV, DerivedF>::addSharpEdgeCons
 
 
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::MIQ_class(const Eigen::PlainObjectBase<DerivedV> &V_,
+IGL_INLINE igl::copyleft::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::MIQ_class(const Eigen::PlainObjectBase<DerivedV> &V_,
                                                                    const Eigen::PlainObjectBase<DerivedF> &F_,
                                                                    const Eigen::PlainObjectBase<DerivedV> &PD1_combed,
                                                                    const Eigen::PlainObjectBase<DerivedV> &PD2_combed,
@@ -1237,7 +1239,7 @@ F(F_)
 }
 
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE void igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::extractUV(Eigen::PlainObjectBase<DerivedU> &UV_out,
+IGL_INLINE void igl::copyleft::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::extractUV(Eigen::PlainObjectBase<DerivedU> &UV_out,
                                                                         Eigen::PlainObjectBase<DerivedF> &FUV_out)
 {
   UV_out = this->UV_out;
@@ -1245,7 +1247,7 @@ IGL_INLINE void igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::extractUV(
 }
 
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE int igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::NumFlips(const Eigen::MatrixXd& WUV)
+IGL_INLINE int igl::copyleft::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::NumFlips(const Eigen::MatrixXd& WUV)
 {
   int numFl=0;
   for (unsigned int i=0;i<F.rows();i++)
@@ -1257,7 +1259,7 @@ IGL_INLINE int igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::NumFlips(co
 }
 
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE double igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::Distortion(int f, double h, const Eigen::MatrixXd& WUV)
+IGL_INLINE double igl::copyleft::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::Distortion(int f, double h, const Eigen::MatrixXd& WUV)
 {
   assert(h > 0);
 
@@ -1345,7 +1347,7 @@ IGL_INLINE double igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::Distorti
 //  @return     distortion laplacian for f
 ///////////////////////////////////////////////////////////////////////////
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE double igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::LaplaceDistortion(const int f, double h, const Eigen::MatrixXd& WUV)
+IGL_INLINE double igl::copyleft::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::LaplaceDistortion(const int f, double h, const Eigen::MatrixXd& WUV)
 {
   double mydist = Distortion(f, h, WUV);
   double lapl=0;
@@ -1358,7 +1360,7 @@ IGL_INLINE double igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::LaplaceD
 }
 
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE bool igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::updateStiffeningJacobianDistorsion(double grad_size, const Eigen::MatrixXd& WUV)
+IGL_INLINE bool igl::copyleft::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::updateStiffeningJacobianDistorsion(double grad_size, const Eigen::MatrixXd& WUV)
 {
   bool flipped = NumFlips(WUV)>0;
 
@@ -1394,7 +1396,7 @@ IGL_INLINE bool igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::updateStif
 }
 
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE bool igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::IsFlipped(const Eigen::Vector2d &uv0,
+IGL_INLINE bool igl::copyleft::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::IsFlipped(const Eigen::Vector2d &uv0,
                                                                         const Eigen::Vector2d &uv1,
                                                                         const Eigen::Vector2d &uv2)
 {
@@ -1406,7 +1408,7 @@ IGL_INLINE bool igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::IsFlipped(
 }
 
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE bool igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::IsFlipped(
+IGL_INLINE bool igl::copyleft::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::IsFlipped(
   const int i, const Eigen::MatrixXd& WUV)
 {
   Eigen::Vector2d uv0,uv1,uv2;
@@ -1421,7 +1423,7 @@ IGL_INLINE bool igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU>::IsFlipped(
 
 
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE void igl::comiso::miq(
+IGL_INLINE void igl::copyleft::comiso::miq(
   const Eigen::PlainObjectBase<DerivedV> &V,
   const Eigen::PlainObjectBase<DerivedF> &F,
   const Eigen::PlainObjectBase<DerivedV> &PD1_combed,
@@ -1443,7 +1445,7 @@ IGL_INLINE void igl::comiso::miq(
 {
   GradientSize = GradientSize/(V.colwise().maxCoeff()-V.colwise().minCoeff()).norm();
 
-  igl::comiso::MIQ_class<DerivedV, DerivedF, DerivedU> miq(V,
+  igl::copyleft::comiso::MIQ_class<DerivedV, DerivedF, DerivedU> miq(V,
     F,
     PD1_combed,
     PD2_combed,
@@ -1466,7 +1468,7 @@ IGL_INLINE void igl::comiso::miq(
 }
 
 template <typename DerivedV, typename DerivedF, typename DerivedU>
-IGL_INLINE void igl::comiso::miq(
+IGL_INLINE void igl::copyleft::comiso::miq(
     const Eigen::PlainObjectBase<DerivedV> &V,
     const Eigen::PlainObjectBase<DerivedF> &F,
     const Eigen::PlainObjectBase<DerivedV> &PD1,
@@ -1502,7 +1504,7 @@ IGL_INLINE void igl::comiso::miq(
   Eigen::PlainObjectBase<DerivedV> PD1_combed, PD2_combed;
   igl::comb_frame_field(V, F, PD1, PD2, BIS1_combed, BIS2_combed, PD1_combed, PD2_combed);
 
-  igl::comiso::miq(V,
+  igl::copyleft::comiso::miq(V,
            F,
            PD1_combed,
            PD2_combed,
@@ -1525,7 +1527,7 @@ IGL_INLINE void igl::comiso::miq(
 
 #ifdef IGL_STATIC_LIBRARY
 // Explicit template specialization
-template void igl::comiso::miq<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&, double, double, bool, int, int, bool, bool, std::vector<int, std::allocator<int> >, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >);
-template void igl::comiso::miq<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::Matrix<int, -1, 3, 0, -1, 3> const&, Eigen::Matrix<int, -1, 1, 0, -1, 1> const&, Eigen::Matrix<int, -1, 3, 0, -1, 3> const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, double, double, bool, int, int, bool, bool, std::vector<int, std::allocator<int> >, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >);
-template void igl::comiso::miq<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, double, double, bool, int, int, bool, bool, std::vector<int, std::allocator<int> >, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >);
+template void igl::copyleft::comiso::miq<Eigen::Matrix<double, -1, 3, 0, -1, 3>, Eigen::Matrix<int, -1, 3, 0, -1, 3>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 3, 0, -1, 3> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, 3, 0, -1, 3> >&, double, double, bool, int, int, bool, bool, std::vector<int, std::allocator<int> >, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >);
+template void igl::copyleft::comiso::miq<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::Matrix<int, -1, 3, 0, -1, 3> const&, Eigen::Matrix<int, -1, 1, 0, -1, 1> const&, Eigen::Matrix<int, -1, 3, 0, -1, 3> const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, double, double, bool, int, int, bool, bool, std::vector<int, std::allocator<int> >, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >);
+template void igl::copyleft::comiso::miq<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1> >(Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> > const&, Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1> >&, Eigen::PlainObjectBase<Eigen::Matrix<int, -1, -1, 0, -1, -1> >&, double, double, bool, int, int, bool, bool, std::vector<int, std::allocator<int> >, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >);
 #endif

include/igl/comiso/miq.h → include/igl/copyleft/comiso/miq.h

@@ -13,6 +13,8 @@
 
 namespace igl
 {
+  namespace copyleft
+  {
   namespace comiso
   {
   // Global seamless parametrization aligned with a given per-face jacobian (PD1,PD2).
@@ -89,6 +91,7 @@ namespace igl
       std::vector<std::vector<int> > hardFeatures = std::vector<std::vector<int> >());
   };
 };
+};
 #ifndef IGL_STATIC_LIBRARY
 #include "miq.cpp"
 #endif

include/igl/comiso/nrosy.cpp → include/igl/copyleft/comiso/nrosy.cpp

@@ -8,7 +8,7 @@
 
 #include "nrosy.h"
 
-#include <igl/comiso/nrosy.h>
+#include <igl/copyleft/comiso/nrosy.h>
 #include <igl/triangle_triangle_adjacency.h>
 #include <igl/edge_topology.h>
 #include <igl/per_face_normals.h>
@@ -27,6 +27,9 @@
 
 namespace igl
 {
+namespace copyleft
+{
+
 namespace comiso
 {
 class NRosyField
@@ -150,9 +153,10 @@ private:
 };
 
 } // NAMESPACE COMISO
+} // NAMESPACE COPYLEFT
 } // NAMESPACE IGL
 
-igl::comiso::NRosyField::NRosyField(const Eigen::MatrixXd& _V, const Eigen::MatrixXi& _F)
+igl::copyleft::comiso::NRosyField::NRosyField(const Eigen::MatrixXd& _V, const Eigen::MatrixXi& _F)
 {
   using namespace std;
   using namespace Eigen;
@@ -207,14 +211,14 @@ igl::comiso::NRosyField::NRosyField(const Eigen::MatrixXd& _V, const Eigen::Matr
   softAlpha = 0.5;
 }
 
-void igl::comiso::NRosyField::setSoftAlpha(double alpha)
+void igl::copyleft::comiso::NRosyField::setSoftAlpha(double alpha)
 {
   assert(alpha >= 0 && alpha < 1);
   softAlpha = alpha;
 }
 
 
-void igl::comiso::NRosyField::prepareSystemMatrix(const int N)
+void igl::copyleft::comiso::NRosyField::prepareSystemMatrix(const int N)
 {
   using namespace std;
   using namespace Eigen;
@@ -395,7 +399,7 @@ void igl::comiso::NRosyField::prepareSystemMatrix(const int N)
 //  s2.close();
 }
 
-void igl::comiso::NRosyField::solveNoRoundings()
+void igl::copyleft::comiso::NRosyField::solveNoRoundings()
 {
   using namespace std;
   using namespace Eigen;
@@ -417,7 +421,7 @@ void igl::comiso::NRosyField::solveNoRoundings()
       p[i] = roundl(x[tag_p[i]]);
 }
 
-void igl::comiso::NRosyField::solveRoundings()
+void igl::copyleft::comiso::NRosyField::solveRoundings()
 {
   using namespace std;
   using namespace Eigen;
@@ -471,13 +475,13 @@ void igl::comiso::NRosyField::solveRoundings()
 }
 
 
-void igl::comiso::NRosyField::roundAndFix()
+void igl::copyleft::comiso::NRosyField::roundAndFix()
 {
   for(unsigned i=0; i<p.rows(); ++i)
     pFixed[i] = true;
 }
 
-void igl::comiso::NRosyField::roundAndFixToZero()
+void igl::copyleft::comiso::NRosyField::roundAndFixToZero()
 {
   for(unsigned i=0; i<p.rows(); ++i)
   {
@@ -486,7 +490,7 @@ void igl::comiso::NRosyField::roundAndFixToZero()
   }
 }
 
-void igl::comiso::NRosyField::solve(const int N)
+void igl::copyleft::comiso::NRosyField::solve(const int N)
 {
   // Reduce the search space by fixing matchings
   reduceSpace();
@@ -514,19 +518,19 @@ void igl::comiso::NRosyField::solve(const int N)
   findCones(N);
 }
 
-void igl::comiso::NRosyField::setConstraintHard(const int fid, const Eigen::Vector3d& v)
+void igl::copyleft::comiso::NRosyField::setConstraintHard(const int fid, const Eigen::Vector3d& v)
 {
   isHard[fid] = true;
   hard(fid) = convert3DtoLocal(fid, v);
 }
 
-void igl::comiso::NRosyField::setConstraintSoft(const int fid, const double w, const Eigen::Vector3d& v)
+void igl::copyleft::comiso::NRosyField::setConstraintSoft(const int fid, const double w, const Eigen::Vector3d& v)
 {
   wSoft(fid) = w;
   soft(fid) = convert3DtoLocal(fid, v);
 }
 
-void igl::comiso::NRosyField::resetConstraints()
+void igl::copyleft::comiso::NRosyField::resetConstraints()
 {
   using namespace std;
   using namespace Eigen;
@@ -540,7 +544,7 @@ void igl::comiso::NRosyField::resetConstraints()
   soft   = VectorXd::Zero(F.rows());
 }
 
-Eigen::MatrixXd igl::comiso::NRosyField::getFieldPerFace()
+Eigen::MatrixXd igl::copyleft::comiso::NRosyField::getFieldPerFace()
 {
   using namespace std;
   using namespace Eigen;
@@ -551,7 +555,7 @@ Eigen::MatrixXd igl::comiso::NRosyField::getFieldPerFace()
   return result;
 }
 
-Eigen::MatrixXd igl::comiso::NRosyField::getFFieldPerFace()
+Eigen::MatrixXd igl::copyleft::comiso::NRosyField::getFFieldPerFace()
 {
   using namespace std;
   using namespace Eigen;
@@ -572,7 +576,7 @@ Eigen::MatrixXd igl::comiso::NRosyField::getFFieldPerFace()
 }
 
 
-void igl::comiso::NRosyField::computek()
+void igl::copyleft::comiso::NRosyField::computek()
 {
   using namespace std;
   using namespace Eigen;
@@ -671,7 +675,7 @@ void igl::comiso::NRosyField::computek()
 
 }
 
-void igl::comiso::NRosyField::reduceSpace()
+void igl::copyleft::comiso::NRosyField::reduceSpace()
 {
   using namespace std;
   using namespace Eigen;
@@ -768,7 +772,7 @@ void igl::comiso::NRosyField::reduceSpace()
 
 }
 
-double igl::comiso::NRosyField::convert3DtoLocal(unsigned fid, const Eigen::Vector3d& v)
+double igl::copyleft::comiso::NRosyField::convert3DtoLocal(unsigned fid, const Eigen::Vector3d& v)
 {
   using namespace std;
   using namespace Eigen;
@@ -780,7 +784,7 @@ double igl::comiso::NRosyField::convert3DtoLocal(unsigned fid, const Eigen::Vect
   return atan2(vp(1),vp(0));
 }
 
-Eigen::Vector3d igl::comiso::NRosyField::convertLocalto3D(unsigned fid, double a)
+Eigen::Vector3d igl::copyleft::comiso::NRosyField::convertLocalto3D(unsigned fid, double a)
 {
   using namespace std;
   using namespace Eigen;
@@ -789,7 +793,7 @@ Eigen::Vector3d igl::comiso::NRosyField::convertLocalto3D(unsigned fid, double a
   return vp.transpose() * TPs[fid];
 }
 
-Eigen::VectorXd igl::comiso::NRosyField::angleDefect()
+Eigen::VectorXd igl::copyleft::comiso::NRosyField::angleDefect()
 {
   Eigen::VectorXd A = Eigen::VectorXd::Constant(V.rows(),-2*M_PI);
 
@@ -808,7 +812,7 @@ Eigen::VectorXd igl::comiso::NRosyField::angleDefect()
   return A;
 }
 
-void igl::comiso::NRosyField::findCones(int N)
+void igl::copyleft::comiso::NRosyField::findCones(int N)
 {
   // Compute I0, see http://www.graphics.rwth-aachen.de/media/papers/bommes_zimmer_2009_siggraph_011.pdf for details
 
@@ -865,12 +869,12 @@ void igl::comiso::NRosyField::findCones(int N)
   singularityIndex = I;
 }
 
-Eigen::VectorXd igl::comiso::NRosyField::getSingularityIndexPerVertex()
+Eigen::VectorXd igl::copyleft::comiso::NRosyField::getSingularityIndexPerVertex()
 {
   return singularityIndex;
 }
 
-IGL_INLINE void igl::comiso::nrosy(
+IGL_INLINE void igl::copyleft::comiso::nrosy(
   const Eigen::MatrixXd& V,
   const Eigen::MatrixXi& F,
   const Eigen::VectorXi& b,
@@ -885,7 +889,7 @@ IGL_INLINE void igl::comiso::nrosy(
   )
 {
   // Init solver
-  igl::comiso::NRosyField solver(V,F);
+  igl::copyleft::comiso::NRosyField solver(V,F);
 
   // Add hard constraints
   for (unsigned i=0; i<b.size();++i)
@@ -909,7 +913,7 @@ IGL_INLINE void igl::comiso::nrosy(
 }
 
 
-IGL_INLINE void igl::comiso::nrosy(
+IGL_INLINE void igl::copyleft::comiso::nrosy(
                            const Eigen::MatrixXd& V,
                            const Eigen::MatrixXi& F,
                            const Eigen::VectorXi& b,
@@ -920,7 +924,7 @@ IGL_INLINE void igl::comiso::nrosy(
                            )
 {
   // Init solver
-  igl::comiso::NRosyField solver(V,F);
+  igl::copyleft::comiso::NRosyField solver(V,F);
 
   // Add hard constraints
   for (unsigned i=0; i<b.size();++i)

include/igl/comiso/nrosy.h → include/igl/copyleft/comiso/nrosy.h

@@ -16,6 +16,8 @@
 
 namespace igl
 {
+  namespace copyleft
+  {
   namespace comiso
   {
     // Generate a N-RoSy field from a sparse set of constraints
@@ -61,6 +63,7 @@ namespace igl
 
   }
 }
+}
 
 #ifndef IGL_STATIC_LIBRARY
 #  include "nrosy.cpp"

python/py_igl/comiso/py_miq.cpp

@@ -19,7 +19,7 @@ m.def("miq", []
   std::vector<int> round_vertices;
   std::vector<std::vector<int> > hard_features;
 
-  igl::comiso::miq(V,F,PD1,PD2,UV,FUV,scale,stiffness,direct_round,iter,local_iter,DoRound, SingularityRound, round_vertices, hard_features);
+  igl::copyleft::comiso::miq(V,F,PD1,PD2,UV,FUV,scale,stiffness,direct_round,iter,local_iter,DoRound, SingularityRound, round_vertices, hard_features);
 }, __doc_igl_comiso_miq,
 py::arg("V"), py::arg("F"), py::arg("PD1"), py::arg("PD2"), py::arg("UV"), py::arg("FUV"), py::arg("scale") = 30.0, py::arg("stiffness") = 5.0, py::arg("direct_round") = false, py::arg("iter") = 5, py::arg("local_iter") = 5, py::arg("DoRound") = true, py::arg("SingularityRound") = true
 // , py::arg("round_vertices"), py::arg("hard_features")
@@ -50,7 +50,7 @@ m.def("miq", []
   std::vector<int> roundVertices;
   std::vector<std::vector<int> > hardFeatures;
 
-  igl::comiso::miq(V,F,PD1_combed,PD2_combed,MMatch,Singular,Seams,UV,FUV,GradientSize,Stiffness,DirectRound,iter,localIter,DoRound, SingularityRound, roundVertices, hardFeatures);
+  igl::copyleft::comiso::miq(V,F,PD1_combed,PD2_combed,MMatch,Singular,Seams,UV,FUV,GradientSize,Stiffness,DirectRound,iter,localIter,DoRound, SingularityRound, roundVertices, hardFeatures);
 }, __doc_igl_comiso_miq,
 py::arg("V"), py::arg("F"), py::arg("PD1_combed"), py::arg("PD2_combed"),
 py::arg("MMatch"), py::arg("Singular"), py::arg("Seams"),

python/py_igl/comiso/py_nrosy.cpp

@@ -30,7 +30,7 @@ m.def("nrosy", []
     w_softt = w_soft;
 
   Eigen::VectorXd St;
-  igl::comiso::nrosy(V,F,bt,bc,b_softt,w_softt,bc_soft,N,soft,R,St);
+  igl::copyleft::comiso::nrosy(V,F,bt,bc,b_softt,w_softt,bc_soft,N,soft,R,St);
   S = St;
 
 }, __doc_igl_comiso_nrosy,
@@ -54,7 +54,7 @@ m.def("nrosy", []
     bt = b;
 
   Eigen::VectorXd St;
-  igl::comiso::nrosy(V,F,bt,bc,N,R,St);
+  igl::copyleft::comiso::nrosy(V,F,bt,bc,N,R,St);
   S = St;
 }, __doc_igl_comiso_nrosy,
 py::arg("V"), py::arg("F"), py::arg("b"), py::arg("bc"), py::arg("N"), py::arg("R"), py::arg("S"));

python/py_igl_comiso.cpp

@@ -5,15 +5,15 @@
 
 #include "python.h"
 
-#include <igl/comiso/nrosy.h>
-#include <igl/comiso/miq.h>
+#include <igl/copyleft/comiso/nrosy.h>
+#include <igl/copyleft/comiso/miq.h>
 
 void python_export_igl_comiso(py::module &me) {
 
   py::module m = me.def_submodule(
     "comiso", "Wrappers for libigl functions that use comiso");
 
-  #include "py_igl/comiso/py_nrosy.cpp"
-  #include "py_igl/comiso/py_miq.cpp"
+  #include "py_igl/copyleft/comiso/py_nrosy.cpp"
+  #include "py_igl/copyleft/comiso/py_miq.cpp"
 
 }

tutorial/504_NRosyDesign/main.cpp

@@ -2,7 +2,7 @@
 #include <igl/barycenter.h>
 #include <igl/local_basis.h>
 #include <igl/readOFF.h>
-#include <igl/comiso/nrosy.h>
+#include <igl/copyleft/comiso/nrosy.h>
 #include <igl/viewer/Viewer.h>
 
 #include "tutorial_shared_path.h"
@@ -23,10 +23,10 @@ int N = 4;
 // Converts a representative vector per face in the full set of vectors that describe
 // an N-RoSy field
 void representative_to_nrosy(
-  const Eigen::MatrixXd& V, 
-  const Eigen::MatrixXi& F, 
-  const Eigen::MatrixXd& R, 
-  const int N, 
+  const Eigen::MatrixXd& V,
+  const Eigen::MatrixXi& F,
+  const Eigen::MatrixXd& R,
+  const int N,
   Eigen::MatrixXd& Y)
 {
   using namespace Eigen;
@@ -55,12 +55,12 @@ void representative_to_nrosy(
 // Plots the mesh with an N-RoSy field and its singularities on top
 // The constrained faces (b) are colored in red.
 void plot_mesh_nrosy(
-  igl::viewer::Viewer& viewer, 
-  Eigen::MatrixXd& V, 
-  Eigen::MatrixXi& F, 
-  int N, 
-  Eigen::MatrixXd& PD1, 
-  Eigen::VectorXd& S, 
+  igl::viewer::Viewer& viewer,
+  Eigen::MatrixXd& V,
+  Eigen::MatrixXi& F,
+  int N,
+  Eigen::MatrixXd& PD1,
+  Eigen::VectorXd& S,
   Eigen::VectorXi& b)
 {
   using namespace Eigen;
@@ -111,7 +111,7 @@ bool key_down(igl::viewer::Viewer& viewer, unsigned char key, int modifier)
   MatrixXd R;
   VectorXd S;
 
-  igl::comiso::nrosy(V,F,b,bc,VectorXi(),VectorXd(),MatrixXd(),N,0.5,R,S);
+  igl::copyleft::comiso::nrosy(V,F,b,bc,VectorXi(),VectorXd(),MatrixXd(),N,0.5,R,S);
   plot_mesh_nrosy(viewer,V,F,N,R,S,b);
 
   return false;

tutorial/505_MIQ/main.cpp

@@ -2,7 +2,7 @@
 #include <igl/barycenter.h>
 #include <igl/comb_cross_field.h>
 #include <igl/comb_frame_field.h>
-#include <igl/comiso/miq.h>
+#include <igl/copyleft/comiso/miq.h>
 #include <igl/compute_frame_field_bisectors.h>
 #include <igl/cross_field_missmatch.h>
 #include <igl/cut_mesh_from_singularities.h>
@@ -10,7 +10,7 @@
 #include <igl/local_basis.h>
 #include <igl/readOFF.h>
 #include <igl/rotate_vectors.h>
-#include <igl/comiso/nrosy.h>
+#include <igl/copyleft/comiso/nrosy.h>
 #include <igl/viewer/Viewer.h>
 #include <sstream>
 
@@ -249,7 +249,7 @@ int main(int argc, char *argv[])
 
   // Create a smooth 4-RoSy field
   VectorXd S;
-  igl::comiso::nrosy(V,F,b,bc,VectorXi(),VectorXd(),MatrixXd(),4,0.5,X1,S);
+  igl::copyleft::comiso::nrosy(V,F,b,bc,VectorXi(),VectorXd(),MatrixXd(),4,0.5,X1,S);
 
   // Find the the orthogonal vector
   MatrixXd B1,B2,B3;
@@ -280,7 +280,7 @@ int main(int argc, char *argv[])
   igl::comb_frame_field(V, F, X1, X2, BIS1_combed, BIS2_combed, X1_combed, X2_combed);
 
   // Global parametrization
-  igl::comiso::miq(V,
+  igl::copyleft::comiso::miq(V,
            F,
            X1_combed,
            X2_combed,
@@ -297,7 +297,7 @@ int main(int argc, char *argv[])
            true);
 
 // Global parametrization (with seams, only for demonstration)
-igl::comiso::miq(V,
+igl::copyleft::comiso::miq(V,
          F,
          X1_combed,
          X2_combed,

tutorial/506_FrameField/main.cpp

@@ -7,9 +7,9 @@
 #include <igl/readDMAT.h>
 #include <igl/readOBJ.h>
 #include <igl/rotate_vectors.h>
-#include <igl/comiso/nrosy.h>
-#include <igl/comiso/miq.h>
-#include <igl/comiso/frame_field.h>
+#include <igl/copyleft/comiso/nrosy.h>
+#include <igl/copyleft/comiso/miq.h>
+#include <igl/copyleft/comiso/frame_field.h>
 #include <igl/viewer/Viewer.h>
 
 #include "tutorial_shared_path.h"
@@ -196,7 +196,7 @@ int main(int argc, char *argv[])
   bc2 = temp.block(0,4,temp.rows(),3);
 
   // Interpolate the frame field
-  igl::comiso::frame_field(V, F, b, bc1, bc2, FF1, FF2);
+  igl::copyleft::comiso::frame_field(V, F, b, bc1, bc2, FF1, FF2);
 
   // Deform the mesh to transform the frame field in a cross field
   igl::frame_field_deformer(
@@ -214,7 +214,7 @@ int main(int argc, char *argv[])
     bc_x.row(i) = X1_deformed.row(b(i));
 
   VectorXd S;
-  igl::comiso::nrosy(
+  igl::copyleft::comiso::nrosy(
              V,
              F,
              b,
@@ -234,7 +234,7 @@ int main(int argc, char *argv[])
     igl::rotate_vectors(X1_deformed, VectorXd::Constant(1,M_PI/2), B1, B2);
 
   // Global seamless parametrization
-  igl::comiso::miq(V_deformed,
+  igl::copyleft::comiso::miq(V_deformed,
            F,
            X1_deformed,
            X2_deformed,