Ticket #6063: boost_polygon_bug6063_diffForBoost1_49_0.patch

detail/minkowski.hpp

@@ -82 +82 @@
 }
   template<typename T>
   inline polygon_set_data<T>&
-  polygon_set_data<T>::resize(coordinate_type resizing, bool corner_fill_arc, unsigned int num_circle_segments) {
+  polygon_set_data<T>::resize(coordinate_type resizing, bool corner_fill_arc, unsigned int num_circle_segments,
+                              double min_unrounded_angle_degrees) {
     using namespace ::boost::polygon::operators;
-    if(!corner_fill_arc) {
+    if(resizing == 0) return *this;
+    if(empty()) return *this;
+    if(!corner_fill_arc || min_unrounded_angle_degrees<=0.0) {
       if(resizing < 0)
         return shrink(-resizing);
-      if(resizing > 0)
+      else
         return bloat(resizing);
       return *this;
     }
-    if(resizing == 0) return *this;
-    if(empty()) return *this;
+
     if(num_circle_segments < 3) num_circle_segments = 4;
     rectangle_data<coordinate_type> rect;
     extents(rect);
@@ -100 +102 @@
       ::boost::polygon::bloat(rect, 10);
       (*this) = rect - (*this); //invert
     }
-    //make_arc(std::vector<point_data< T> >& return_points,  
-    //point_data< double> start, point_data< double>  end,
-    //point_data< double> center,  double r, unsigned int num_circle_segments)      
+    // scale arc up so that minimum radius corresponds to 'resizing',
+    // for bug ticket #6063.
+    const double our_pi=3.1415926535897932384626433832795028841971;
+    double arcRadScaling = 1.0/cos(our_pi/double(num_circle_segments));
+    double arcRadius = double(std::abs(resizing))*arcRadScaling;
+
+    if(min_unrounded_angle_degrees < 180.0)
+    {
+        // Don't round corners less than given angle (in radians).
+        // We do this by setting the minimum radius of the 'circle' to correspond to
+        // the distance to the 'elbow' created by normal offset of a corner with the given angle.
+        // e.g. an 90-degree corner with an offset of 1 will generate an elbow-corner at distance sqrt(2),
+        // so if \param min_unrounded_angle_degrees=90, we set the circle radius to offset*sqrt(2)*arcRadScaling.
+        // This will of course offset non-corners more than the given resizing, but the extra area
+        // gets chopped off by the intersection with normal_offset_result, below.
+        double elbowDist = double(std::abs(resizing))/sin(min_unrounded_angle_degrees*our_pi/180.0/2.0);
+        arcRadius = elbowDist*arcRadScaling;
+    }
+
+    // Note: By setting round_away_from_center=true, we make a 'circle polygon' here that is actually the result of
+    // calling round_away<coordinate_type>(pt, center) on the vertices of a circle polygon.
+    // Previously (see bug ticket #6063) we were using round_down instead of round_away, with the result that
+    // the elbowDist and arcRadScaling above were sometimes insufficient to avoid rounding corners
+    // with angle >= min_unrounded_angle_degrees, due to integer precision.
+    bool round_away_from_center = true;
+
     std::vector<point_data<coordinate_type> > circle;
-    point_data<double> center(0.0, 0.0), start(0.0, (double)resizing);
-    make_arc(circle, start, start, center, std::abs((double)resizing),
-             num_circle_segments);
+    point_data<double> center(0.0, 0.0), start(0.0, arcRadius);
+    make_arc(circle, start, start, center, arcRadius, num_circle_segments, round_away_from_center);
+
     polygon_data<coordinate_type> poly;
     set_points(poly, circle.begin(), circle.end());
     polygon_set_data<coordinate_type> offset_set;
@@ -114 +139 @@
     polygon_set_data<coordinate_type> result;
     detail::minkowski_offset<coordinate_type>::convolve_two_polygon_sets
       (result, *this, offset_set);
+
+    // Intersect with result of 'normal' (non-minkowski-sum) offset,
+    // to remove offsets larger than the given 'resizing' when not near corners.
+    // Also for bug ticket #6063
+    polygon_set_data<coordinate_type> normal_offset_result(*this);
+    normal_offset_result.bloat(std::abs(resizing));
+    result = result & normal_offset_result;
+
     if(resizing < 0) {
       result = result & rect;//eliminate overhang
       result = result ^ rect;//invert
     }
+
     *this = result;
     return *this;
   }

polygon_set_data.hpp

@@ -27 +27 @@
      return rounded_val;
   }
   template <typename T>
-  static inline point_data<T> round_down(point_data<double> v) {
+  static inline point_data<T> round_down(const point_data<double> & v) {
      return point_data<T>(round_down<T>(v.x()),round_down<T>(v.y()));
   }
 
-
+  // utility function to round coordinate types away from another value.
+  // intended really for integer type T (does not make sense for float)
+  template <typename T>
+  static inline T round_away(double val, double center) {
+     T rounded_val = (T)(val);
+     if(val <= center)
+     {
+         // round down
+         if(val < (double)rounded_val)
+             --rounded_val;
+     }
+     else
+     {
+         // round up
+         if(val > (double)rounded_val)
+             ++rounded_val;
+     }
+     return rounded_val;
+  }
+  template <typename T>
+  static inline point_data<T> round_away(const point_data<double> &v, const point_data<double> &center) {
+     return point_data<T>(round_away<T>(v.x(),center.x()), round_away<T>(v.y(),center.y()));
+  }
 
   //foward declare view
   template <typename ltype, typename rtype, int op_type> class polygon_set_view;
@@ -359 +381 @@
     }
 
     inline polygon_set_data&
-    resize(coordinate_type resizing, bool corner_fill_arc = false, unsigned int num_circle_segments=0);
+    resize(coordinate_type resizing, bool corner_fill_arc = false, unsigned int num_circle_segments=0,
+           double min_unrounded_angle_degrees=180.0);
 
     template <typename transform_type>
     inline polygon_set_data& 
@@ -840 +863 @@
          return_points_back.push_back(curr_prev);
          point_data<double> dmid(middle.x(),middle.y());
          return_points.push_back(return_points1);
-         int num = make_arc(return_points[return_points.size()-1],mid1_offset,mid2_offset,dmid,sizing_distance,num_circle_segments);
+
+         // NOTE: perhaps this should be an additional parameter
+         bool round_away_from_center=false;
+
+         int num = make_arc(return_points[return_points.size()-1],mid1_offset,mid2_offset,dmid,sizing_distance,num_circle_segments,round_away_from_center);
          curr_prev = round_down<T>(mid2_offset);
          return num;
          
@@ -874 +901 @@
 
   }
 
-  // this routine should take in start and end point s.t. end point is CCW from start
-  // it sould make a pie slice polygon  that is an intersection of that arc
-  // with an ngon segments approximation of the circle centered at center with radius r
-  // point start is gauaranteed to be on the segmentation
+  // This routine should take in start and end point s.t. end point is CCW from start.
+  // It should make a pie slice polygon  that is an intersection of that arc
+  // with an ngon segments approximation of the circle centered at center with radius r.
+  // Point start is guaranteed to be on the segmentation, unless a full circle is created.
+  // If round_away_from_center is true, points will be rounded to the nearest type T values "away" from the center;
+  // otherwise, they will be rounded down via round_down().  (new for bug ticket #6063)
+  // TODO: do we need a version that rounds values "toward" the center?
   // returnPoints will start with the first point after start
   // returnPoints vector  may be empty
   template <typename  T>
   inline int  make_arc(std::vector<point_data< T> >& return_points,  
                        point_data< double> start, point_data< double>  end,
-                       point_data< double> center,  double r, unsigned int num_circle_segments) {
+                       point_data< double> center,  double r, unsigned int num_circle_segments,
+                       bool round_away_from_center) {
       const double our_pi=3.1415926535897932384626433832795028841971;
 
       // derive start and end angles 
@@ -898 +929 @@
       while (pe <= ps)  
          pe += 2.0 * our_pi;
       double delta_angle = (2.0 * our_pi) / (double)num_circle_segments;
+
+      std::vector< point_data<double> > tmp_points;
       if ( start==end) // full circle?
       {
           ps = delta_angle*0.5;
@@ -908 +941 @@
           start = point_data<double>(x,y);
           end = start;
       }
-      return_points.push_back(round_down<T>(center));
-      return_points.push_back(round_down<T>(start));
+      else
+      {
+          tmp_points.push_back(center);
+      }
+      tmp_points.push_back(start);
       unsigned int i=0;
       double curr_angle = ps+delta_angle;
       while( curr_angle < pe - 0.01 && i < 2 * num_circle_segments) {
          i++;
          double x = center.x() + r * cos( curr_angle);
          double y = center.y() + r * sin( curr_angle);
-         return_points.push_back( round_down<T>((point_data<double>(x,y))));
+         tmp_points.push_back(point_data<double>(x,y));
          curr_angle+=delta_angle;
       }
-      return_points.push_back(round_down<T>(end));
+      tmp_points.push_back(end);
+
+      for(int i=0; i<tmp_points.size(); i++)
+          return_points.push_back(round_away_from_center ?round_away<T>(tmp_points[i], center) :round_down<T>(tmp_points[i]));
+
       return return_points.size();
   }