dxfngc

@@ -8,8 +8,8 @@

 #include <vector>

 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>

+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>

 #include <CGAL/Gmpq.h>

-#include <CGAL/number_utils.h>

 #include <CGAL/Polygon_2.h>

 #include <CGAL/Polygon_with_holes_2.h>

 #include <CGAL/Boolean_set_operations_2.h>

@@ -38,6 +38,9 @@ void Polygons::clear()

 bool Polygons::addLayer(const Layer &layer, double eqDist)

 {

   // convert all paths to simple polygons

+  // once using exact construction kernel (needed by intersection, difference)

+  // once using inexact construction kernel (faster offsetting)

+  CgExPolyVec simplesEx;

   CgPolyVec simples;

   Layer::Paths::const_iterator path;

   for (path = layer.mPaths.begin(); path != layer.mPaths.end(); ++path) {

@@ -54,12 +57,15 @@ bool Polygons::addLayer(const Layer &layer, double eqDist)

     }

     // create simple polygon from path

     //   - do not add last point to polygon, as it is the same as the first one

+    CgExPoly simpleEx;

     CgPoly simple;

     Path::Points::const_iterator pt;

-    for (pt = path->mPoints.begin(); pt + 1 != path->mPoints.end(); ++pt)

+    for (pt = path->mPoints.begin(); pt + 1 != path->mPoints.end(); ++pt) {

+      simpleEx.push_back(CgExPoint(pt->mX, pt->mY));

       simple.push_back(CgPoint(pt->mX, pt->mY));

+    }

     // check that polygon is simple

-    if (!simple.is_simple()) {

+    if (!simpleEx.is_simple()) {

       std::cerr << "path is not simple (maybe self-itersecting?)" << std::endl;

       Path::Points::const_iterator pt;

       for (pt = path->mPoints.begin(); pt != path->mPoints.end(); ++pt)

@@ -67,9 +73,12 @@ bool Polygons::addLayer(const Layer &layer, double eqDist)

       return false;

     }

     // ensure orientation is clockwise (must be the same for all polygons)

-    if (simple.is_clockwise_oriented())

+    if (simpleEx.is_clockwise_oriented()) {

+      simpleEx.reverse_orientation();

       simple.reverse_orientation();

+    }

     // collect polygons

+    simplesEx.push_back(simpleEx);

     simples.push_back(simple);

   } // for path

@@ -77,17 +86,17 @@ bool Polygons::addLayer(const Layer &layer, double eqDist)

   // deterine which polygon is contained in which one

   std::vector<ssize_t> contained_in; // idx: contained poly, val: containing poly

   ssize_t ia, ib;

-  CgPolyVec::const_iterator a, b;

-  for (a = simples.begin(); a != simples.end(); ++a)

+  CgExPolyVec::const_iterator a, b;

+  for (a = simplesEx.begin(); a != simplesEx.end(); ++a)

     contained_in.push_back(-1); // not contained in any polygon

-  for (a = simples.begin(), ia = 0; a != simples.end(); ++a, ++ia) {

+  for (a = simplesEx.begin(), ia = 0; a != simplesEx.end(); ++a, ++ia) {

     b = a;

     ib = ia;

-    for (++b, ++ib; b != simples.end(); ++b, ++ib) {

+    for (++b, ++ib; b != simplesEx.end(); ++b, ++ib) {

       // A and B intersect each other

       if (CGAL::do_intersect(*a, *b)) {

         // compute differences A - B and B - A

-        CgPolyHolesVec a_b, b_a;

+        CgExPolyHolesVec a_b, b_a;

         CGAL::difference(*a, *b, std::back_inserter(a_b));

         CGAL::difference(*b, *a, std::back_inserter(b_a));

         if (a_b.empty()) {

@@ -181,10 +190,9 @@ bool Polygons::createInnerOffset(double offset, Polygons &offsetPolys) const

   for (poly = mPolys.begin(); poly != mPolys.end(); ++poly) {

     // create inner offset polygons

-    CGAL::Lazy_exact_nt<CGAL::Gmpq> offs(offset);

     CgPolyHolesPtrVec offPolys =

       CGAL::create_interior_skeleton_and_offset_polygons_with_holes_2(

-        offs, *poly);

+        offset, *poly);

     // add offset polygons to output polygons

     CgPolyHolesPtrVec::const_iterator offPoly;

@@ -250,9 +258,8 @@ bool Polygons::fillInnerOffset(double offset, Polygons &offsetPolys) const

     for (i = 1; ; ++i) {

       // create inner offset polygons

-      CGAL::Lazy_exact_nt<CGAL::Gmpq> offs_i(offset * i);

       CgPolyPtrVec offPolys =

-        CGAL::create_offset_polygons_2<CgPoly>(offs_i, *skel);

+        CGAL::create_offset_polygons_2<CgPoly>(offset * i, *skel);

       // no offset polygons -> done

       if (offPolys.empty())

@@ -302,12 +309,10 @@ bool Polygons::createOuterOffsetPoly(const CgPolyHoles &poly, double offset,

                                      CgPolyHoles &offsetPoly)

 {

   // calculate outer offset of outer bondary

-  CGAL::Lazy_exact_nt<CGAL::Gmpq> offs(offset);

   const CgPoly &outer = poly.outer_boundary();

-  CgKern kern;

   CgPolyPtrVec outOffPolys =

     CGAL::create_exterior_skeleton_and_offset_polygons_2(

-      offs, outer, kern, kern);

+      offset, outer);

   /* outer Offset should now contain 2 polygons,

      the artificially added very outer boundary and the offset polygon */

   if (outOffPolys.size() != 2) {

@@ -323,7 +328,7 @@ bool Polygons::createOuterOffsetPoly(const CgPolyHoles &poly, double offset,

     holeRev.reverse_orientation();

     CgPolyPtrVec inOffPolys =

       CGAL::create_interior_skeleton_and_offset_polygons_2(

-        offs, holeRev, kern, kern);

+        offset, holeRev);

     CgPolyPtrVec::iterator inOff; // add inner offset polys as new holes

     for (inOff = inOffPolys.begin(); inOff != inOffPolys.end(); ++inOff) {

       (*inOff)->reverse_orientation(); // re-reverse (make poly a hole again)

@@ -10,6 +10,7 @@

 #include <vector>

 #include <CGAL/Exact_predicates_exact_constructions_kernel.h>

+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>

 #include <CGAL/Polygon_2.h>

 #include <CGAL/Polygon_with_holes_2.h>

 #include <CGAL/create_straight_skeleton_from_polygon_with_holes_2.h>

@@ -19,16 +20,24 @@

 /// a set of polygons

 class Polygons {

 public:

-  typedef CGAL::Exact_predicates_exact_constructions_kernel CgKern;

+  typedef CGAL::Exact_predicates_exact_constructions_kernel   CgExKern;

+

+  typedef CgExKern::Point_2                    CgExPoint;

+  typedef CGAL::Polygon_2<CgExKern>            CgExPoly;

+  typedef std::vector<CgExPoly>                CgExPolyVec;

+  typedef CGAL::Polygon_with_holes_2<CgExKern> CgExPolyHoles;

+  typedef std::vector<CgExPolyHoles>           CgExPolyHolesVec;

+

+  typedef CGAL::Exact_predicates_inexact_constructions_kernel CgKern;

   typedef CgKern::Point_2                    CgPoint;

   typedef CGAL::Polygon_2<CgKern>            CgPoly;

   typedef CGAL::Polygon_with_holes_2<CgKern> CgPolyHoles;

-  typedef CGAL::Straight_skeleton_2<CgKern>  CgSs;

   typedef std::vector<CgPoly>                CgPolyVec;

   typedef std::vector<CgPolyHoles>           CgPolyHolesVec;

   typedef boost::shared_ptr<CgPoly>          CgPolyPtr;

   typedef boost::shared_ptr<CgPolyHoles>     CgPolyHolesPtr;

+  typedef CGAL::Straight_skeleton_2<CgKern>  CgSs;

   typedef boost::shared_ptr<CgSs>            CgSsPtr;

   typedef std::vector<CgPolyPtr>             CgPolyPtrVec;

   typedef std::vector<CgPolyHolesPtr>        CgPolyHolesPtrVec;