Added disabling option for lim tutorial

Former-commit-id: de9eaee83928989cd4c2a15139674a91e5daa8df

include/igl/lim/compute_lim.cpp

@@ -8,6 +8,64 @@
 #include "compute_lim.h"
 #include <LIMSolverInterface.h>
 
+IGL_INLINE int igl::compute_lim(
+  Eigen::Matrix<double,Eigen::Dynamic,3>& vertices,
+  const Eigen::Matrix<double,Eigen::Dynamic,3>& initialVertices,
+  const Eigen::Matrix<int,Eigen::Dynamic,Eigen::Dynamic>& elements,
+  const Eigen::SparseMatrix<double>& constraintMatrix,
+  const Eigen::Matrix<double,Eigen::Dynamic,1>& constraintTargets,
+  int energyType,
+  double tolerance,
+  int maxIteration,
+  bool findLocalMinima)
+{
+  return ComputeLIM(
+    vertices,
+    initialVertices,
+    elements,
+    constraintMatrix,
+    constraintTargets,
+    energyType,
+    tolerance,
+    maxIteration,
+    findLocalMinima
+    );
+}
+
+IGL_INLINE int igl::compute_lim(
+  Eigen::Matrix<double,Eigen::Dynamic,3>& vertices,
+  const Eigen::Matrix<double,Eigen::Dynamic,3>& initialVertices,
+  const Eigen::Matrix<int,Eigen::Dynamic,Eigen::Dynamic>& elements,
+  const Eigen::SparseMatrix<double>& constraintMatrix,
+  const Eigen::Matrix<double,Eigen::Dynamic,1>& constraintTargets,
+  int energyType,
+  double tolerance,
+  int maxIteration,
+  bool findLocalMinima,
+  bool enableOuput,
+  bool enableBarriers,
+  bool enableAlphaUpdate,
+  double beta,
+  double eps)
+{
+  return ComputeLIM(
+    vertices,
+    initialVertices,
+    elements,
+    constraintMatrix,
+    constraintTargets,
+    energyType,
+    tolerance,
+    maxIteration,
+    findLocalMinima,
+    enableOuput,
+    enableBarriers,
+    enableAlphaUpdate,
+    beta,
+    eps
+    );
+}
+
 IGL_INLINE int igl::compute_lim(
   Eigen::Matrix<double,Eigen::Dynamic,3>& vertices,
   const Eigen::Matrix<double,Eigen::Dynamic,3>& initialVertices,
@@ -23,20 +81,17 @@ IGL_INLINE int igl::compute_lim(
 {
   return ComputeLIM(
     vertices,
-  initialVertices,
-  elements,
-  borderVertices,
-  gradients,
-  constraintMatrix,
-  constraintTargets,
-  energyType,
-  tolerance,
-  maxIteration,
-  findLocalMinima,
-  true,
-  true,
-  -1,
-  -1);
+    initialVertices,
+    elements,
+    borderVertices,
+    gradients,
+    constraintMatrix,
+    constraintTargets,
+    energyType,
+    tolerance,
+    maxIteration,
+    findLocalMinima
+    );
 }
 
 IGL_INLINE int igl::compute_lim(
@@ -52,26 +107,28 @@ IGL_INLINE int igl::compute_lim(
   int maxIteration,
   bool findLocalMinima,
   bool enableOuput,
+  bool enableBarriers,
   bool enableAlphaUpdate,
   double beta,
   double eps)
 {
   return ComputeLIM(
     vertices,
-  initialVertices,
-  elements,
-  borderVertices,
-  gradients,
-  constraintMatrix,
-  constraintTargets,
-  energyType,
-  tolerance,
-  maxIteration,
-  findLocalMinima,
-  enableOuput,
-  enableAlphaUpdate,
-  beta,
-  eps);
+    initialVertices,
+    elements,
+    borderVertices,
+    gradients,
+    constraintMatrix,
+    constraintTargets,
+    energyType,
+    tolerance,
+    maxIteration,
+    findLocalMinima,
+    enableOuput,
+    enableBarriers,
+    enableAlphaUpdate,
+    beta,
+    eps);
 }
 
 #ifdef IGL_STATIC_LIBRARY

include/igl/lim/compute_lim.h

@@ -28,6 +28,7 @@ namespace igl
   //   maxIteration      max number of iterations
   //   findLocalMinima   iterating until a local minima is found. If not enabled only tolerance must be fulfilled.
   //   enableOutput      (optional) enables the output (#itaration / hessian correction / step size / positional constraints / barrier constraints / deformation energy) (default : true)
+  //   enableBarriers    (optional) enables the non-flip constraints (default = true)
   //   enableAlphaUpdate (optional) enables dynamic alpha weight adjustment (default = true)
   //   beta              (optional) steepness factor of barrier slopes (default: ARAP/LSCM = 0.01, Green = 1)
   //   eps               (optional) smallest valid triangle area (default: 1e-5 * smallest triangle)
@@ -46,6 +47,33 @@ namespace igl
   // -1 : Max iteration reached before tolerance was fulfilled
   // -2 : not feasible -> has inverted elements (may want to decrease eps?)
 
+  int compute_lim(
+    Eigen::Matrix<double,Eigen::Dynamic,3>& vertices,
+    const Eigen::Matrix<double,Eigen::Dynamic,3>& initialVertices,
+    const Eigen::Matrix<int,Eigen::Dynamic,Eigen::Dynamic>& elements,
+    const Eigen::SparseMatrix<double>& constraintMatrix,
+    const Eigen::Matrix<double,Eigen::Dynamic,1>& constraintTargets,
+    int energyType,
+    double tolerance,
+    int maxIteration,
+    bool findLocalMinima);
+
+  int compute_lim(
+    Eigen::Matrix<double,Eigen::Dynamic,3>& vertices,
+    const Eigen::Matrix<double,Eigen::Dynamic,3>& initialVertices,
+    const Eigen::Matrix<int,Eigen::Dynamic,Eigen::Dynamic>& elements,
+    const Eigen::SparseMatrix<double>& constraintMatrix,
+    const Eigen::Matrix<double,Eigen::Dynamic,1>& constraintTargets,
+    int energyType,
+    double tolerance,
+    int maxIteration,
+    bool findLocalMinima,
+    bool enableOuput,
+    bool enableBarriers,
+    bool enableAlphaUpdate,
+    double beta,
+    double eps);
+
   int compute_lim(
     Eigen::Matrix<double,Eigen::Dynamic,3>& vertices,
     const Eigen::Matrix<double,Eigen::Dynamic,3>& initialVertices,
@@ -72,6 +100,7 @@ namespace igl
     int maxIteration,
     bool findLocalMinima,
     bool enableOuput,
+    bool enableBarriers,
     bool enableAlphaUpdate,
     double beta,
     double eps);

tutorial/607_LIM/main.cpp

@@ -16,8 +16,9 @@ Eigen::MatrixXi F;
 
 SparseMatrix<double> C;
 Eigen::VectorXd b;
-vector<int> bv; // border vertices (don't need to be defined exept for LSCM)
-Eigen::VectorXd g; // gradients (don't need to be defined execpt for Poisson)
+
+int energyType;
+bool barriersEnabled;
 
 // This function is called every time a keyboard button is pressed
 // keys: 0:Original Mesh / 1:Harmonic / 2:Biharmonic / 3:Green / 4:ARAP
@@ -26,19 +27,30 @@ bool key_down(igl::Viewer& viewer,unsigned char key,int modifier)
   using namespace std;
   using namespace Eigen;
 
-  if(key >= '0' && key <= '4')
+  if(key >= '0' && key <= '4' || key == 'B')
   {
     // compute locally injective map
     int energy = key - 49;
 
     V1 = V0;
-    if(energy >= 0)
-      igl::compute_lim(V1,V0,F,bv,g,C,b,energy,1e-8,100,true);
+
+    if(key == 'B')
+    {
+      barriersEnabled = !barriersEnabled;
+    }
+    else
+    {
+      if(energy >= 0)
+        energyType = energy;
+    }
+    
+    igl::compute_lim(V1,V0,F,C,b,energyType,1e-8,100,true,true,barriersEnabled,true,-1,-1);
 
     // set mesh
-    viewer.set_mesh(V1,F);
-  }
+    viewer.set_vertices(V1);
 
+    return true;
+  }
 
   return false;
 }
@@ -48,6 +60,9 @@ int main(int argc, char *argv[])
   using namespace std;
   using namespace Eigen;
 
+  energyType = 0;
+  barriersEnabled = true;
+
   // load a mesh in OFF format
   igl::readOFF("../shared/grid.off",V0,F);
   V1 = V0;
@@ -85,7 +100,7 @@ int main(int argc, char *argv[])
   b(2*fixedVertices.size()+1) = 0.2;
 
   // compute locally injective map
-  igl::compute_lim(V1,V0,F,bv,g,C,b,0,1e-8,100,true);
+  igl::compute_lim(V1,V0,F,C,b,energyType,1e-8,100,true,true,barriersEnabled,true,-1,-1);
 
   // Show mesh
   igl::Viewer viewer;