Fixed the tab issue

Former-commit-id: 50d873554a160a6ed0278eb462b6d0e4bc24846b

include/igl/build_octree.cpp

@@ -5,13 +5,13 @@
 
 namespace igl {
   template <typename DerivedP, typename IndexType, typename CentersType,
-  	typename WidthsType>
+    typename WidthsType>
   IGL_INLINE void build_octree(const Eigen::MatrixBase<DerivedP>& P,
     std::vector<std::vector<IndexType> > & point_indices,
     std::vector<Eigen::Matrix<IndexType,8,1>,
-    	Eigen::aligned_allocator<Eigen::Matrix<IndexType,8,1> > > & children,
+      Eigen::aligned_allocator<Eigen::Matrix<IndexType,8,1> > > & children,
     std::vector<Eigen::Matrix<CentersType,1,3>,
-    	Eigen::aligned_allocator<Eigen::Matrix<CentersType,1,3> > > & centers,
+      Eigen::aligned_allocator<Eigen::Matrix<CentersType,1,3> > > & centers,
     std::vector<WidthsType> & widths)
   {
     const int MAX_DEPTH = 30000;
@@ -97,7 +97,7 @@ namespace igl {
         for(int j = 0; j < point_indices.at(index).size(); j++){
           IndexType curr_point_index = point_indices.at(index).at(j);
           IndexType cell_of_curr_point =
-          	get_octant(P.row(curr_point_index),curr_center)+m;
+            get_octant(P.row(curr_point_index),curr_center)+m;
           point_indices.at(cell_of_curr_point).emplace_back(curr_point_index);
         }
       
@@ -129,7 +129,7 @@ namespace igl {
     WidthsType aabb_width = std::max(std::max(
                                           frontrighttop(0) - backleftbottom(0),
                                           frontrighttop(1) - backleftbottom(1)),
-                                 					frontrighttop(2) - backleftbottom(2));
+                                          frontrighttop(2) - backleftbottom(2));
     centers.emplace_back( aabb_center );
   
     //Widths are the side length of the cube, (not half the side length):

include/igl/build_octree.h

@@ -42,14 +42,14 @@ namespace igl
   //                  octree cell
   //
   template <typename DerivedP, typename IndexType, typename CentersType,
-  	typename WidthsType>
+    typename WidthsType>
   IGL_INLINE void build_octree(const Eigen::MatrixBase<DerivedP>& P,
     std::vector<std::vector<IndexType> > & point_indices,
     std::vector<Eigen::Matrix<IndexType,8,1>,
-    	Eigen::aligned_allocator<Eigen::Matrix<IndexType,8,1> > > & children,
+      Eigen::aligned_allocator<Eigen::Matrix<IndexType,8,1> > > & children,
     std::vector<Eigen::Matrix<CentersType,1,3>,
       Eigen::aligned_allocator<Eigen::Matrix<CentersType,1,3> > > & centers,
-  	std::vector<WidthsType> & widths);
+    std::vector<WidthsType> & widths);
 }
 
 #ifndef IGL_STATIC_LIBRARY

include/igl/copyleft/cgal/point_areas_and_normals.cpp

@@ -20,14 +20,14 @@ typedef CGAL::Delaunay_triangulation_2<Kernel, Tds>                   Delaunay;
 typedef Kernel::Point_2                                               Point;
 
 namespace igl {
-	namespace copyleft{
-		namespace cgal{
+  namespace copyleft{
+    namespace cgal{
       template <typename DerivedP, typename DerivedI, typename DerivedO,
       typename DerivedA, typename DerivedN>
       IGL_INLINE void point_areas_and_normals(
                                         const Eigen::MatrixBase<DerivedP>& P,
                                         const Eigen::MatrixBase<DerivedI>& I,
-                                      	const Eigen::MatrixBase<DerivedO>& O,
+                                        const Eigen::MatrixBase<DerivedO>& O,
                                         Eigen::PlainObjectBase<DerivedA> & A,
                                         Eigen::PlainObjectBase<DerivedN> & N)
       {
@@ -40,9 +40,9 @@ namespace igl {
         typedef Eigen::Matrix<real, Eigen::Dynamic, Eigen::Dynamic> MatrixP;
         typedef Eigen::Matrix<scalarO, Eigen::Dynamic, Eigen::Dynamic> MatrixO;
         typedef Eigen::Matrix<typename DerivedO::Scalar,
-        					Eigen::Dynamic, Eigen::Dynamic> VecotorO;
+                  Eigen::Dynamic, Eigen::Dynamic> VecotorO;
         typedef Eigen::Matrix<typename DerivedI::Scalar,
-        					Eigen::Dynamic, Eigen::Dynamic> MatrixI;
+                  Eigen::Dynamic, Eigen::Dynamic> MatrixI;
         
         
         
@@ -66,7 +66,7 @@ namespace igl {
             igl::slice(O,neighbor_index,1,neighbor_normals);
             Eigen::Matrix<scalarO,1,3> poi_normal = neighbor_normals.row(0);
             Eigen::Matrix<scalarO,Eigen::Dynamic,1> dotprod =
-            								poi_normal(0)*neighbor_normals.col(0)
+                            poi_normal(0)*neighbor_normals.col(0)
             + poi_normal(1)*neighbor_normals.col(1)
             + poi_normal(2)*neighbor_normals.col(2);
             Eigen::Array<bool,Eigen::Dynamic,1> keep = dotprod.array() > 0;
@@ -105,7 +105,7 @@ namespace igl {
             int f_row = 0;
             for(Delaunay::Finite_faces_iterator fit =
                 triangulation.finite_faces_begin();
-              	fit != triangulation.finite_faces_end(); ++fit) {
+                fit != triangulation.finite_faces_end(); ++fit) {
               Delaunay::Face_handle face = fit;
               F.row(f_row) = Eigen::RowVector3i((int)face->vertex(0)->info(),
                                                 (int)face->vertex(1)->info(),
@@ -140,7 +140,7 @@ namespace igl {
                 scalarA full_area = 0.25*std::sqrt(
                                     (x+(y+z))*(z-(x-y))*(z+(x-y))*(x+(y-z)));
                 Eigen::Matrix<scalarA,1,3> partial_area =
-                																		barycentric * full_area;
+                                                    barycentric * full_area;
                 if(cosX < 0){
                   area_accumulator += 0.5*full_area;
                 } else if (cosY < 0 || cosZ < 0){
@@ -159,8 +159,8 @@ namespace igl {
           }
         },1000);
       }
-		}
-	}
+    }
+  }
 }
 
 

include/igl/copyleft/cgal/point_areas_and_normals.h

@@ -12,14 +12,14 @@
 #include <Eigen/Core>
 namespace igl
 {
-	namespace copyleft
+  namespace copyleft
   {
-  	namespace cgal
+    namespace cgal
     {
     // Given a 3D set of points P, each with a list of k-nearest-neighbours,
     // estimate the geodesic voronoi area associated with each point.
     //
-  	// The k nearest neighbours may be known from running igl::knn_octree on
+    // The k nearest neighbours may be known from running igl::knn_octree on
     // the output data from igl::build_octree. We reccomend using a k value
     // between 15 and 20 inclusive for accurate area estimation.
     //
@@ -38,7 +38,7 @@ namespace igl
     // Outputs:
     //   A  #P list of estimated areas
     //   N  #P by 3 list of estimated normals
-		template <typename DerivedP, typename DerivedI, typename DerivedO,
+    template <typename DerivedP, typename DerivedI, typename DerivedO,
       typename DerivedA, typename DerivedN>
     IGL_INLINE void point_areas_and_normals(
                                         const Eigen::MatrixBase<DerivedP>& P,

include/igl/fast_winding_number.cpp

@@ -7,7 +7,7 @@
 
 namespace igl {
 template <typename DerivedP, typename DerivedA, typename DerivedN,
-  	typename Index, typename DerivedCM, typename DerivedR, typename DerivedEC>
+    typename Index, typename DerivedCM, typename DerivedR, typename DerivedEC>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
             const Eigen::MatrixBase<DerivedN>& N,
             const Eigen::MatrixBase<DerivedA>& A,
@@ -73,7 +73,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
               //Get max distance from center of mass:
               int curr_point_index = point_indices.at(index).at(i);
               Eigen::Matrix<real_r,1,3> point =
-            			P.row(curr_point_index)-masscenter;
+                  P.row(curr_point_index)-masscenter;
               curr_norm = point.norm();
               if(curr_norm > max_norm){
                   max_norm = curr_norm;
@@ -83,7 +83,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
               Eigen::Matrix<real_ec,3,3> TempCoeffs;
               if(EC.cols() >= (3+9)){
                   TempCoeffs = A(curr_point_index)*point.transpose()*
-                									N.row(curr_point_index);
+                                  N.row(curr_point_index);
                   EC.block(index,3,1,9) +=
                   Eigen::Map<Eigen::Matrix<real_ec,1,9> >(TempCoeffs.data(),
                                                           TempCoeffs.size());
@@ -94,7 +94,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
                       TempCoeffs = 0.5 * point(k) * (A(curr_point_index)*
                                     point.transpose()*N.row(curr_point_index));
                       EC.block(index,12+9*k,1,9) += Eigen::Map<
-                    		Eigen::Matrix<real_ec,1,9> >(TempCoeffs.data(),
+                        Eigen::Matrix<real_ec,1,9> >(TempCoeffs.data(),
                                                      TempCoeffs.size());
                   }
               }
@@ -113,8 +113,8 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
   }
   
   template <typename DerivedP, typename DerivedA, typename DerivedN,
-  	typename Index, typename DerivedCM, typename DerivedR, typename DerivedEC,
-  	typename DerivedQ, typename BetaType, typename DerivedWN>
+    typename Index, typename DerivedCM, typename DerivedR, typename DerivedEC,
+    typename DerivedQ, typename BetaType, typename DerivedWN>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
             const Eigen::MatrixBase<DerivedN>& N,
             const Eigen::MatrixBase<DerivedA>& A,
@@ -144,7 +144,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
     auto direct_eval = [](const RowVec & loc,
                           const Eigen::Matrix<real_ec,1,3> & anorm){
         real_wn wn = (loc(0)*anorm(0)+loc(1)*anorm(1)+loc(2)*anorm(2))
-      															/(4.0*M_PI*std::pow(loc.norm(),3));
+                                    /(4.0*M_PI*std::pow(loc.norm(),3));
         if(std::isnan(wn)){
             return 0.5;
         }else{
@@ -158,10 +158,10 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
       double r = loc.norm();
       if(EC.size()>3){
         Eigen::Matrix<real_ec,3,3> SecondDerivative =
-          	Eigen::Matrix<real_ec,3,3>::Identity()/(4.0*M_PI*std::pow(r,3));
+            Eigen::Matrix<real_ec,3,3>::Identity()/(4.0*M_PI*std::pow(r,3));
         SecondDerivative += -3.0*loc.transpose()*loc/(4.0*M_PI*std::pow(r,5));
         Eigen::Matrix<real_ec,1,9> derivative_vector =
-        	Eigen::Map<Eigen::Matrix<real_ec,1,9> >(SecondDerivative.data(),
+          Eigen::Map<Eigen::Matrix<real_ec,1,9> >(SecondDerivative.data(),
                                                   SecondDerivative.size());
         wn += derivative_vector.cwiseProduct(EC.segment<9>(3)).sum();
       }
@@ -169,7 +169,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
           Eigen::Matrix<real_ec,3,3> ThirdDerivative;
           for(int i = 0; i < 3; i++){
               ThirdDerivative =
-            			15.0*loc(i)*loc.transpose()*loc/(4.0*M_PI*std::pow(r,7));
+                  15.0*loc(i)*loc.transpose()*loc/(4.0*M_PI*std::pow(r,7));
               Eigen::Matrix<real_ec,3,3> Diagonal;
               Diagonal << loc(i), 0, 0,
               0, loc(i), 0,
@@ -179,9 +179,9 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
               RowCol.row(i) = loc;
               RowCol = RowCol + RowCol.transpose();
               ThirdDerivative +=
-            			-3.0/(4.0*M_PI*std::pow(r,5))*(RowCol+Diagonal);
+                  -3.0/(4.0*M_PI*std::pow(r,5))*(RowCol+Diagonal);
               Eigen::Matrix<real_ec,1,9> derivative_vector =
-            		Eigen::Map<Eigen::Matrix<real_ec,1,9> >(ThirdDerivative.data(),
+                Eigen::Map<Eigen::Matrix<real_ec,1,9> >(ThirdDerivative.data(),
                                                         ThirdDerivative.size());
               wn += derivative_vector.cwiseProduct(
                                               EC.segment<9>(12 + i*9)).sum();
@@ -260,7 +260,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
   }
   
   template <typename DerivedP, typename DerivedA, typename DerivedN,
-  	typename DerivedQ, typename BetaType, typename DerivedWN>
+    typename DerivedQ, typename BetaType, typename DerivedWN>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
                                       const Eigen::MatrixBase<DerivedN>& N,
                                       const Eigen::MatrixBase<DerivedA>& A,
@@ -291,7 +291,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
   }
   
   template <typename DerivedP, typename DerivedA, typename DerivedN,
-  	typename DerivedQ, typename DerivedWN>
+    typename DerivedQ, typename DerivedWN>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
                                       const Eigen::MatrixBase<DerivedN>& N,
                                       const Eigen::MatrixBase<DerivedA>& A,
@@ -302,7 +302,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
   }
   
   template <typename DerivedP, typename DerivedN, typename DerivedQ,
-  	typename BetaType, typename DerivedWN>
+    typename BetaType, typename DerivedWN>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
                                       const Eigen::MatrixBase<DerivedN>& N,
                                       const Eigen::MatrixBase<DerivedQ>& Q,
@@ -315,7 +315,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
   
     std::vector<std::vector<int> > point_indices;
     std::vector<Eigen::Matrix<int,8,1>,
-    	Eigen::aligned_allocator<Eigen::Matrix<int,8,1> > > children;
+      Eigen::aligned_allocator<Eigen::Matrix<int,8,1> > > children;
     std::vector<RowVec, Eigen::aligned_allocator<RowVec> > centers;
     std::vector<real> widths;
     Eigen::MatrixXi I;
@@ -334,7 +334,7 @@ template <typename DerivedP, typename DerivedA, typename DerivedN,
   }
   
   template <typename DerivedP, typename DerivedN,
-  	typename DerivedQ, typename DerivedWN>
+    typename DerivedQ, typename DerivedWN>
   IGL_INLINE void fast_winding_number(
                             const Eigen::MatrixBase<DerivedP>& P,
                             const Eigen::MatrixBase<DerivedN>& N,

include/igl/fast_winding_number.h

@@ -26,13 +26,13 @@ namespace igl
   //   expansion_order    the order of the taylor expansion. We support 0,1,2.
   // Outputs:
   //   CM  #OctreeCells by 3 list of each cell's center of mass
-  //   R	 #OctreeCells by 1 list of each cell's maximum distance of any point
-  //			 to the center of mass
+  //   R   #OctreeCells by 1 list of each cell's maximum distance of any point
+  //       to the center of mass
   //   EC  #OctreeCells by #TaylorCoefficients list of expansion coefficients.
-  //	 		 (Note that #TaylorCoefficients = ∑_{i=1}^{expansion_order} 3^i)
+  //       (Note that #TaylorCoefficients = ∑_{i=1}^{expansion_order} 3^i)
   //
   template <typename DerivedP, typename DerivedA, typename DerivedN,
-  	typename Index, typename DerivedCM, typename DerivedR, typename DerivedEC>
+    typename Index, typename DerivedCM, typename DerivedR, typename DerivedEC>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
                                       const Eigen::MatrixBase<DerivedN>& N,
                                       const Eigen::MatrixBase<DerivedA>& A,
@@ -61,16 +61,16 @@ namespace igl
   //        (Note that #TaylorCoefficients = ∑_{i=1}^{expansion_order} 3^i)
   //   Q  #Q by 3 list of query points for the winding number
   //   beta  This is a Barnes-Hut style accuracy term that separates near feild
-  //				 from far field. The higher the beta, the more accurate and slower
+  //         from far field. The higher the beta, the more accurate and slower
   //         the evaluation. We reccommend using a beta value of 2. Note that
-  //				 for a beta value ≤ 0, we use the direct evaluation, rather than
+  //         for a beta value ≤ 0, we use the direct evaluation, rather than
   //         the fast approximation
   // Outputs:
-  //	 WN  #Q by 1 list of windinng number values at each query point
+  //   WN  #Q by 1 list of windinng number values at each query point
   //
   template <typename DerivedP, typename DerivedA, typename DerivedN,
-  	typename Index, typename DerivedCM, typename DerivedR, typename DerivedEC,
-  	typename DerivedQ, typename BetaType, typename DerivedWN>
+    typename Index, typename DerivedCM, typename DerivedR, typename DerivedEC,
+    typename DerivedQ, typename BetaType, typename DerivedWN>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
                                       const Eigen::MatrixBase<DerivedN>& N,
                                       const Eigen::MatrixBase<DerivedA>& A,
@@ -102,7 +102,7 @@ namespace igl
   //   WN  #Q by 1 list of windinng number values at each query point
   //
   template <typename DerivedP, typename DerivedA, typename DerivedN,
-  	typename DerivedQ, typename BetaType, typename DerivedWN>
+    typename DerivedQ, typename BetaType, typename DerivedWN>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
                                       const Eigen::MatrixBase<DerivedN>& N,
                                       const Eigen::MatrixBase<DerivedA>& A,
@@ -132,7 +132,7 @@ namespace igl
   //   WN  #Q by 1 list of windinng number values at each query point
   //
   template <typename DerivedP, typename DerivedA, typename DerivedN,
-  	typename DerivedQ, typename DerivedWN>
+    typename DerivedQ, typename DerivedWN>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
                                       const Eigen::MatrixBase<DerivedN>& N,
                                       const Eigen::MatrixBase<DerivedA>& A,
@@ -160,7 +160,7 @@ namespace igl
   //   WN  #Q by 1 list of windinng number values at each query point
   //
   template <typename DerivedP, typename DerivedN, typename DerivedQ,
-  	typename BetaType, typename DerivedWN>
+    typename BetaType, typename DerivedWN>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
                                       const Eigen::MatrixBase<DerivedN>& N,
                                       const Eigen::MatrixBase<DerivedQ>& Q,
@@ -186,7 +186,7 @@ namespace igl
   //   WN  #Q by 1 list of windinng number values at each query point
   //
   template <typename DerivedP, typename DerivedN, typename DerivedQ,
-  	typename DerivedWN>
+    typename DerivedWN>
   IGL_INLINE void fast_winding_number(const Eigen::MatrixBase<DerivedP>& P,
                                       const Eigen::MatrixBase<DerivedN>& N,
                                       const Eigen::MatrixBase<DerivedQ>& Q,

include/igl/knn_octree.h

@@ -22,15 +22,15 @@ namespace igl
   //
   // Inputs:
   //   P  #P by 3 list of point locations
-  //	 k  number of neighbors to find
+  //   k  number of neighbors to find
   //   point_indices  a vector of vectors, where the ith entry is a vector of
   //                  the indices into P that are the ith octree cell's points
-  //   children 			a vector of vectors, where the ith entry is a vector of
-  //									the ith octree cell's of octree children
-  //	 centers				a vector where the ith entry is a 3d row vector
-  //									representing the position of the ith cell's center
-  //   widths					a vector where the ith entry is the width of the ith
-  //									octree cell
+  //   children       a vector of vectors, where the ith entry is a vector of
+  //                  the ith octree cell's of octree children
+  //   centers        a vector where the ith entry is a 3d row vector
+  //                  representing the position of the ith cell's center
+  //   widths         a vector where the ith entry is the width of the ith
+  //                  octree cell
   // Outputs:
   //   I  #P by k list of k-nearest-neighbor indices into P
   template <typename DerivedP, typename KType, typename IndexType,