Clean SMS code (whitespace, indentation, variable names, clumsy for loops, etc)

Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_ratio_stop_predicate.h

@@ -10,14 +10,14 @@ which returns `true` when the relation between the initial and current number of
 
 \tparam TriangleMesh is the type of surface mesh being simplified, and must be a model of the `MutableFaceGraph` and `HalfedgeListGraph` concepts.
 
-
 \cgalModels `StopPredicate`
 
 \sa `CGAL::Surface_mesh_simplification::Count_stop_predicate<TriangleMesh>`
 
 */
 template< typename TriangleMesh >
-class Count_ratio_stop_predicate {
+class Count_ratio_stop_predicate
+{
 public:
 
 /// \name Creation
@@ -37,11 +37,10 @@ Count_ratio_stop_predicate<TriangleMesh>(double ratio);
 Returns ` (((double)current_count / (double)initial_count) < ratio)`.
 All other parameters are ignored (but exist since this is a generic policy).
 */
-bool operator()(FT const& current_cost 
+bool operator()(const FT& current_cost,
-, const Profile& edge_profile 
+                const Profile& edge_profile,
-, size_type initial_count 
+                size_type initial_count,
-, size_type current_count 
+                size_type current_count) const;
-) const; 
 
 /// @}
 

Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_stop_predicate.h

@@ -1,4 +1,3 @@
-
 namespace CGAL {
 namespace Surface_mesh_simplification {
 
@@ -35,11 +34,10 @@ Count_stop_predicate<TriangleMesh>(size_type threshold);
 /*!
 Returns `(current_count < threshold)`. All other parameters are ignored (but exist since this is a generic policy).
 */
-bool operator()(FT const& current_cost 
+bool operator()(const FT& current_cost,
-, const Profile& edge_profile 
+                const Profile& edge_profile,
-, size_type initial_count 
+                size_type initial_count,
-, size_type current_count 
+                size_type current_count) const;
-) const; 
 
 /// @}
 

Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_length_cost.h

@@ -1,4 +1,3 @@
-
 namespace CGAL {
 namespace Surface_mesh_simplification {
 
@@ -10,12 +9,12 @@ which computes the collapse cost as the squared length of the edge.
 
 \tparam TriangleMesh is the type of surface mesh being simplified, and must be a model of the `MutableFaceGraph` and `HalfedgeListGraph` concepts.
 
-
 \cgalModels `GetCost`
 
 */
 template< typename TriangleMesh >
-class Edge_length_cost {
+class Edge_length_cost
+{
 public:
 
 /// \name Creation
@@ -39,8 +38,8 @@ The `placement` argument is ignored.
 
 */
 template <typename Profile, typename T>
-optional<typename Profile::FT> operator()(const Profile& profile 
+optional<typename Profile::FT> operator()(const Profile& profile,
-, T const& placement) const; 
+                                          const T& placement) const;
 
 /// @}
 

Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_length_stop_predicate.h

@@ -15,7 +15,8 @@ This predicate is meant to be used with `Edge_length_cost`.
 
 */
 template< typename FT >
-class Edge_length_stop_predicate {
+class Edge_length_stop_predicate
+{
 public:
 
 /// \name Creation
@@ -35,11 +36,10 @@ Edge_length_stop_predicate<TriangleMesh>(FT threshold);
 Returns `(CGAL::squared_distance(edge_profile.p0(),edge_profile.p1()) > threshold*threshold)`.
 All other parameters are ignored (but exist since this is a generic policy).
 */
-bool operator()(FT const&
+bool operator()(const FT&,
-, const Profile& edge_profile
+                const Profile& edge_profile,
-, size_type
+                size_type,
-, size_type
+                size_type) const;
-) const;
 
 /// @}
 

Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_cost.h

@@ -1,4 +1,3 @@
-
 namespace CGAL {
 namespace Surface_mesh_simplification {
 /*!
@@ -26,7 +25,7 @@ public:
 Initializes the policy with the given <I>weighting unit factor</I>.
 See \ref SurfaceMeshSimplificationLindstromTurkStrategy for details on the meaning of this factor.
 */
-LindstromTurk_cost<TriangleMesh>(FT const& factor = FT(0.5)); 
+LindstromTurk_cost<TriangleMesh>(const FT& factor = FT(0.5));
 
 /// @}
 
@@ -39,8 +38,8 @@ the new `placement` computed for it.
 */
 template <typename Profile>
 optional<typename Profile::FT>
-operator()(const Profile& profile 
+operator()(const Profile& profile,
-            , boost::optional<typename Profile::Point> const& placement) const; 
+           const boost::optional<typename Profile::Point>& placement) const
 
 /// @}
 

Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_placement.h

@@ -1,4 +1,3 @@
-
 namespace CGAL {
 namespace Surface_mesh_simplification {
 
@@ -28,7 +27,7 @@ public:
 Initializes the policy with the given <I>weighting unit factor</I>.
 See \ref SurfaceMeshSimplificationLindstromTurkStrategy for details on the meaning of this factor.
 */
-LindstromTurk_placement<TriangleMesh>(FT const& factor = FT(0.5)); 
+LindstromTurk_placement<TriangleMesh>(const FT& factor = FT(0.5));
 
 /// @}
 

Surface_mesh_simplification/doc/Surface_mesh_simplification/Concepts/EdgeCollapseSimplificationVisitor.h

@@ -1,4 +1,3 @@
-
 /*!
 \ingroup PkgSurfaceMeshSimplificationConcepts
 \cgalConcept
@@ -8,7 +7,6 @@ The concept `EdgeCollapseSimplificationVisitor` describes the requirements for t
 The several callbacks given as member functions in the visitor are called from certain places in the algorithm implementation.
 
 */
-
 class EdgeCollapseSimplificationVisitor {
 public:
 
@@ -40,7 +38,6 @@ An integer type representing the number of edges
 */
 typedef unspecified_type size_type;
 
-
 /// @}
 
 /// \name Operations
@@ -54,7 +51,7 @@ void OnStarted(TriangleMesh& surface_mesh);
 /*!
 Called after the algorithm finishes.
 */
-void OnFinished (TriangleMesh& surface_mesh); 
+void OnFinished(TriangleMesh& surface_mesh);
 
 /*!
 Called when the `StopPredicate` returned `true`
@@ -68,7 +65,8 @@ Called during the <I>collecting phase</I> (when a cost is assigned to the edges)
 for each edge collected.
 
 */
-void OnCollected(const Profile& profile, boost::optional<FT> cost); 
+void OnCollected(const Profile& profile,
+                 boost::optional<FT> cost);
 
 /*!
 Called during the <I>processing phase</I> (when edges are collapsed),
@@ -85,11 +83,10 @@ the edge will not be collapsed.
 the number of edges.
 
 */
-void OnSelected(const Profile& profile 
+void OnSelected(const Profile& profile,
-, boost::optional<FT> cost 
+                boost::optional<FT> cost,
-, size_type initial_count 
+                size_type initial_count,
-, size_type current_count 
+                size_type current_count);
-); 
 
 /*!
 Called when an edge is about to be collapsed and replaced by a vertex
@@ -99,14 +96,14 @@ If `placement` is absent (meaning that it could not be computed)
 the edge will not be collapsed.
 
 */
-void OnCollapsing(const Profile& profile 
+void OnCollapsing(const Profile& profile,
-, boost::optional<Point> placement 
+                  boost::optional<Point> placement);
-); 
 
 /*!
 Called when an edge has been collapsed and replaced by the vertex `vd`
 */
-void OnCollapsed(Profile const&, Profile::const vertex_descriptor vd) {}
+void OnCollapsed(const Profile&,
+                 const Profile::vertex_descriptor vd) {}
 
 /*!
 Called for each selected edge which cannot be
@@ -120,4 +117,3 @@ void OnNonCollapsable(const Profile& profile);
 /// @}
 
 }; /* end EdgeCollapseSimplificationVisitor */
-

Surface_mesh_simplification/doc/Surface_mesh_simplification/Concepts/EdgeProfile.h

@@ -1,4 +1,3 @@
-
 /*!
 \ingroup PkgSurfaceMeshSimplificationConcepts
 \cgalConcept
@@ -10,7 +9,6 @@ This profile is used by the stop, cost and placement policies.
 \cgalHasModel `CGAL::Surface_mesh_simplification::Edge_profile<TriangleMesh>`
 
 */
-
 class EdgeProfile {
 public:
 
@@ -76,12 +74,12 @@ halfedge_descriptor v1_v0() const;
 /*!
 The point of vertex ` v0`.
 */
-Point const& p0() const; 
+const Point& p0() const;
 
 /*!
 The point of vertex ` v1`.
 */
-Point const& p1() const; 
+const Point& p1() const;
 
 /*!
 If ` v0v1` belongs to a finite face (is not a border edge)
@@ -150,7 +148,7 @@ const TriangleMesh& surface_mesh() const;
 /*!
 Returns the vertex point property map.
 */
-  VertexPointMap vertex_point_map() const;
+VertexPointMap vertex_point_map() const;
 
 /// @}
 

Surface_mesh_simplification/doc/Surface_mesh_simplification/Concepts/GetCost.h

@@ -1,4 +1,3 @@
-
 /*!
 \ingroup PkgSurfaceMeshSimplificationConcepts
 \cgalConcept
@@ -18,11 +17,10 @@ or can be intentionally returned to prevent the edge from being collapsed.
 \cgalHasModel `CGAL::Surface_mesh_simplification::LindstromTurk_cost<TriangleMesh>`
 
 */
-
+class GetCost
-class GetCost {
+{
 public:
 
-
 /// \name Operations 
 /// @{
 
@@ -32,8 +30,8 @@ using the calculated placement.
 \tparam Profile must be a model of `EdgeProfile`.
 */ 
   template <class Profile>
-  boost::optional<typename Profile::FT> operator()(const Profile& edge_profile 
+  boost::optional<typename Profile::FT> operator()(const Profile& edge_profile,
-                                                    , boost::optional<typename Profile::Point> const& placement) const; 
+                                                   const boost::optional<typename Profile::Point>& placement) const;
 
 /// @}
 

Surface_mesh_simplification/doc/Surface_mesh_simplification/Concepts/StopPredicate.h

@@ -1,4 +1,3 @@
-
 /*!
 \ingroup PkgSurfaceMeshSimplificationConcepts
 \cgalConcept
@@ -10,7 +9,6 @@ The concept `StopPredicate` describes the requirements for the predicate which i
 \cgalHasModel `CGAL::Surface_mesh_simplification::Edge_length_stop_predicate<FT>`
 
 */
-
 class StopPredicate {
 public:
 
@@ -55,13 +53,11 @@ If the return value is `true` the simplification terminates before processing th
 otherwise it continues normally.
 
 */
-bool operator()(FT const& current_cost 
+  bool operator()(const FT& current_cost,
-, const Profile& profile 
+                  const Profile& profile,
-, size_type initial_count 
+                  size_type initial_count,
-, size_type current_count 
+                  size_type current_count) const;
-) const; 
 
 /// @}
 
 }; /* end StopPredicate */
-

Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_constrain_sharp_edges.cpp

@@ -36,11 +36,9 @@ struct Constrained_edge_map
     : mConstraints(aConstraints)
   {}
 
-  reference operator[](key_type const& e) const { return  is_constrained(e); }
+  reference operator[](const key_type& e) const { return  is_constrained(e); }
 
-  bool is_constrained(key_type const& e) const {
+  bool is_constrained(const key_type& e) const { return mConstraints.is_defined(e); }
-    return mConstraints.is_defined(e);
-  }
 
 private:
   const CGAL::Unique_hash_map<key_type,bool>& mConstraints;

Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_visitor_surface_mesh.cpp

@@ -13,18 +13,17 @@
 // Stop-condition policy
 #include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_ratio_stop_predicate.h>
 
-typedef CGAL::Simple_cartesian<double> Kernel;
+typedef CGAL::Simple_cartesian<double>                                  Kernel;
-typedef Kernel::Point_3 Point_3;
+typedef Kernel::Point_3                                                 Point_3;
 
-typedef CGAL::Surface_mesh<Point_3> Surface_mesh; 
+typedef CGAL::Surface_mesh<Point_3>                                     Surface_mesh;
 
-typedef boost::graph_traits<Surface_mesh>::halfedge_descriptor halfedge_descriptor;
+typedef boost::graph_traits<Surface_mesh>::halfedge_descriptor          halfedge_descriptor;
-typedef boost::graph_traits<Surface_mesh>::vertex_descriptor vertex_descriptor;
+typedef boost::graph_traits<Surface_mesh>::vertex_descriptor            vertex_descriptor;
 
 namespace SMS = CGAL::Surface_mesh_simplification;
 
-typedef SMS::Edge_profile<Surface_mesh> Profile;
+typedef SMS::Edge_profile<Surface_mesh>                                 Profile;
-
 
 // The following is a Visitor that keeps track of the simplification process.
 // In this example the progress is printed real-time and a few statistics are
@@ -33,12 +32,8 @@ typedef SMS::Edge_profile<Surface_mesh> Profile;
 struct Stats
 {
   Stats()
-    : collected(0)
+    : collected(0), processed(0), collapsed(0),
-    , processed(0)
+      non_collapsable(0), cost_uncomputable(0), placement_uncomputable(0)
-    , collapsed(0)
-    , non_collapsable(0)
-    , cost_uncomputable(0) 
-    , placement_uncomputable(0) 
   {}
 
   std::size_t collected;
@@ -54,23 +49,22 @@ struct My_visitor : SMS::Edge_collapse_visitor_base<Surface_mesh>
   My_visitor(Stats* s) : stats(s){}
 
   // Called during the collecting phase for each edge collected.
-  void OnCollected(Profile const&, boost::optional<double> const&)
+  void OnCollected(const Profile&, const boost::optional<double>&)
   {
-    ++ stats->collected;
+    ++(stats->collected);
     std::cerr << "\rEdges collected: " << stats->collected << std::flush;
   }
 
   // Called during the processing phase for each edge selected.
   // If cost is absent the edge won't be collapsed.
-  void OnSelected(const Profile&          
+  void OnSelected(const Profile&,
-                 ,boost::optional<double> cost
+                  boost::optional<double> cost,
-                 ,std::size_t             initial
+                  std::size_t initial,
-                 ,std::size_t             current
+                  std::size_t current)
-                )
   {
-    ++ stats->processed;
+    ++(stats->processed);
     if(!cost)
-      ++ stats->cost_uncomputable;
+      ++(stats->cost_uncomputable);
 
     if(current == initial)
       std::cerr << "\n" << std::flush;
@@ -79,39 +73,38 @@ struct My_visitor : SMS::Edge_collapse_visitor_base<Surface_mesh>
 
   // Called during the processing phase for each edge being collapsed.
   // If placement is absent the edge is left uncollapsed.
-  void OnCollapsing(const Profile&          
+  void OnCollapsing(const Profile&,
-                   ,boost::optional<Point>  placement
+                    boost::optional<Point> placement)
-                  )
   {
     if(!placement)
-      ++ stats->placement_uncomputable;
+      ++(stats->placement_uncomputable);
   }
 
   // Called for each edge which failed the so called link-condition,
   // that is, which cannot be collapsed because doing so would
   // turn the surface mesh into a non-manifold.
-  void OnNonCollapsable(Profile const&)
+  void OnNonCollapsable(const Profile&)
   {
-    ++ stats->non_collapsable;
+    ++(stats->non_collapsable);
   }
 
   // Called after each edge has been collapsed
-  void OnCollapsed(Profile const&, vertex_descriptor)
+  void OnCollapsed(const Profile&, vertex_descriptor)
   {
-    ++ stats->collapsed;
+    ++(stats->collapsed);
   }
 
   Stats* stats;
 };
 
-
 int main(int argc, char** argv)
 {
   Surface_mesh surface_mesh;
 
   std::ifstream is(argv[1]);
   is >> surface_mesh;
-  if(!CGAL::is_triangle_mesh(surface_mesh)){
+  if(!CGAL::is_triangle_mesh(surface_mesh))
+  {
     std::cerr << "Input geometry is not triangulated." << std::endl;
     return EXIT_FAILURE;
   }
@@ -129,11 +122,7 @@ int main(int argc, char** argv)
   // On the other hand, we pass here explicit cost and placement
   // function which differ from the default policies, ommited in
   // the previous example.
-  int r = SMS::edge_collapse
+  int r = SMS::edge_collapse(surface_mesh, stop, CGAL::parameters::visitor(vis));
-           (surface_mesh
-           ,stop
-           ,CGAL::parameters::visitor(vis)
-          );
 
   std::cout << "\nEdges collected: "  << stats.collected
             << "\nEdges proccessed: " << stats.processed

Surface_mesh_simplification/include/CGAL/Cartesian/MatrixC33.h

@@ -163,7 +163,7 @@ private:
 
 template<class R>
 inline
-MatrixC33<R> direct_product(Vector_3<R> const& u, Vector_3<R> const& v)
+MatrixC33<R> direct_product(const Vector_3<R>& u, const Vector_3<R>& v)
 {
   return MatrixC33<R>(v * u.x(),
                       v * u.y(),
@@ -239,7 +239,7 @@ boost::optional< MatrixC33<R> > inverse_matrix(const MatrixC33<R>& m)
   return rInverse;
 }
 
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_CARTESIAN_MATRIXC33_H //
 // EOF //

Surface_mesh_simplification/include/CGAL/Null_matrix.h

@@ -28,6 +28,6 @@ class Null_matrix {};
 
 static const Null_matrix NULL_MATRIX = Null_matrix();
 
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_NULL_MATRIX_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Detail/Edge_collapse.h

@@ -18,11 +18,10 @@
 // Author(s)     : Fernando Cacciola <fernando.cacciola@geometryfactory.com>
 //
 #ifndef CGAL_SURFACE_MESH_SIMPLIFICATION_DETAIL_EDGE_COLLAPSE_H
-#define CGAL_SURFACE_MESH_SIMPLIFICATION_DETAIL_EDGE_COLLAPSE_H 1
+#define CGAL_SURFACE_MESH_SIMPLIFICATION_DETAIL_EDGE_COLLAPSE_H
 
 #include <CGAL/license/Surface_mesh_simplification.h>
 
-
 #include <CGAL/Surface_mesh_simplification/Detail/Common.h>
 #include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_profile.h>
 #include <CGAL/boost/graph/Euler_operations.h>
@@ -122,7 +121,7 @@ public:
     edge_id() : mAlgorithm(0) {}
     edge_id(Self const* aAlgorithm) : mAlgorithm(aAlgorithm) {}
 
-    size_type operator[] (const halfedge_descriptor e) const { return mAlgorithm->get_edge_id(e); }
+    size_type operator[](const halfedge_descriptor e) const { return mAlgorithm->get_edge_id(e); }
 
     Self const* mAlgorithm;
   };
@@ -182,15 +181,15 @@ private:
   }
 
   size_type get_halfedge_id(const halfedge_descriptor aEdge) const { return Edge_index_map[aEdge]; }
-  size_type get_edge_id (const halfedge_descriptor aEdge) const { return get_halfedge_id(aEdge) / 2; }
+  size_type get_edge_id(const halfedge_descriptor aEdge) const { return get_halfedge_id(aEdge) / 2; }
 
-  bool is_primary_edge (const halfedge_descriptor aEdge) const { return (get_halfedge_id(aEdge) % 2) == 0; }
+  bool is_primary_edge(const halfedge_descriptor aEdge) const { return (get_halfedge_id(aEdge) % 2) == 0; }
-  halfedge_descriptor primary_edge (const halfedge_descriptor aEdge) {
+  halfedge_descriptor primary_edge(const halfedge_descriptor aEdge) {
     return is_primary_edge(aEdge) ? aEdge : opposite(aEdge, mSurface);
   }
 
   bool is_border(const vertex_descriptor aV) const;
-  bool is_border (const halfedge_descriptor aEdge) const {
+  bool is_border(const halfedge_descriptor aEdge) const {
     return face(aEdge, mSurface) == boost::graph_traits<TM>::null_face();
   }
 
@@ -202,7 +201,7 @@ private:
   bool is_border_or_constrained(const vertex_descriptor aV) const;
   bool is_border_or_constrained(const halfedge_descriptor aEdge) const { return is_border(aEdge) || is_constrained(aEdge); }
 
-  bool is_edge_a_border (const halfedge_descriptor aEdge) const
+  bool is_edge_a_border(const halfedge_descriptor aEdge) const
   {
     return is_border(aEdge) || is_border(opposite(aEdge, mSurface));
   }
@@ -243,13 +242,14 @@ private:
     return boost::str(boost::format("[V%1%:%2%]") % get(Vertex_index_map,v) % xyz_to_string(p));
   }
 
-  std::string edge_to_string (const halfedge_descriptor aEdge) const
+  std::string edge_to_string(const halfedge_descriptor aEdge) const
   {
-    vertex_descriptor p,q; boost::tie(p,q) = get_vertices(aEdge);
+    vertex_descriptor p, q;
+    boost::tie(p,q) = get_vertices(aEdge);
     return boost::str(boost::format("{E%1% %2%->%3%}%4%") % get(Edge_index_map, aEdge) % vertex_to_string(p) % vertex_to_string(q) % (is_border(aEdge) ? " (BORDER)" : (is_border(opposite(aEdge, mSurface)) ? " (~BORDER)": "")));
   }
 
-  Cost_type get_cost (const Profile& aProfile) const {
+  Cost_type get_cost(const Profile& aProfile) const {
     return Get_cost(aProfile, get_placement(aProfile));
   }
 
@@ -361,7 +361,7 @@ private:
 
   FT mcMaxDihedralAngleCos2;
 
-  CGAL_SMS_DEBUG_CODE (unsigned mStep;)
+  CGAL_SMS_DEBUG_CODE(unsigned mStep;)
 };
 
 template<class M, class SP, class VIM, class VPM,class EIM, class ECTM, class CF, class PF, class V>
@@ -400,9 +400,9 @@ EdgeCollapse(TM& aSurface,
     }
   }
 
-  CGAL_SMS_TRACE(0,"EdgeCollapse of TM with " << (num_edges(aSurface)/2) << " edges");
+  CGAL_SMS_TRACE(0, "EdgeCollapse of TM with " << (num_edges(aSurface)/2) << " edges");
 
-  CGAL_SMS_DEBUG_CODE (mStep = 0;)
+  CGAL_SMS_DEBUG_CODE(mStep = 0;)
 
 #ifdef CGAL_SURFACE_SIMPLIFICATION_ENABLE_TRACE
   for(vertex_descriptor vd : vertices(mSurface))
@@ -428,7 +428,7 @@ run()
   // Then proceed to collapse each edge in turn
   loop();
 
-  CGAL_SMS_TRACE(0,"Finished: " << (mInitialEdgeCount - mCurrentEdgeCount) << " edges removed.");
+  CGAL_SMS_TRACE(0, "Finished: " << (mInitialEdgeCount - mCurrentEdgeCount) << " edges removed.");
 
   int r = int(mInitialEdgeCount - mCurrentEdgeCount);
 
@@ -442,7 +442,7 @@ void
 EdgeCollapse<M,SP,VIM,VPM,EIM,ECTM,CF,PF,V>::
 collect()
 {
-  CGAL_SMS_TRACE(0,"collecting edges...");
+  CGAL_SMS_TRACE(0, "collecting edges...");
 
   // loop over all the _undirected_ edges in the surface putting them in the PQ
 
@@ -456,7 +456,7 @@ collect()
 
   mEdgeDataArray.reset(new Edge_data[lSize]);
 
-  mPQ.reset(new PQ (lSize, Compare_cost(this), edge_id(this)));
+  mPQ.reset(new PQ(lSize, Compare_cost(this), edge_id(this)));
 
   std::size_t id = 0;
   CGAL_SURF_SIMPL_TEST_assertion_code(size_type lInserted = 0);
@@ -485,18 +485,18 @@ collect()
 
       Visitor.OnCollected(lProfile, lData.cost());
 
-      CGAL_SURF_SIMPL_TEST_assertion_code (++ lInserted);
+      CGAL_SURF_SIMPL_TEST_assertion_code(++lInserted);
     }
     else
     {
       zero_length_edges.insert(primary_edge(lEdge));
-      CGAL_SURF_SIMPL_TEST_assertion_code (++ lNotInserted);
+      CGAL_SURF_SIMPL_TEST_assertion_code(++lNotInserted);
     }
 
     CGAL_SMS_TRACE(2,edge_to_string(lEdge));
   }
 
-  CGAL_SURF_SIMPL_TEST_assertion (lInserted + lNotInserted == mInitialEdgeCount);
+  CGAL_SURF_SIMPL_TEST_assertion(lInserted + lNotInserted == mInitialEdgeCount);
 
   for(halfedge_descriptor hd : zero_length_edges)
   {
@@ -545,11 +545,11 @@ collect()
     //the placement is trivial, it's always the point itself
     Placement_type lPlacement = lProfile.p0();
     vertex_descriptor rResult = halfedge_collapse_bk_compatibility(lProfile.v0_v1(), Edge_is_constrained_map);
-    put(Vertex_point_map,rResult,*lPlacement);
+    put(Vertex_point_map, rResult, *lPlacement);
-    Visitor.OnCollapsed(lProfile,rResult);
+    Visitor.OnCollapsed(lProfile, rResult);
   }
 
-  CGAL_SMS_TRACE(0,"Initial edge count: " << mInitialEdgeCount);
+  CGAL_SMS_TRACE(0, "Initial edge count: " << mInitialEdgeCount);
 }
 
 template<class M,class SP, class VIM, class VPM,class EIM,class ECTM, class CF,class PF,class V>
@@ -557,10 +557,10 @@ void
 EdgeCollapse<M,SP,VIM,VPM,EIM,ECTM,CF,PF,V>::
 loop()
 {
-  CGAL_SMS_TRACE(0,"Collapsing edges...");
+  CGAL_SMS_TRACE(0, "Collapsing edges...");
 
-  CGAL_SURF_SIMPL_TEST_assertion_code (size_type lloop_watchdog = 0);
+  CGAL_SURF_SIMPL_TEST_assertion_code(size_type lloop_watchdog = 0);
-  CGAL_SURF_SIMPL_TEST_assertion_code (size_type lNonCollapsableCount = 0);
+  CGAL_SURF_SIMPL_TEST_assertion_code(size_type lNonCollapsableCount = 0);
 
   // Pops and processes each edge from the PQ
 
@@ -571,7 +571,7 @@ loop()
 
   while((lEdge = pop_from_PQ()))
   {
-    CGAL_SURF_SIMPL_TEST_assertion(lloop_watchdog ++ < mInitialEdgeCount);
+    CGAL_SURF_SIMPL_TEST_assertion(lloop_watchdog++ < mInitialEdgeCount);
 
     CGAL_SMS_TRACE(1, "Popped " << edge_to_string(*lEdge));
     CGAL_assertion(!is_constrained(*lEdge));
@@ -947,7 +947,6 @@ are_shared_triangles_valid(const Point& p0, const Point& p1, const Point& p2, co
   return rR;
 }
 
-
 // Returns the directed halfedge connecting v0 to v1, if exists.
 template<class M, class SP, class VIM, class VPM, class EIM, class ECTM, class CF, class PF, class V>
 typename EdgeCollapse<M,SP,VIM,VPM,EIM,ECTM,CF,PF,V>::halfedge_descriptor
@@ -1043,10 +1042,10 @@ is_collapse_geometrically_valid(const Profile& aProfile, Placement_type k0)
 
         if(!are_shared_triangles_valid(*k0, get_point(k1), get_point(k2), get_point(k3)))
         {
-          CGAL_SMS_TRACE(3,  "    Triangles VX-V" << get(Vertex_index_map, k1)
+          CGAL_SMS_TRACE(3, "    Triangles VX-V" << get(Vertex_index_map, k1)
-                               << "-V" << get(Vertex_index_map, k2)
+                              << "-V" << get(Vertex_index_map, k2)
-                               << " and VX-V" << get(Vertex_index_map, k3)
+                              << " and VX-V" << get(Vertex_index_map, k3)
-                               << " are not geometrically valid. Collapse rejected");
+                              << " are not geometrically valid. Collapse rejected");
           rR = false;
         }
       }
@@ -1122,7 +1121,7 @@ collapse(const Profile& aProfile,
   if(aProfile.left_face_exists())
   {
     halfedge_descriptor lV0VL = primary_edge(aProfile.vL_v0());
-    if(is_constrained(lV0VL)) //make sure a constrained edge will not disappear
+    if(is_constrained(lV0VL)) // make sure a constrained edge will not disappear
       lV0VL=primary_edge(aProfile.v1_vL());
 
     CGAL_SMS_TRACE(3, "V0VL E" << get(Edge_index_map,lV0VL)
@@ -1197,7 +1196,7 @@ collapse(const Profile& aProfile,
 
   update_neighbors(rResult);
 
-  CGAL_SMS_DEBUG_CODE (++mStep;)
+  CGAL_SMS_DEBUG_CODE(++mStep;)
 }
 
 template<class M, class SP, class VIM, class VPM, class EIM, class ECTM, class CF, class PF, class V>

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Bounded_normal_change_placement.h

@@ -75,9 +75,9 @@ public:
 
            Vector n1 = Traits().construct_cross_product_vector_3_object()(eqp,eqr);
            Vector n2 = Traits().construct_cross_product_vector_3_object()(eq2p,eq2r);
-           if(! is_positive(Traits().compute_scalar_product_3_object()(n1, n2))){
+           if(!is_positive(Traits().compute_scalar_product_3_object()(n1, n2)))
              return boost::optional<typename Profile::Point>();
-           }
+
            ++it;
          }
        }
@@ -86,10 +86,10 @@ public:
   }
 
 private:
-  Placement  mPlacement;
+  Placement mPlacement;
 };
 
 } // namespace Surface_mesh_simplification
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_BOUNDED_NORMAL_CHANGE_PLACEMENT_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Constrained_placement.h

@@ -36,7 +36,7 @@ public:
   EdgeIsConstrainedMap Edge_is_constrained_map;
 
   Constrained_placement(EdgeIsConstrainedMap map=EdgeIsConstrainedMap(),
-                        BasePlacement base=BasePlacement())
+                        BasePlacement base = BasePlacement())
     : BasePlacement(base),
       Edge_is_constrained_map(map)
   {}
@@ -44,24 +44,19 @@ public:
   template <typename Profile> 
   optional<typename Profile::Point> operator()(const Profile& aProfile) const
   {
-    typedef typename Profile::TM                                TM;
+    typedef typename Profile::TM                                    TM;
-    typedef typename CGAL::Halfedge_around_target_iterator<TM>  in_edge_iterator;
+    typedef typename boost::graph_traits<TM>::halfedge_descriptor   halfedge_descriptor;
 
-    in_edge_iterator eb, ee;
+    for(halfedge_descriptor h : halfedges_around_target(aProfile.v0(), aProfile.surface_mesh()))
-    for(boost::tie(eb,ee) = halfedges_around_target(aProfile.v0(),aProfile.surface_mesh());
-      eb != ee; ++ eb)
     {
-      if(get(Edge_is_constrained_map, edge(*eb,aProfile.surface_mesh())))
+      if(get(Edge_is_constrained_map, edge(h, aProfile.surface_mesh())))
-        return get(aProfile.vertex_point_map(),
+        return get(aProfile.vertex_point_map(), aProfile.v0());
-                   aProfile.v0());
     }
 
-    for(boost::tie(eb,ee) = halfedges_around_target(aProfile.v1(),aProfile.surface_mesh());
+    for(halfedge_descriptor h : halfedges_around_target(aProfile.v1(), aProfile.surface_mesh()))
-      eb != ee; ++ eb)
     {
-      if(get(Edge_is_constrained_map, edge(*eb,aProfile.surface_mesh())))
+      if(get(Edge_is_constrained_map, edge(h, aProfile.surface_mesh())))
-        return get(aProfile.vertex_point_map(),
+        return get(aProfile.vertex_point_map(), aProfile.v1());
-                   aProfile.v1());
     }
 
     return static_cast<const BasePlacement*>(this)->operator()(aProfile);
@@ -69,6 +64,6 @@ public:
 };
 
 } // namespace Surface_mesh_simplification
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_CONSTRAINED_PLACEMENT_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_ratio_stop_predicate.h

@@ -18,7 +18,7 @@
 // Author(s)     : Fernando Cacciola <fernando.cacciola@geometryfactory.com>
 //
 #ifndef CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_COUNT_RATIO_STOP_PREDICATE_H
-#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_COUNT_RATIO_STOP_PREDICATE_H 1
+#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_COUNT_RATIO_STOP_PREDICATE_H
 
 #include <CGAL/license/Surface_mesh_simplification.h>
 
@@ -63,6 +63,6 @@ private:
 };
 
 } // namespace Surface_mesh_simplification
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_COUNT_RATIO_STOP_PREDICATE_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_stop_predicate.h

@@ -60,6 +60,6 @@ private:
 };
 
 } // namespace Surface_mesh_simplification
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_COUNT_STOP_PREDICATE_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Detail/Lindstrom_Turk_core.h

@@ -18,7 +18,7 @@
 // Author(s)     : Fernando Cacciola <fernando_cacciola@ciudad.com.ar>
 //
 #ifndef CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_DETAIL_LINDSTROM_TURK_CORE_H
-#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_DETAIL_LINDSTROM_TURK_CORE_H 1
+#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_DETAIL_LINDSTROM_TURK_CORE_H
 
 #include <CGAL/license/Surface_mesh_simplification.h>
 
@@ -28,6 +28,7 @@
 #include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_profile.h>
 #include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_params.h>
 
+#include <limits>
 #include <vector>
 
 // This should be in
@@ -77,7 +78,7 @@ public:
   typedef typename Profile::halfedge_descriptor_vector::const_iterator   const_border_edge_iterator;
 
 public:
-  LindstromTurkCore(Params const& aParams, const Profile& aProfile);
+  LindstromTurkCore(const Params& aParams, const Profile& aProfile);
 
   Optional_point compute_placement();
   Optional_FT compute_cost(const Optional_point& p);
@@ -111,12 +112,13 @@ private :
 
   void add_boundary_preservation_constraints(const Boundary_data_vector& aBdry);
   void add_volume_preservation_constraints(const Triangle_data_vector& aTriangles);
-  void add_boundary_and_volume_optimization_constraints(const Boundary_data_vector& aBdry, const Triangle_data_vector& aTriangles);
+  void add_boundary_and_volume_optimization_constraints(const Boundary_data_vector& aBdry,
+                                                        const Triangle_data_vector& aTriangles);
   void add_shape_optimization_constraints(const vertex_descriptor_vector& aLink);
 
   FT compute_boundary_cost(const Vector& v, const Boundary_data_vector& aBdry);
   FT compute_volume_cost(const Vector& v, const Triangle_data_vector& aTriangles);
-  FT compute_shape_cost(Point  const& p, const vertex_descriptor_vector& aLink);
+  FT compute_shape_cost(const Point& p, const vertex_descriptor_vector& aLink);
 
   Point get_point(const vertex_descriptor v) const
   {
@@ -156,12 +158,12 @@ private :
   static bool is_finite(const Matrix& m) { return is_finite(m.r0()) && is_finite(m.r1()) && is_finite(m.r2()); }
 
   template<class T>
-  static optional<T> filter_infinity (T const& n) { return is_finite(n) ? optional<T>(n) : optional<T>(); }
+  static optional<T> filter_infinity(const T& n) { return is_finite(n) ? optional<T>(n) : optional<T>(); }
 
   TM& surface() const { return mProfile.surface(); }
 
 private:
-  Params const& mParams;
+  const Params& mParams;
   const Profile& mProfile;
 
   void add_constraint_if_alpha_compatible(const Vector& Ai, const FT& bi);
@@ -183,7 +185,7 @@ private:
 
 template<class TM, class K>
 LindstromTurkCore<TM,K>::
-LindstromTurkCore(Params const& aParams, const Profile& aProfile)
+LindstromTurkCore(const Params& aParams, const Profile& aProfile)
   :
     mParams(aParams),
     mProfile(aProfile),
@@ -209,13 +211,12 @@ LindstromTurkCore<TM,K>::
 extract_boundary_data()
 {
   mBdry_data.reserve(mProfile.border_edges().size());
-  for(const_border_edge_iterator it = mProfile.border_edges().begin(), eit = mProfile.border_edges().end(); it != eit; ++ it)
+  for(halfedge_descriptor border_edge : mProfile.border_edges())
   {
-    halfedge_descriptor border_edge = *it;
+    halfedge_descriptor face_edge = opposite(border_edge, surface());
-    halfedge_descriptor face_edge = opposite(border_edge,surface());
 
-    vertex_descriptor sv = source(face_edge,surface());
+    vertex_descriptor sv = source(face_edge, surface());
-    vertex_descriptor tv = target(face_edge,surface());
+    vertex_descriptor tv = target(face_edge, surface());
 
     const Point& sp = get_point(sv);
     const Point& tp = get_point(tv);
@@ -236,10 +237,9 @@ LindstromTurkCore<TM,K>::
 extract_triangle_data()
 {
   mTriangle_data.reserve(mProfile.triangles().size());
-  for(const_triangle_iterator it = mProfile.triangles().begin(), eit = mProfile.triangles().end(); it != eit; ++ it)
-  {
-    Triangle const& tri = *it;
 
+  for(const Triangle& tri : mProfile.triangles())
+  {
     const Point& p0 = get_point(tri.v0);
     const Point& p1 = get_point(tri.v1);
     const Point& p2 = get_point(tri.v2);
@@ -248,7 +248,7 @@ extract_triangle_data()
     Vector v02 = p2 - p0;
 
     Vector lNormalV = cross_product(v01,v02);
-    FT lNormalL = point_cross_product(p0,p1) * (p2-ORIGIN);
+    FT lNormalL = point_cross_product(p0,p1) * (p2 - ORIGIN);
 
     CGAL_SMS_LT_TRACE(1, "  Extracting triangle v" << tri.v0 << "->v" << tri.v1 << "->v" << tri.v2
                            << " N:" << xyz_to_string(lNormalV) << " L:" << n_to_string(lNormalL));
@@ -347,11 +347,11 @@ compute_cost(const Optional_point& aP)
     CGAL_SMS_LT_TRACE(0,"Computing LT cost for E" << mProfile.v0_v1());
     Vector lV = (*aP) - ORIGIN;
 
-    FT lSquaredLength = squared_distance(mProfile.p0(),mProfile.p1());
+    FT lSquaredLength = squared_distance(mProfile.p0(), mProfile.p1());
 
-    FT lBdryCost = compute_boundary_cost(lV ,mBdry_data);
+    FT lBdryCost = compute_boundary_cost(lV, mBdry_data);
-    FT lVolumeCost = compute_volume_cost(lV ,mTriangle_data);
+    FT lVolumeCost = compute_volume_cost(lV, mTriangle_data);
-    FT lShapeCost  = compute_shape_cost(*aP,mProfile.link());
+    FT lShapeCost  = compute_shape_cost(*aP, mProfile.link());
 
     FT lTotalCost = FT(mParams.VolumeWeight) * lVolumeCost
                     + FT(mParams.BoundaryWeight) * lBdryCost * lSquaredLength
@@ -384,7 +384,7 @@ add_boundary_preservation_constraints(const Boundary_data_vector& aBdry)
        e1y = FT(0),
        e1z = FT(0);
 
-    for(typename Boundary_data_vector::const_iterator it = aBdry.begin(); it != aBdry.end(); ++ it)
+    for(typename Boundary_data_vector::const_iterator it = aBdry.begin(); it != aBdry.end(); ++it)
     {
       e1 = e1 + it->v;
       e2 = e2 + it->n;
@@ -447,12 +447,9 @@ add_boundary_and_volume_optimization_constraints(const Boundary_data_vector& aBd
   Vector c = NULL_VECTOR;
 
   // Volume optimization
-  for(typename Triangle_data_vector::const_iterator it = aTriangles.begin(), eit = aTriangles.end(); it != eit; ++it)
+  for(const Triangle_data& lTri : aTriangles)
   {
-    Triangle_data const& lTri = *it;
-
     H += direct_product(lTri.NormalV, lTri.NormalV);
-
     c = c - (lTri.NormalL * lTri.NormalV);
   }
 
@@ -464,10 +461,10 @@ add_boundary_and_volume_optimization_constraints(const Boundary_data_vector& aBd
     Matrix Hb = NULL_MATRIX;
     Vector cb = NULL_VECTOR;
 
-    for(typename Boundary_data_vector::const_iterator it = aBdry.begin(); it != aBdry.end(); ++ it)
+    for(typename Boundary_data_vector::const_iterator it = aBdry.begin(); it != aBdry.end(); ++it)
     {
       Matrix H = LT_product(it->v);
-      Vector c = cross_product(it->v,it->n);
+      Vector c = cross_product(it->v, it->n);
 
       Hb += H;
       cb = cb + c;
@@ -484,8 +481,8 @@ add_boundary_and_volume_optimization_constraints(const Boundary_data_vector& aBd
     H += lScaledBoundaryWeight * Hb;
     c = c + (lScaledBoundaryWeight * cb);
 
-    CGAL_SMS_LT_TRACE(2,"      H:" << matrix_to_string(H) << "\n      c:" << xyz_to_string(c));
+    CGAL_SMS_LT_TRACE(2, "      H:" << matrix_to_string(H) << "\n      c:" << xyz_to_string(c));
-    CGAL_SMS_LT_TRACE(2,"      VolW:" << mParams.VolumeWeight << " BdryW:" << mParams.BoundaryWeight << " ScaledBdryW:" << lScaledBoundaryWeight);
+    CGAL_SMS_LT_TRACE(2, "      VolW:" << mParams.VolumeWeight << " BdryW:" << mParams.BoundaryWeight << " ScaledBdryW:" << lScaledBoundaryWeight);
   }
 
   add_constraint_from_gradient(H,c);
@@ -498,14 +495,13 @@ add_shape_optimization_constraints(const vertex_descriptor_vector& aLink)
 {
   FT s(double(aLink.size()));
 
-  Matrix H (s, 0.0, 0.0,
+  Matrix H(s, 0.0, 0.0,
-            0.0, s, 0.0,
+           0.0, s, 0.0,
-            0.0, 0.0, s);
+           0.0, 0.0, s);
 
   Vector c = NULL_VECTOR;
-
+  for(const vertex_descriptor v : aLink)
-  for(typename vertex_descriptor_vector::const_iterator it = aLink.begin(), eit = aLink.end(); it != eit; ++it)
+    c = c + (ORIGIN - get_point(v));
-    c = c + (ORIGIN - get_point(*it));
 
   CGAL_SMS_LT_TRACE(1,"  Adding shape optimization constraint. Shape vector: " << xyz_to_string(c));
 
@@ -519,10 +515,10 @@ compute_boundary_cost(const Vector& v,
                       const Boundary_data_vector& aBdry)
 {
   FT rCost(0);
-  for(typename Boundary_data_vector::const_iterator it = aBdry.begin(); it != aBdry.end(); ++ it)
+  for(typename Boundary_data_vector::const_iterator it = aBdry.begin(); it != aBdry.end(); ++it)
   {
     Vector u = (it->t - ORIGIN) - v;
-    Vector c = cross_product(it->v,u);
+    Vector c = cross_product(it->v, u);
     rCost += c*c;
   }
 
@@ -537,11 +533,9 @@ compute_volume_cost(const Vector& v,
 {
   FT rCost(0);
 
-  for(typename Triangle_data_vector::const_iterator it = aTriangles.begin(), eit = aTriangles.end(); it != eit; ++it)
+  for(const Triangle_data& lTri : aTriangles)
   {
-    Triangle_data const& lTri = *it;
     FT lF = lTri.NormalV * v - lTri.NormalL;
-
     rCost += (lF * lF);
   }
 
@@ -555,9 +549,8 @@ compute_shape_cost(const Point& p,
                    const vertex_descriptor_vector& aLink)
 {
   FT rCost(0);
-
+  for(const vertex_descriptor v : aLink)
-  for(typename vertex_descriptor_vector::const_iterator it = aLink.begin(), eit = aLink.end(); it != eit; ++it)
+    rCost += squared_distance(p, get_point(v));
-    rCost += squared_distance(p,get_point(*it));
 
   return rCost;
 }
@@ -582,7 +575,7 @@ add_constraint_if_alpha_compatible(const Vector& Ai,
     {
       Vector Ain = Ai / l;
       FT bin = bi / l;
-      CGAL_SMS_LT_TRACE(3,"      Ain: " << xyz_to_string(Ain) << " bin:" << n_to_string(bin));
+      CGAL_SMS_LT_TRACE(3, "      Ain: " << xyz_to_string(Ain) << " bin:" << n_to_string(bin));
 
       bool lAddIt = true;
 
@@ -593,7 +586,8 @@ add_constraint_if_alpha_compatible(const Vector& Ai,
         FT sd01 = d01 * d01;
         FT max = sla0 * slai * mSquared_cos_alpha;
 
-        CGAL_SMS_LT_TRACE(3,"      Second constraint. d01: " << n_to_string(d01) << " sla0:" << n_to_string(sla0) << " sd01:" << n_to_string(sd01) << " max:" << n_to_string(max));
+        CGAL_SMS_LT_TRACE(3, "      Second constraint. d01: " << n_to_string(d01) << " sla0:" << n_to_string(sla0)
+                                                 << " sd01:" << n_to_string(sd01) << " max:" << n_to_string(max));
 
         if(sd01 > max)
           lAddIt = false;
@@ -603,13 +597,13 @@ add_constraint_if_alpha_compatible(const Vector& Ai,
         Vector N = cross_product(mConstraints_A.r0(),mConstraints_A.r1());
 
         FT dc012 = N * Ai;
-
         FT slc01 = N * N;
         FT sdc012 = dc012 * dc012;
 
         FT min = slc01 * slai * mSquared_sin_alpha;
 
-        CGAL_SMS_LT_TRACE(3, "      Third constraint. N: " << xyz_to_string(N) << " dc012:" << n_to_string(dc012) << " slc01:" << n_to_string(slc01)
+        CGAL_SMS_LT_TRACE(3, "      Third constraint. N: " << xyz_to_string(N)
+                               << " dc012:" << n_to_string(dc012) << " slc01:" << n_to_string(slc01)
                                << " sdc012:" << n_to_string(sdc012) << " min:" << n_to_string(min));
 
         if(sdc012 <= min)
@@ -634,28 +628,28 @@ add_constraint_if_alpha_compatible(const Vector& Ai,
             break;
         }
 
-        CGAL_SMS_LT_TRACE(3,"      Accepting # " << mConstraints_n << " A:" << matrix_to_string(mConstraints_A) << " b:" << xyz_to_string(mConstraints_b));
+        CGAL_SMS_LT_TRACE(3, "      Accepting # " << mConstraints_n << " A:" << matrix_to_string(mConstraints_A) << " b:" << xyz_to_string(mConstraints_b));
 
-        ++ mConstraints_n;
+        ++mConstraints_n;
       }
       else
       {
-        CGAL_SMS_LT_TRACE(3,"      INCOMPATIBLE. Discarded");
+        CGAL_SMS_LT_TRACE(3, "      INCOMPATIBLE. Discarded");
       }
     }
     else
     {
-      CGAL_SMS_LT_TRACE(3,"        l is ZERO. Discarded");
+      CGAL_SMS_LT_TRACE(3, "        l is ZERO. Discarded");
     }
   }
   else
   {
-    CGAL_SMS_LT_TRACE(3,"      OVERFLOW. Discarded");
+    CGAL_SMS_LT_TRACE(3, "      OVERFLOW. Discarded");
   }
 }
 
 template<class V>
-int index_of_max_component (V const& v)
+int index_of_max_component(const V& v)
 {
   typedef typename Kernel_traits<V>::Kernel::FT                     FT;
 
@@ -683,16 +677,16 @@ LindstromTurkCore<TM,K>::
 add_constraint_from_gradient(const Matrix& H,
                              const Vector& c)
 {
-  CGAL_SMS_LT_TRACE(3,"    Adding constraint from gradient. Current n=" << mConstraints_n);
+  CGAL_SMS_LT_TRACE(3, "    Adding constraint from gradient. Current n=" << mConstraints_n);
 
-  CGAL_precondition(mConstraints_n >= 0 && mConstraints_n<=2);
+  CGAL_precondition(mConstraints_n >= 0 && mConstraints_n <= 2);
 
   switch(mConstraints_n)
   {
     case 0:
-      add_constraint_if_alpha_compatible(H.r0(),-c.x());
+      add_constraint_if_alpha_compatible(H.r0(), -c.x());
-      add_constraint_if_alpha_compatible(H.r1(),-c.y());
+      add_constraint_if_alpha_compatible(H.r1(), -c.y());
-      add_constraint_if_alpha_compatible(H.r2(),-c.z());
+      add_constraint_if_alpha_compatible(H.r2(), -c.z());
       break;
     case 1:
     {
@@ -722,12 +716,11 @@ add_constraint_from_gradient(const Matrix& H,
           Q0 = NULL_VECTOR; // This should never happen!
       }
 
-      CGAL_SMS_LT_TRACE(3,"      Q0:" << xyz_to_string(Q0));
+      CGAL_SMS_LT_TRACE(3, "      Q0:" << xyz_to_string(Q0));
 
       CGAL_assertion(Q0 != NULL_VECTOR);
 
-      Vector Q1 = cross_product(A0,Q0);
+      Vector Q1 = cross_product(A0, Q0);
-
       Vector A1 = H * Q0;
       Vector A2 = H * Q1;
 
@@ -735,7 +728,7 @@ add_constraint_from_gradient(const Matrix& H,
       FT b2 = - (Q1 * c);
 
       CGAL_SMS_LT_TRACE(3, "      Q1:" << xyz_to_string(Q1) << "\n      A1: " << xyz_to_string(A1) << "\n      A2:" << xyz_to_string(A2)
-                            << "\n      b1:" << n_to_string(b1) << "\n      b2:" << n_to_string(b2));
+                             << "\n      b1:" << n_to_string(b1) << "\n      b2:" << n_to_string(b2));
 
       add_constraint_if_alpha_compatible(A1,b1);
       add_constraint_if_alpha_compatible(A2,b2);
@@ -747,7 +740,7 @@ add_constraint_from_gradient(const Matrix& H,
       Vector Q = cross_product(mConstraints_A.r0(),mConstraints_A.r1());
       Vector A2 = H * Q;
       FT b2 = - (Q * c);
-      CGAL_SMS_LT_TRACE(3,"      Q:" << xyz_to_string(Q) << "\n      A2: " << xyz_to_string(A2) << "\n      b2:" << n_to_string(b2));
+      CGAL_SMS_LT_TRACE(3, "      Q:" << xyz_to_string(Q) << "\n      A2: " << xyz_to_string(A2) << "\n      b2:" << n_to_string(b2));
 
       add_constraint_if_alpha_compatible(A2,b2);
     }

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_length_cost.h

@@ -44,6 +44,6 @@ public:
 };
 
 } // namespace Surface_mesh_simplification
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_EDGE_LENGHT_COST_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_length_stop_predicate.h

@@ -18,7 +18,7 @@
 // Author(s)     : Sebastien Loriot <sebastien.loriot@geometryfactory.com>
 //
 #ifndef CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_EDGE_LENGTH_STOP_PREDICATE_H
-#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_EDGE_LENGTH_STOP_PREDICATE_H 1
+#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_EDGE_LENGTH_STOP_PREDICATE_H
 
 #include <CGAL/license/Surface_mesh_simplification.h>
 #include <CGAL/squared_distance_3.h>
@@ -47,6 +47,6 @@ public:
 };
 
 } // namespace Surface_mesh_simplification
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_EDGE_LENGTH_STOP_PREDICATE_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_profile.h

@@ -352,6 +352,6 @@ extract_triangles_and_link()
 }
 
 } // namespace Surface_mesh_simplification
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_SURFACE_MESH_SIMPLIFICATION_DETAIL_EDGE_PROFILE_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_cost.h

@@ -34,7 +34,7 @@ class LindstromTurk_cost
 public:
   typedef TM_                                                                 TM;
 
-  LindstromTurk_cost(LindstromTurk_params const& aParams = LindstromTurk_params())
+  LindstromTurk_cost(const LindstromTurk_params& aParams = LindstromTurk_params())
     : mParams(aParams)
   {}
 
@@ -51,6 +51,6 @@ private:
 };
 
 } // namespace Surface_mesh_simplification
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_LINDSTROMTURK_COST_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_placement.h

@@ -18,7 +18,7 @@
 // Author(s)     : Fernando Cacciola <fernando.cacciola@geometryfactory.com>
 //
 #ifndef CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_LINDSTROMTURK_PLACEMENT_H
-#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_LINDSTROMTURK_PLACEMENT_H 1
+#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_LINDSTROMTURK_PLACEMENT_H
 
 #include <CGAL/license/Surface_mesh_simplification.h>
 
@@ -34,7 +34,7 @@ class LindstromTurk_placement
 public:
   typedef TM_                                                             TM;
 
-  LindstromTurk_placement(LindstromTurk_params const& aParams = LindstromTurk_params())
+  LindstromTurk_placement(const LindstromTurk_params& aParams = LindstromTurk_params())
     : mParams(aParams)
   {}
 
@@ -49,6 +49,6 @@ private:
 };
 
 } // namespace Surface_mesh_simplification
-} //namespace CGAL
+} // namespace CGAL
 
 #endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_LINDSTROMTURK_PLACEMENT_H

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Midpoint_placement.h

@@ -18,7 +18,7 @@
 // Author(s)     : Fernando Cacciola <fernando.cacciola@geometryfactory.com>
 //
 #ifndef CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_MIDPOINT_PLACEMENT_H
-#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_MIDPOINT_PLACEMENT_H 1
+#define CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_MIDPOINT_PLACEMENT_H
 
 #include <CGAL/license/Surface_mesh_simplification.h>
 
@@ -27,32 +27,24 @@
 #include <CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_profile.h>
 
 namespace CGAL {
+namespace Surface_mesh_simplification {
 
-namespace Surface_mesh_simplification
+template<class TM_>
-{
-
-  template<class TM_>
 class Midpoint_placement
 {
 public:
+  typedef TM_                                                     TM;
 
-  typedef TM_ TM;
+  Midpoint_placement() {}
-  
-  Midpoint_placement()
-  {}
 
   template <typename Profile>
   optional<typename Profile::Point> operator()(const Profile& aProfile) const
   {
-    return optional<typename Profile::Point> (midpoint(aProfile.p0(),aProfile.p1()));
+    return optional<typename Profile::Point>(midpoint(aProfile.p0(), aProfile.p1()));
   }
-
 };
 
 } // namespace Surface_mesh_simplification
+} // namespace CGAL
 
-} //namespace CGAL
+#endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_MIDPOINT_PLACEMENT_H
-
-#endif // CGAL_SURFACE_MESH_SIMPLIFICATION_POLICIES_EDGE_COLLAPSE_MIDPOINT_PLACEMENT_H //
-// EOF //
- 

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h

@@ -18,7 +18,7 @@
 // Author(s)     : Fernando Cacciola <fernando.cacciola@geometryfactory.com>
 //
 #ifndef CGAL_SURFACE_MESH_SIMPLIFICATION_EDGE_COLLAPSE_H
-#define CGAL_SURFACE_MESH_SIMPLIFICATION_EDGE_COLLAPSE_H 1
+#define CGAL_SURFACE_MESH_SIMPLIFICATION_EDGE_COLLAPSE_H
 
 #include <CGAL/license/Surface_mesh_simplification.h>
 
@@ -73,21 +73,21 @@ struct Dummy_visitor
   template<class Profile>
   void OnStopConditionReached(const Profile&) const {}
   template<class Profile, class OFT>
-  void OnCollected(Profile const&, const OFT&) const {}
+  void OnCollected(const Profile&, const OFT&) const {}
   template<class Profile, class OFT, class Size_type>
-  void OnSelected(Profile const&, const OFT&, Size_type, Size_type) const {}
+  void OnSelected(const Profile&, const OFT&, Size_type, Size_type) const {}
   template<class Profile, class OPoint>
   void OnCollapsing(const Profile&, const OPoint&) const {}
   template<class Profile, class VH>
   void OnCollapsed(const Profile&, VH) const {}
   template<class Profile>
-  void OnNonCollapsable(Profile const&) const {}
+  void OnNonCollapsable(const Profile&) const {}
 };
 
 template<class TM, class ShouldStop, class P, class T, class R>
 int edge_collapse(TM& aSurface,
                   const ShouldStop& aShould_stop,
-                  cgal_bgl_named_params<P,T,R> const& aParams)
+                  const cgal_bgl_named_params<P,T,R>& aParams)
 {
   using boost::choose_param;
   using boost::choose_const_pmap;
@@ -108,8 +108,8 @@ int edge_collapse(TM& aSurface,
 
 template<class TM, class ShouldStop, class GT, class P, class T, class R>
 int edge_collapse(TM& aSurface,
-                  ShouldStop const& aShould_stop,
+                  const ShouldStop& aShould_stop,
-                  cgal_bgl_named_params<P,T,R> const& aParams)
+                  const cgal_bgl_named_params<P,T,R>& aParams)
 {
   using boost::choose_param;
   using boost::choose_const_pmap;

Surface_mesh_simplification/test/Surface_mesh_simplification/test_edge_collapse_Polyhedron_3.cpp

@@ -81,7 +81,8 @@ protected:
     mMap.insert(make_pair(v->id(),mVIdx++));
   }
 
-  void add_triangle(Builder& aBuilder, Profile::Triangle const& aTri)
+  void add_triangle(Builder& aBuilder,
+                    const Profile::Triangle& aTri)
   {
     aBuilder.begin_facet();
     aBuilder.add_vertex_to_facet(mMap[aTri.v0->id()]);
@@ -204,12 +205,14 @@ void write (SurfaceSP aSurface, string aName)
 }
 
 template<class T>
-string opt2str (boost::optional<T> const& o)
+string opt2str (const boost::optional<T>& o)
 {
   ostringstream ss;
   if(o)
-       ss << *o; 
+    ss << *o;
-  else ss << "<none>";
+  else
+    ss << "<none>";
+
   return ss.str();
 }
 
@@ -220,13 +223,13 @@ string float2str (N n)
 }
 
 template<class P>
-string point2str (P const& p)
+string point2str (const P& p)
 {
   return boost::str(boost::format("(%+05.19g %+05.19g %+05.19g)") % to_double(p.x()) % to_double(p.y()) % to_double(p.z()));
 }
 
 template<class P>
-string optpoint2str (boost::optional<P> const& p)
+string optpoint2str (const boost::optional<P>& p)
 {
   ostringstream ss;
   if(p)
@@ -236,7 +239,7 @@ string optpoint2str (boost::optional<P> const& p)
   return ss.str();
 }
 template<class N>
-string optfloat2str (boost::optional<N> const& n)
+string optfloat2str (const boost::optional<N>& n)
 {
   ostringstream ss;
   if(n)
@@ -247,7 +250,7 @@ string optfloat2str (boost::optional<N> const& n)
 }
 
 template<class V>
-string vertex2str (V const& v)
+string vertex2str (const V& v)
 {
   ostringstream ss;
   ss << "[V" << v->id() << point2str(v->point()) << "]";
@@ -255,14 +258,14 @@ string vertex2str (V const& v)
 }
 
 template<class E>
-string edge2str (E const& e)
+string edge2str (const E& e)
 {
   ostringstream ss;
   ss << "{E" << e->id() << vertex2str(e->opposite()->vertex()) << "->" << vertex2str(e->vertex()) << "}";
   return ss.str();
 }
 
-template<class T> ostream&  operator << (ostream& os, boost::optional<T> const& o) { return os << opt2str(o); }
+template<class T> ostream&  operator << (ostream& os, const boost::optional<T>& o) { return os << opt2str(o); }
 
 string normalize_EOL (string line)
 {
@@ -308,19 +311,19 @@ public :
     CHECK(aSurface.is_valid());
   }
 
-  virtual void OnCollected(const Profile& aProfile, boost::optional<FT> const& aCost) const 
+  virtual void OnCollected(const Profile& aProfile, const boost::optional<FT>& aCost) const
   {
     TEST_TRACE(str (format("Collecting %1% : cost=%2%") % edge2str(aProfile.v0_v1()) % optfloat2str(aCost)));
   }
 
-  virtual void OnCollapsing(const Profile& aProfile, boost::optional<Point> const& aP) const 
+  virtual void OnCollapsing(const Profile& aProfile, const boost::optional<Point>& aP) const
   {
     TEST_TRACE(str (format("S %1% - Collapsing %2% : placement=%3%") % mStep % edge2str(aProfile.v0_v1()) % optpoint2str(aP)));
 
     //mBefore = create_edge_link(aProfile);
   }
 
-  virtual void OnCollapsed(const Profile& aProfile, Vertex_handle const& aV) const 
+  virtual void OnCollapsed(const Profile& aProfile, const Vertex_handle& aV) const
   {
     // Some collapse can result in self-intersections in any case, so we can't mark it as a failure
     if(false && Is_self_intersecting(aProfile.surface()))
@@ -333,7 +336,7 @@ public :
       REPORT_ERROR(str(format("Resulting surface self-intersects after step %1% (%2% edges left)") % mStep % (aProfile.surface().size_of_halfedges() / 2)));
     }
 
-    ++ mStep;
+    ++mStep;
   }
 
 private:
@@ -345,12 +348,10 @@ private:
       cerr << "  Assertion failed: " << pred << endl;
     cerr << "  " << msg << endl;
 
-     
     throw runtime_error("");
   }
 
 private:
-    
   string            mTestCase;
   mutable int       mStep;
   mutable SurfaceSP mBefore;
@@ -433,14 +434,13 @@ bool Test (string aName)
       cerr << "Unable to open test file " << aName << endl;
     }
   }
-  catch (std::exception const& x) 
+  catch (const std::exception& x)
   {
     string what(x.what());
     if(what.length() > 0)
       cerr << "Exception caught: " << what << endl;
   }
 
-  
   return rSucceeded;
 }
 
@@ -519,9 +519,4 @@ void postcondition_fail(const char* expr, const char* file, int line)
 }
 
 }
-
 #endif
-
-// EOF //
-
-

Surface_mesh_simplification/test/Surface_mesh_simplification/test_self_intersection.h

@@ -21,6 +21,7 @@ struct Intersect_facets
           || h->next()->opposite()->facet() == c->handle()
           || h->next()->next()->opposite()->facet() == c->handle())
         return;
+
     // check for shared vertex --> maybe intersection, maybe not
     Halfedge_const_handle g = c->handle()->halfedge();
     Halfedge_const_handle v;
@@ -48,6 +49,7 @@ struct Intersect_facets
                 v = g->next()->next();
         }
     }
+
     if(v != Halfedge_const_handle()) {
         // found shared vertex:
         assert(h->vertex() == v->vertex());
@@ -75,6 +77,7 @@ struct Intersect_facets
         }
         return;
     }
+
     // check for geometric intersection
     Triangle t1(h->vertex()->point(),
                   h->next()->vertex()->point(),
@@ -82,6 +85,7 @@ struct Intersect_facets
     Triangle t2(g->vertex()->point(),
                   g->next()->vertex()->point(),
                   g->next()->next()->vertex()->point());
+
     if(CGAL::do_intersect(t1, t2)) {
         //cerr << "Triangles intersect:\n    T1: " << t1 << "\n    T2 :"
         //     << t2 << endl;
@@ -91,8 +95,7 @@ struct Intersect_facets
   }
 };
 
-
+bool Is_self_intersecting(const Surface& s)
-bool Is_self_intersecting(Surface const& s) 
 {
   std::vector<Box> boxes;
   boxes.reserve(s.size_of_facets());