Zero-weight 2D weighted straight skeletons

GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h

@@ -54,8 +54,8 @@
 #include <CGAL/Random.h>
 #include <CGAL/assertions.h>
 
-#define CGAL_BASIC_VIEWER_INIT_SIZE_X 500
-#define CGAL_BASIC_VIEWER_INIT_SIZE_Y 450
+#define CGAL_BASIC_VIEWER_INIT_SIZE_X 1500
+#define CGAL_BASIC_VIEWER_INIT_SIZE_Y 1500
 
 namespace CGAL
 {

Straight_skeleton_2/doc/Straight_skeleton_2/CGAL/extrude_skeleton.h

@@ -5,18 +5,21 @@ namespace CGAL {
 *
 * \brief constructs the straight skeleton-based extrusion of a polygon with holes.
 *
-* Given a polygon with holes and a set of weights, the skeleton extrusion is a volume constructed
-* from the weighted straight skeleton by associating a height to the vertices of the skeleton,
-* which corresponds to the time at the vertex. The input polygon is placed at `z = 0`.
-*
-* This function allows cropping the extruded skeleton at a maximum height, using the optional
-* `maximum_height()` named parameter.
+* Given a polygon with holes and a set of weights (or angles) associated to its edges,
+* the skeleton extrusion is a volume constructed from the weighted straight skeleton
+* by associating a height to the vertices of the skeleton, which corresponds to the time
+* at the vertex. The input polygon is placed at `z = 0`.
 *
 * The result is a closed, 2-manifold surface triangle mesh. Note that this mesh can have non-local
 * self-intersections if a maximal height is provided due to possible (geometric) non-manifold occurences.
 *
-* @tparam PolygonWithHoles must be a model of `SequenceContainer` with value type `InK::Point_2` (e.g. `Polygon_2<InK>`)
-                           or a model of `GeneralPolygonWithHoles_2` (e.g. `Polygon_with_holes_2<InK>`).
+* It is possible to crop the extruded skeleton at a maximum height using the optional
+* `maximum_height()` named parameter. A maximum height must be specified if the weights (or angles)
+* associated to the edges of the input polygon correspond an outward extrusion, i.e. if no weight
+* is greater than zero (or no angle is smaller than `90` degrees).
+*
+* @tparam Polygon must be a model of `SequenceContainer` with value type `InK::Point_2` (e.g. `Polygon_2<InK>`)
+                  or a model of `GeneralPolygonWithHoles_2` (e.g. `Polygon_with_holes_2<InK>`).
 * @tparam PolygonMesh a model of `MutableFaceGraph`
 * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
 *
@@ -42,7 +45,7 @@ namespace CGAL {
 *     \cgalParamType{a model of `Range` whose value type is a model of `Range` whose value type is `FT`}
 *     \cgalParamDefault{an empty range (uniform weights are used)}
 *     \cgalParamExtra{Angles are measured in degrees and should be strictly within `0` and `180` degrees
-*                     and should be eitger all acute (inward extrusion) or all obtuse (outward extrusion).}
+*                     and should be either all acute (inward extrusion) or all obtuse (outward extrusion).}
 *     \cgalParamExtra{This parameter is ignored if the `weights` parameter is provided.}
 *     \cgalParamExtra{The conversion to weights involves trigonometry and will be inexact,
 *                     even when using a number type with exact square roots.}

Straight_skeleton_2/doc/Straight_skeleton_2/Straight_skeleton_2.txt

@@ -142,14 +142,14 @@ The main entry points for straight skeletons are the following functions:
 \subsection Straight_skeleton_2Weights Weighted Straight Skeletons
 
 Weighted straight skeletons are a generalization of straight skeletons: contour edges are assigned
-a positive weight, which can be understood as assigning a speed to the wavefront spawned from
+a weight, which can be understood as assigning a speed to the wavefront spawned from
 the contour edge. Vertices no longer move along the angular bisector between two contour edges, but
 along a weighted bisector.
 
-This \cgal package supports positive multiplicative weights: if the supporting line of a contour edge
+This \cgal package supports multiplicative weights: if the supporting line of a contour edge
 is described through the equation `ax+by+c=0` then the supporting line of the offset edge
-at distance `t` is `ax+by+c-t=0`. With a multiplicative weight `w`, the equation becomes `w(ax+by+c)-t=0`.
-Therefore, a larger weight implies a faster moving front.
+at distance `t` is `ax+by+c-t=0`. With a multiplicative weight `w`, the equation becomes `ax+by+c-w*t=0`.
+Therefore, a larger weight implies a slower moving front.
 
 \cgalFigureAnchor{SLSWeight}
 <center>
@@ -282,7 +282,7 @@ to its offset distance, the resulting roof is "correct" in that water will alway
 to the contour edges (the roof's border), regardless of where it falls on the roof.
 Laycock and Day \cgalCite{cgal:ld-agrm-03} give an algorithm for roof design based on the straight skeleton.
 
-This \cgal package implements skeleton extrusion for polygons with holes, with support for positive
+This \cgal package implements skeleton extrusion for polygons with holes, with support for
 multiplicative weights. The output is a closed, combinatorially 2-manifold surface triangle mesh.
 
 \cgalFigureAnchor{SLSExtrusion}

Straight_skeleton_2/examples/Straight_skeleton_2/Create_straight_skeleton_2.cpp

@@ -1,24 +1,51 @@
+#define CGAL_SLS_DEBUG_DRAW
+
+#include <iostream>
+#include <iomanip>
+#include <string>
+
+#define CGAL_SLS_PRINT_QUEUE_BEFORE_EACH_POP
+#define CGAL_STRAIGHT_SKELETON_ENABLE_TRACE 10000000
+#define CGAL_STRAIGHT_SKELETON_TRAITS_ENABLE_TRACE 10000000
+#define CGAL_STRAIGHT_SKELETON_VALIDITY_ENABLE_TRACE
+#define CGAL_POLYGON_OFFSET_ENABLE_TRACE 10000000
+
+void Straight_skeleton_external_trace(std::string m)
+{
+  std::cout << std::setprecision(17) << m << std::endl << std::endl ;
+}
+
+void Straight_skeleton_traits_external_trace(std::string m)
+{
+  std::cout << std::setprecision(17) << m << std::endl << std::endl ;
+}
+
+
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 
+#include <CGAL/draw_polygon_2.h>
+#include <CGAL/draw_straight_skeleton_2.h>
 #include <CGAL/Polygon_2.h>
 #include <CGAL/create_straight_skeleton_2.h>
+#include <CGAL/create_weighted_straight_skeleton_2.h>
 #include <CGAL/Straight_skeleton_2/IO/print.h>
-#include <CGAL/draw_straight_skeleton_2.h>
 
 #include <boost/shared_ptr.hpp>
 
 #include <cassert>
 
 typedef CGAL::Exact_predicates_inexact_constructions_kernel K ;
 
+typedef K::FT                        FT ;
 typedef K::Point_2                   Point ;
 typedef CGAL::Polygon_2<K>           Polygon_2 ;
-typedef CGAL::Straight_skeleton_2<K> Ss ;
 
-typedef boost::shared_ptr<Ss> SsPtr ;
+typedef CGAL::Straight_skeleton_2<K> Ss ;
+typedef boost::shared_ptr<Ss>        SsPtr ;
 
 int main()
 {
+#if 0
   Polygon_2 poly ;
   poly.push_back( Point(-1,-1) ) ;
   poly.push_back( Point(0,-12) ) ;
@@ -30,6 +57,7 @@ int main()
   poly.push_back( Point(-12,0) ) ;
 
   assert(poly.is_counterclockwise_oriented());
+  CGAL::draw(poly);
 
   // You can pass the polygon via an iterator pair
   SsPtr iss = CGAL::create_interior_straight_skeleton_2(poly.vertices_begin(), poly.vertices_end());
@@ -45,6 +73,21 @@ int main()
 
   CGAL::Straight_skeletons_2::IO::print_straight_skeleton(*oss);
   CGAL::draw(*oss);
+#else
+  Polygon_2 poly ;
+  poly.push_back( Point(0, 0) );
+  // poly.push_back( Point(5, 0) );
+  poly.push_back( Point(10, 0) );
+  poly.push_back( Point(10, 10) );
+  poly.push_back( Point(0, 10) );
+
+  // You can also use weights to modify the speed of some of the fronts
+  std::vector<FT> weights = {{ 3, 5, 6, 7 }};
+  SsPtr iss = CGAL::create_interior_weighted_straight_skeleton_2(poly.vertices_begin(), poly.vertices_end(),
+                                                                 weights.begin(), weights.end());
+  CGAL::Straight_skeletons_2::IO::print_straight_skeleton(*iss);
+  CGAL::draw(*iss);
+#endif
 
   return EXIT_SUCCESS;
 }

Straight_skeleton_2/examples/Straight_skeleton_2/extrude_skeleton.cpp

@@ -1,3 +1,25 @@
+#define CGAL_SLS_DEBUG_DRAW
+
+#include <iostream>
+#include <iomanip>
+#include <string>
+
+#define CGAL_SLS_PRINT_QUEUE_BEFORE_EACH_POP
+#define CGAL_STRAIGHT_SKELETON_ENABLE_TRACE 10000000
+#define CGAL_STRAIGHT_SKELETON_TRAITS_ENABLE_TRACE 10000000
+#define CGAL_STRAIGHT_SKELETON_VALIDITY_ENABLE_TRACE
+#define CGAL_POLYGON_OFFSET_ENABLE_TRACE 10000000
+
+void Straight_skeleton_external_trace(std::string m)
+{
+  std::cout << std::setprecision(17) << m << std::endl << std::endl ;
+}
+
+void Straight_skeleton_traits_external_trace(std::string m)
+{
+  std::cout << std::setprecision(17) << m << std::endl << std::endl ;
+}
+
 #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>
 #include <CGAL/Exact_predicates_exact_constructions_kernel_with_sqrt.h>
@@ -170,16 +192,17 @@ int main(int argc, char** argv)
 
   Mesh sm;
   if(use_angles)
-    CGAL::extrude_skeleton(pwh, sm, CGAL::parameters::angles(speeds).maximum_height(height));
+    CGAL::extrude_skeleton(pwh, sm, CGAL::parameters::angles(speeds).maximum_height(height).verbose(true));
   else
-    CGAL::extrude_skeleton(pwh, sm, CGAL::parameters::weights(speeds).maximum_height(height));
+    CGAL::extrude_skeleton(pwh, sm, CGAL::parameters::weights(speeds).maximum_height(height).verbose(true));
 
   timer.stop();
   std::cout << "Extrusion computation took " << timer.time() << " s." << std::endl;
-
-  CGAL::draw(sm);
+  std::cout << num_vertices(sm) << " vertices, " << num_faces(sm) << " faces" << std::endl;
 
   CGAL::IO::write_polygon_mesh("extruded_skeleton.off", sm, CGAL::parameters::stream_precision(17));
 
+  CGAL::draw(sm);
+
   return EXIT_SUCCESS;
 }

Straight_skeleton_2/include/CGAL/Straight_skeleton_2/IO/print.h

@@ -31,7 +31,9 @@ template<class HDS_V>
 void print_vertex ( HDS_V const& v )
 {
   if(v->has_infinite_time())
-    std::cout << "F" << v->id() << " " ;
+    std::cout << "FN" << v->id() << " " ;
+  else if (v->is_contour())
+    std::cout << "CN" << v->id() << " " ;
   else
     std::cout << "N" << v->id() << " " ;
 }
@@ -92,6 +94,7 @@ void print_straight_skeleton( CGAL::Straight_skeleton_2<K> const& ss )
   typedef CGAL::Straight_skeleton_2<K> Ss ;
 
   typedef typename Ss::Vertex_const_handle     Vertex_const_handle ;
+  typedef typename Ss::Vertex_const_iterator   Vertex_const_iterator ;
   typedef typename Ss::Halfedge_const_handle   Halfedge_const_handle ;
   typedef typename Ss::Halfedge_const_iterator Halfedge_const_iterator ;
 
@@ -103,6 +106,32 @@ void print_straight_skeleton( CGAL::Straight_skeleton_2<K> const& ss )
             << " halfedges and " << ss.size_of_faces()
             << " faces" << std::endl ;
 
+  std::cout << "All vertices: " << std::endl;
+  for ( Vertex_const_iterator v = ss.vertices_begin(); v != ss.vertices_end(); ++v )
+  {
+    print_vertex(v);
+    std::cout << "@ " << v->time() << std::endl;
+  }
+
+  std::cout << "All halfedges: " << std::endl;
+
+  for ( Halfedge_const_iterator h = ss.halfedges_begin(); h != ss.halfedges_end(); ++h )
+  {
+    if(h->is_inner_bisector())
+      std::cout << "IBH" << h->id() << " " << std::flush ;
+    else if(h->is_bisector())
+      std::cout << "BH" << h->id() << " " << std::flush ;
+    else
+      std::cout << "CH" << h->id() << " " << std::flush ;
+
+    print_vertex(h->prev()->vertex()) ;
+    print_point(h->prev()->vertex()->point()) ;
+    std::cout << " ==> " << std::flush ;
+    print_vertex(h->vertex());
+    print_point(h->vertex()->point()) ;
+    std::cout << std::endl;
+  }
+
   std::cout << "Faces " << std::endl;
   for ( Halfedge_const_iterator h = ss.halfedges_begin(); h != ss.halfedges_end(); ++h )
   {
@@ -131,24 +160,6 @@ void print_straight_skeleton( CGAL::Straight_skeleton_2<K> const& ss )
     std::cout << std::endl;
   }
 
-  std::cout << "All halfedges: " << std::endl;
-
-  for ( Halfedge_const_iterator h = ss.halfedges_begin(); h != ss.halfedges_end(); ++h )
-  {
-    if(h->is_inner_bisector())
-      std::cout << "IBH" << h->id() << " " << std::flush ;
-    else if(h->is_bisector())
-      std::cout << "BH" << h->id() << " " << std::flush ;
-    else
-      std::cout << "CH" << h->id() << " " << std::flush ;
-
-    print_vertex(h->prev()->vertex()) ;
-    print_point(h->prev()->vertex()->point()) ;
-    std::cout << " ==> " << std::flush ;
-    print_vertex(h->vertex());
-    print_point(h->vertex()->point()) ;
-    std::cout << std::endl;
-  }
 }
 
 } // namespace IO

Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_aux.h

@@ -128,9 +128,9 @@ class Triedge
   {
     ss << "{E" ;
     insert_handle_id(ss,t.e0())  ;
-    ss << ",E" ;
+    ss << " E" ;
     insert_handle_id(ss,t.e1()) ;
-    ss << ",E" ;
+    ss << " E" ;
     insert_handle_id(ss,t.e2()) ;
     ss << "}" ;
     return ss ;

Straight_skeleton_2/include/CGAL/Straight_skeleton_2/Straight_skeleton_builder_2_impl.h

@@ -106,8 +106,7 @@ Straight_skeleton_builder_2<Gt,Ss,V>::FindEdgeEvent( Vertex_handle aLNode,
   {
     Trisegment_2_ptr lTrisegment = CreateTrisegment(lTriedge,aLNode,aRNode);
 
-    CGAL_STSKEL_BUILDER_TRACE(4, "\n[] Considering E" << lTrisegment->e0().mID << " E" << lTrisegment->e1().mID << " E" << lTrisegment->e2().mID
-                                << " Collinearity: " << trisegment_collinearity_to_string(lTrisegment->collinearity()) ) ;
+    CGAL_STSKEL_BUILDER_TRACE(4, "\nConsidering " << lTrisegment ) ;
 
     // The 02 collinearity configuration is problematic: 01 or 12 collinearity has a seed position
     // giving the point through which the bisector passes. However, for 02, it is not a given.
@@ -362,9 +361,9 @@ void Straight_skeleton_builder_2<Gt,Ss,V>::CollectNewEvents( Vertex_handle aNode
     CollectSplitEvents(aNode, aPrevEventTriedge) ;
 
   EventPtr lLEdgeEvent = FindEdgeEvent( lPrev , aNode, aPrevEventTriedge ) ;
-  CGAL_STSKEL_BUILDER_TRACE(2, "Done Left " << (lLEdgeEvent ? "Found" : "Not Found"));
+  CGAL_STSKEL_BUILDER_TRACE(2, "Done; Edge Event on the Left: " << (lLEdgeEvent ? "Found" : "Not Found"));
   EventPtr lREdgeEvent = FindEdgeEvent( aNode , lNext, aPrevEventTriedge ) ;
-  CGAL_STSKEL_BUILDER_TRACE(2, "Done Right " << (lREdgeEvent ? "Found" : "Not Found"));
+  CGAL_STSKEL_BUILDER_TRACE(2, "Done; Edge Event on the Right: " << (lREdgeEvent ? "Found" : "Not Found"));
 
   bool lAcceptL = !!lLEdgeEvent ;
   bool lAcceptR = !!lREdgeEvent ;
@@ -672,8 +671,9 @@ void Straight_skeleton_builder_2<Gt,Ss,V>::HarmonizeSpeeds(boost::mpl::bool_<tru
     {
       if ( K().orientation_2_object()(lLH->vertex()->point(),
                                       lLH->opposite()->vertex()->point(),
-                                      lRH->vertex()->point()) == EQUAL )
+                                      lRH->vertex()->point()) == EQUAL ) {
         return false; // collinear
+      }
 
       // parallel but not collinear, order arbitrarily (but consistently)
       return K().less_xy_2_object()(lLH->vertex()->point(), lRH->vertex()->point()) ;
@@ -699,6 +699,9 @@ void Straight_skeleton_builder_2<Gt,Ss,V>::HarmonizeSpeeds(boost::mpl::bool_<tru
     {
       CGAL_STSKEL_BUILDER_TRACE(4, "Harmonize " << lBorder->id() << " with " << (*lRes.first)->id() ) ;
       mTraits.InitializeLineCoeffs(lBorder->id(), (*lRes.first)->id());
+      if(lBorder->weight() != (*lRes.first)->weight()) {
+        throw std::runtime_error("Collinear input edges must have the same weight");
+      }
     }
     else
     {
@@ -801,7 +804,7 @@ Straight_skeleton_builder_2<Gt,Ss,V>::LookupOnSLAV ( Halfedge_handle aBorder, Ev
 
           CGAL_STSKEL_BUILDER_TRACE ( 3, "Split point found at the "
                                     << ( rSite == AT_SOURCE ? "SOURCE vertex" : ( rSite == AT_TARGET ? "TARGET vertex" : "strict inside" ) )
-                                    << " of the offset edge " << vh2str(lPrevN) << " " << vh2str(v)
+                                    << " of the offset edge " << vh2str(lPrevN) << " -- " << vh2str(v)
                                     ) ;
           break ;
         }
@@ -1578,7 +1581,7 @@ void Straight_skeleton_builder_2<Gt,Ss,V>::Propagate()
       {
         EventPtr event = mpq.top();
         mpq.pop();
-        CGAL_STSKEL_BUILDER_TRACE(4, *event);
+        CGAL_STSKEL_BUILDER_TRACE(4, "MPQ Event: " << *event);
       }
       CGAL_STSKEL_BUILDER_TRACE(4, "END MAIN QUEUE --------------------------------------------- ");
 #endif
@@ -1606,13 +1609,18 @@ void Straight_skeleton_builder_2<Gt,Ss,V>::Propagate()
         }
 
         ++ mStepID ;
+
+        CGAL::draw(*mSSkel);
       }
       else
       {
         CGAL_STSKEL_BUILDER_TRACE (3,"\nAlready processed") ;
       }
     }
-    else break ;
+    else
+    {
+      break ;
+    }
   }
 
   mVisitor.on_propagation_finished();
@@ -2410,6 +2418,8 @@ bool Straight_skeleton_builder_2<Gt,Ss,V>::FinishUp()
 
   mVisitor.on_cleanup_started();
 
+  CGAL::draw(*mSSkel);
+
   std::for_each( mSplitNodes.begin()
                 ,mSplitNodes.end  ()
                 ,[this](Vertex_handle_pair p){ this->MergeSplitNodes(p); }
@@ -2433,6 +2443,8 @@ bool Straight_skeleton_builder_2<Gt,Ss,V>::FinishUp()
 
   mVisitor.on_cleanup_finished();
 
+  CGAL::draw(*mSSkel);
+
   // If 'mMaxTime' is sufficiently large, it will be a full skeleton and could be validated as such...
   if(mMaxTime) // might be a partial skeleton
     return mSSkel->is_valid(true);