inline void apply(PointIn const& penultimate_point, PointIn const& perp_left_point, PointIn const& ultimate_point, PointIn const& perp_right_point, buffer_side_selector side, DistanceStrategy const& distance, RangeOut& range_out) const { promoted_type const dist_left = distance.apply(penultimate_point, ultimate_point, buffer_side_left); promoted_type const dist_right = distance.apply(penultimate_point, ultimate_point, buffer_side_right); bool reversed = (side == buffer_side_left && dist_right < 0 && -dist_right > dist_left) || (side == buffer_side_right && dist_left < 0 && -dist_left > dist_right) ; if (reversed) { range_out.push_back(perp_right_point); range_out.push_back(perp_left_point); } else { range_out.push_back(perp_left_point); range_out.push_back(perp_right_point); } // Don't add the ultimate_point (endpoint of the linestring). // The buffer might be generated completely at one side. // In other cases it does no harm but is further useless }
inline bool apply(Point const& ip, Point const& vertex, Point const& perp1, Point const& perp2, DistanceType const& buffer_distance, RangeOut& range_out) const { typedef typename coordinate_type<Point>::type coordinate_type; typedef typename geometry::select_most_precise < coordinate_type, double >::type promoted_type; geometry::equal_to<Point> equals; if (equals(perp1, perp2)) { #ifdef BOOST_GEOMETRY_DEBUG_BUFFER_WARN std::cout << "Corner for equal points " << geometry::wkt(ip) << " " << geometry::wkt(perp1) << std::endl; #endif return false; } // Generate 'vectors' coordinate_type const vix = (get<0>(ip) - get<0>(vertex)); coordinate_type const viy = (get<1>(ip) - get<1>(vertex)); promoted_type const length_i = geometry::math::sqrt(vix * vix + viy * viy); promoted_type const bd = geometry::math::abs(buffer_distance); promoted_type prop = bd / length_i; Point bp; set<0>(bp, get<0>(vertex) + vix * prop); set<1>(bp, get<1>(vertex) + viy * prop); range_out.push_back(perp1); if (m_max_level > 1) { mid_points<promoted_type>(vertex, perp1, bp, bd, range_out); range_out.push_back(bp); mid_points<promoted_type>(vertex, bp, perp2, bd, range_out); } else if (m_max_level == 1) { range_out.push_back(bp); } range_out.push_back(perp2); return true; }
inline bool apply(Point const& ip, Point const& vertex, Point const& perp1, Point const& perp2, DistanceType const& buffer_distance, RangeOut& range_out) const { geometry::equal_to<Point> equals; if (equals(ip, vertex)) { return false; } if (equals(perp1, perp2)) { return false; } typedef typename coordinate_type<Point>::type coordinate_type; typedef typename geometry::select_most_precise < coordinate_type, double >::type promoted_type; Point p = ip; // Check the distance ip-vertex (= miter distance) // (We calculate it manually (not using Pythagoras strategy) to reuse // dx and dy) coordinate_type const dx = get<0>(p) - get<0>(vertex); coordinate_type const dy = get<1>(p) - get<1>(vertex); promoted_type const distance = geometry::math::sqrt(dx * dx + dy * dy); promoted_type const max_distance = m_miter_limit * geometry::math::abs(buffer_distance); if (distance > max_distance) { BOOST_ASSERT(distance != 0.0); promoted_type const proportion = max_distance / distance; set<0>(p, get<0>(vertex) + dx * proportion); set<1>(p, get<1>(vertex) + dy * proportion); } range_out.push_back(perp1); range_out.push_back(p); range_out.push_back(perp2); return true; }
inline void generate_points(Point const& vertex, Point const& perp1, Point const& perp2, DistanceType const& buffer_distance, RangeOut& range_out) const { PromotedType dx1 = get<0>(perp1) - get<0>(vertex); PromotedType dy1 = get<1>(perp1) - get<1>(vertex); PromotedType dx2 = get<0>(perp2) - get<0>(vertex); PromotedType dy2 = get<1>(perp2) - get<1>(vertex); BOOST_ASSERT(buffer_distance != 0); dx1 /= buffer_distance; dy1 /= buffer_distance; dx2 /= buffer_distance; dy2 /= buffer_distance; PromotedType angle_diff = acos(dx1 * dx2 + dy1 * dy2); PromotedType two = 2.0; PromotedType steps = m_points_per_circle; int n = boost::numeric_cast<int>(steps * angle_diff / (two * geometry::math::pi<PromotedType>())); if (n <= 1) { return; } PromotedType const angle1 = atan2(dy1, dx1); PromotedType diff = angle_diff / PromotedType(n); PromotedType a = angle1 - diff; for (int i = 0; i < n - 1; i++, a -= diff) { Point p; set<0>(p, get<0>(vertex) + buffer_distance * cos(a)); set<1>(p, get<1>(vertex) + buffer_distance * sin(a)); range_out.push_back(p); } }
inline void mid_points(Point const& vertex, Point const& p1, Point const& p2, DistanceType const& buffer_distance, RangeOut& range_out, std::size_t level = 1) const { typedef typename coordinate_type<Point>::type coordinate_type; // Generate 'vectors' coordinate_type const vp1_x = get<0>(p1) - get<0>(vertex); coordinate_type const vp1_y = get<1>(p1) - get<1>(vertex); coordinate_type const vp2_x = (get<0>(p2) - get<0>(vertex)); coordinate_type const vp2_y = (get<1>(p2) - get<1>(vertex)); // Average them to generate vector in between coordinate_type const two = 2; coordinate_type const v_x = (vp1_x + vp2_x) / two; coordinate_type const v_y = (vp1_y + vp2_y) / two; PromotedType const length2 = geometry::math::sqrt(v_x * v_x + v_y * v_y); PromotedType prop = buffer_distance / length2; Point mid_point; set<0>(mid_point, get<0>(vertex) + v_x * prop); set<1>(mid_point, get<1>(vertex) + v_y * prop); if (level < m_max_level) { mid_points<PromotedType>(vertex, p1, mid_point, buffer_distance, range_out, level + 1); } range_out.push_back(mid_point); if (level < m_max_level) { mid_points<PromotedType>(vertex, mid_point, p2, buffer_distance, range_out, level + 1); } }
inline void generate_points(Point const& point, PromotedType alpha, // by value DistanceType const& buffer_distance, RangeOut& range_out) const { PromotedType const two = 2.0; PromotedType const two_pi = two * geometry::math::pi<PromotedType>(); std::size_t point_buffer_count = m_points_per_circle; PromotedType const diff = two_pi / PromotedType(point_buffer_count); // For half circle: point_buffer_count /= 2; point_buffer_count++; for (std::size_t i = 0; i < point_buffer_count; i++, alpha -= diff) { typename boost::range_value<RangeOut>::type p; set<0>(p, get<0>(point) + buffer_distance * cos(alpha)); set<1>(p, get<1>(point) + buffer_distance * sin(alpha)); range_out.push_back(p); } }