// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
-// This file was modified by Oracle on 2016-2017.
-// Modifications copyright (c) 2016-2017 Oracle and/or its affiliates.
+// This file was modified by Oracle on 2016-2019.
+// Modifications copyright (c) 2016-2019 Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Use, modification and distribution is subject to the Boost Software License,
>::type robust_comparable_radius_type;
typedef typename IntersectionStrategy::side_strategy_type side_strategy_type;
+ typedef typename IntersectionStrategy::envelope_strategy_type envelope_strategy_type;
+ typedef typename IntersectionStrategy::expand_strategy_type expand_strategy_type;
typedef typename IntersectionStrategy::template area_strategy
<
robust_point_type
>::type robust_area_result_type;
+ typedef typename IntersectionStrategy::template point_in_geometry_strategy
+ <
+ robust_point_type,
+ robust_ring_type
+ >::type point_in_geometry_strategy_type;
+
typedef typename geometry::rescale_policy_type
<
- typename geometry::point_type<Ring>::type
+ typename geometry::point_type<Ring>::type,
+ typename IntersectionStrategy::cs_tag
>::type rescale_policy_type;
- typedef typename geometry::segment_ratio_type
+ typedef geometry::segment_ratio
<
- point_type,
- RobustPolicy
- >::type segment_ratio_type;
+ typename geometry::coordinate_type<robust_point_type>::type
+ > ratio_type;
typedef buffer_turn_info
<
point_type,
robust_point_type,
- segment_ratio_type
+ ratio_type
> buffer_turn_info_type;
typedef buffer_turn_operation
<
point_type,
- segment_ratio_type
+ ratio_type
> buffer_turn_operation_type;
typedef std::vector<buffer_turn_info_type> turn_vector_type;
int operation_index;
robust_point_type point;
segment_identifier seg_id;
- segment_ratio_type fraction;
+ ratio_type fraction;
};
struct piece
{}
inline robust_original(robust_ring_type const& ring,
- bool is_interior, bool has_interiors)
+ bool is_interior, bool has_interiors,
+ envelope_strategy_type const& envelope_strategy,
+ expand_strategy_type const& expand_strategy)
: m_ring(ring)
, m_is_interior(is_interior)
, m_has_interiors(has_interiors)
{
- geometry::envelope(m_ring, m_box);
+ geometry::envelope(m_ring, m_box, envelope_strategy);
// create monotonic sections in x-dimension
// The dimension is critical because the direction is later used
// and this strategy is scanning in x direction.
typedef boost::mpl::vector_c<std::size_t, 0> dimensions;
geometry::sectionalize<false, dimensions>(m_ring,
- detail::no_rescale_policy(), m_sections);
+ detail::no_rescale_policy(), m_sections,
+ envelope_strategy, expand_strategy);
}
robust_ring_type m_ring;
IntersectionStrategy m_intersection_strategy;
side_strategy_type m_side_strategy;
area_strategy_type m_area_strategy;
+ envelope_strategy_type m_envelope_strategy;
+ expand_strategy_type m_expand_strategy;
+ point_in_geometry_strategy_type m_point_in_geometry_strategy;
+
robust_area_strategy_type m_robust_area_strategy;
RobustPolicy const& m_robust_policy;
, m_has_deflated(false)
, m_intersection_strategy(intersection_strategy)
, m_side_strategy(intersection_strategy.get_side_strategy())
- , m_area_strategy(intersection_strategy.template get_area_strategy<point_type>())
- , m_robust_area_strategy(intersection_strategy.template get_area_strategy<robust_point_type>())
+ , m_area_strategy(intersection_strategy
+ .template get_area_strategy<point_type>())
+ , m_envelope_strategy(intersection_strategy.get_envelope_strategy())
+ , m_expand_strategy(intersection_strategy.get_expand_strategy())
+ , m_point_in_geometry_strategy(intersection_strategy
+ .template get_point_in_geometry_strategy<robust_point_type,
+ robust_ring_type>())
+ , m_robust_area_strategy(intersection_strategy
+ .template get_area_strategy<robust_point_type>())
, m_robust_policy(robust_policy)
{}
// intersection-point -> outgoing)
// for all (co-located) points still present in the map
- for (iterator_type it = boost::begin(m_turns);
- it != boost::end(m_turns);
- ++it)
+ for (iterator_type tit = boost::begin(m_turns);
+ tit != boost::end(m_turns);
+ ++tit)
{
typename occupation_map_type::iterator mit =
- occupation_map.find(it->get_robust_point());
+ occupation_map.find(tit->get_robust_point());
if (mit != occupation_map.end())
{
buffer_occupation_info& info = mit->second;
for (int i = 0; i < 2; i++)
{
- add_incoming_and_outgoing_angles(it->get_robust_point(), *it,
+ add_incoming_and_outgoing_angles(tit->get_robust_point(), *tit,
m_pieces,
- i, it->operations[i].seg_id,
+ i, tit->operations[i].seg_id,
info);
}
- it->count_on_multi++;
+ tit->count_on_multi++;
}
}
#endif
// Get left turns from all clusters
- for (typename occupation_map_type::iterator it = occupation_map.begin();
- it != occupation_map.end(); ++it)
+ for (typename occupation_map_type::iterator mit = occupation_map.begin();
+ mit != occupation_map.end(); ++mit)
{
- it->second.get_left_turns(it->first, m_turns, m_side_strategy);
+ mit->second.get_left_turns(mit->first, m_turns, m_side_strategy);
}
}
{
it->location = inside_buffer;
}
- if (it->count_on_original_boundary > 0)
- {
- it->location = inside_buffer;
- }
-#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
if (it->count_within_near_offsetted > 0)
{
// Within can have in rare cases a rounding issue. We don't discard this
it->operations[0].enriched.startable = false;
it->operations[1].enriched.startable = false;
}
-#endif
}
}
{
// Check if a turn is inside any of the originals
- turn_in_original_visitor<turn_vector_type> visitor(m_turns);
+ typedef turn_in_original_ovelaps_box
+ <
+ typename IntersectionStrategy::disjoint_point_box_strategy_type
+ > turn_in_original_ovelaps_box_type;
+ typedef original_ovelaps_box
+ <
+ typename IntersectionStrategy::disjoint_box_box_strategy_type
+ > original_ovelaps_box_type;
+
+ turn_in_original_visitor
+ <
+ turn_vector_type,
+ point_in_geometry_strategy_type
+ > visitor(m_turns, m_point_in_geometry_strategy);
+
geometry::partition
<
robust_box_type,
include_turn_policy,
detail::partition::include_all_policy
>::apply(m_turns, robust_originals, visitor,
- turn_get_box(), turn_in_original_ovelaps_box(),
- original_get_box(), original_ovelaps_box());
+ turn_get_box(), turn_in_original_ovelaps_box_type(),
+ original_get_box(), original_ovelaps_box_type());
bool const deflate = distance_strategy.negative();
}
}
-#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
- // Insert all rescaled turn-points into these rings, to form a
- // reliable integer-based ring. All turns can be compared (inside) to this
- // rings to see if they are inside.
-
- for (typename boost::range_iterator<piece_vector_type>::type
- it = boost::begin(m_pieces); it != boost::end(m_pieces); ++it)
+ if (! use_side_of_intersection<typename geometry::cs_tag<point_type>::type>::value)
{
- piece& pc = *it;
- signed_size_type piece_segment_index = pc.first_seg_id.segment_index;
- if (! pc.robust_turns.empty())
+ // Insert all rescaled turn-points into these rings, to form a
+ // reliable integer-based ring. All turns can be compared (inside) to this
+ // rings to see if they are inside.
+
+ for (typename boost::range_iterator<piece_vector_type>::type
+ it = boost::begin(m_pieces); it != boost::end(m_pieces); ++it)
{
- if (pc.robust_turns.size() > 1u)
+ piece& pc = *it;
+ signed_size_type piece_segment_index = pc.first_seg_id.segment_index;
+ if (! pc.robust_turns.empty())
{
- std::sort(pc.robust_turns.begin(), pc.robust_turns.end(), buffer_operation_less());
- }
- // Walk through them, in reverse to insert at right index
- signed_size_type index_offset = static_cast<signed_size_type>(pc.robust_turns.size()) - 1;
- for (typename boost::range_reverse_iterator<const std::vector<robust_turn> >::type
- rit = boost::const_rbegin(pc.robust_turns);
- rit != boost::const_rend(pc.robust_turns);
- ++rit, --index_offset)
- {
- signed_size_type const index_in_vector = 1 + rit->seg_id.segment_index - piece_segment_index;
- BOOST_GEOMETRY_ASSERT
- (
- index_in_vector > 0
- && index_in_vector < pc.offsetted_count
- );
+ if (pc.robust_turns.size() > 1u)
+ {
+ std::sort(pc.robust_turns.begin(), pc.robust_turns.end(), buffer_operation_less());
+ }
+ // Walk through them, in reverse to insert at right index
+ signed_size_type index_offset = static_cast<signed_size_type>(pc.robust_turns.size()) - 1;
+ for (typename boost::range_reverse_iterator<const std::vector<robust_turn> >::type
+ rit = boost::const_rbegin(pc.robust_turns);
+ rit != boost::const_rend(pc.robust_turns);
+ ++rit, --index_offset)
+ {
+ signed_size_type const index_in_vector = 1 + rit->seg_id.segment_index - piece_segment_index;
+ BOOST_GEOMETRY_ASSERT
+ (
+ index_in_vector > 0
+ && index_in_vector < pc.offsetted_count
+ );
- pc.robust_ring.insert(boost::begin(pc.robust_ring) + index_in_vector, rit->point);
- pc.offsetted_count++;
+ pc.robust_ring.insert(boost::begin(pc.robust_ring) + index_in_vector, rit->point);
+ pc.offsetted_count++;
- m_turns[rit->turn_index].operations[rit->operation_index].index_in_robust_ring = index_in_vector + index_offset;
+ m_turns[rit->turn_index].operations[rit->operation_index].index_in_robust_ring = index_in_vector + index_offset;
+ }
}
}
- }
- BOOST_GEOMETRY_ASSERT(assert_indices_in_robust_rings());
-#endif
+ BOOST_GEOMETRY_ASSERT(assert_indices_in_robust_rings());
+ }
}
template <std::size_t Dimension>
}
}
- static inline void determine_properties(piece& pc)
+ inline void determine_properties(piece& pc) const
{
pc.is_monotonic_increasing[0] = true;
pc.is_monotonic_increasing[1] = true;
pc.is_monotonic_decreasing[0] = true;
pc.is_monotonic_decreasing[1] = true;
- pc.is_convex = geometry::is_convex(pc.robust_ring);
+ pc.is_convex = geometry::is_convex(pc.robust_ring, m_side_strategy);
if (pc.offsetted_count < 2)
{
// create monotonic sections in y-dimension
typedef boost::mpl::vector_c<std::size_t, 1> dimensions;
geometry::sectionalize<false, dimensions>(pc.robust_ring,
- detail::no_rescale_policy(), pc.sections);
+ detail::no_rescale_policy(), pc.sections,
+ m_envelope_strategy, m_expand_strategy);
// Determine min/max radius
typedef geometry::model::referring_segment<robust_point_type const>
}
}
- inline void get_turns()
+ template <typename DistanceStrategy>
+ inline void get_turns(DistanceStrategy const& distance_strategy)
{
for(typename boost::range_iterator<sections_type>::type it
= boost::begin(monotonic_sections);
> visitor(m_pieces, offsetted_rings, m_turns,
m_intersection_strategy, m_robust_policy);
+ typedef detail::section::get_section_box
+ <
+ typename IntersectionStrategy::expand_box_strategy_type
+ > get_section_box_type;
+ typedef detail::section::overlaps_section_box
+ <
+ typename IntersectionStrategy::disjoint_box_box_strategy_type
+ > overlaps_section_box_type;
+
geometry::partition
<
robust_box_type
>::apply(monotonic_sections, visitor,
- detail::section::get_section_box(),
- detail::section::overlaps_section_box());
+ get_section_box_type(),
+ overlaps_section_box_type());
}
insert_rescaled_piece_turns();
// Check if it is inside any of the pieces
turn_in_piece_visitor
<
- turn_vector_type, piece_vector_type
- > visitor(m_turns, m_pieces);
+ typename geometry::cs_tag<point_type>::type,
+ turn_vector_type, piece_vector_type,
+ DistanceStrategy,
+ point_in_geometry_strategy_type,
+ side_strategy_type
+ > visitor(m_turns, m_pieces,
+ distance_strategy,
+ m_point_in_geometry_strategy,
+ m_side_strategy);
+
+ typedef turn_ovelaps_box
+ <
+ typename IntersectionStrategy::disjoint_point_box_strategy_type
+ > turn_ovelaps_box_type;
+ typedef piece_ovelaps_box
+ <
+ typename IntersectionStrategy::disjoint_box_box_strategy_type
+ > piece_ovelaps_box_type;
geometry::partition
<
robust_box_type
>::apply(m_turns, m_pieces, visitor,
- turn_get_box(), turn_ovelaps_box(),
- piece_get_box(), piece_ovelaps_box());
+ turn_get_box(), turn_ovelaps_box_type(),
+ piece_get_box(), piece_ovelaps_box_type());
}
}
robust_originals.push_back(
robust_original(current_robust_ring,
- is_interior, has_interiors));
+ is_interior, has_interiors, m_envelope_strategy, m_expand_strategy));
}
}
return;
}
- geometry::envelope(pc.robust_ring, pc.robust_envelope);
+ geometry::envelope(pc.robust_ring, pc.robust_envelope, m_envelope_strategy);
geometry::assign_inverse(pc.robust_offsetted_envelope);
for (signed_size_type i = 0; i < pc.offsetted_count; i++)
inline void enrich()
{
enrich_intersection_points<false, false, overlay_buffer>(m_turns,
- m_clusters, offsetted_rings, offsetted_rings,
- m_robust_policy, m_side_strategy);
+ m_clusters, offsetted_rings, offsetted_rings,
+ m_robust_policy,
+ m_intersection_strategy);
}
// Discards all rings which do have not-OK intersection points only.
inline bool point_coveredby_original(point_type const& point)
{
+ typedef typename IntersectionStrategy::disjoint_point_box_strategy_type d_pb_strategy_type;
+
robust_point_type any_point;
geometry::recalculate(any_point, point, m_robust_policy);
{
robust_original const& original = *it;
if (detail::disjoint::disjoint_point_box(any_point,
- original.m_box))
+ original.m_box,
+ d_pb_strategy_type()))
{
continue;
}
int const geometry_code
= detail::within::point_in_geometry(any_point,
- original.m_ring);
+ original.m_ring, m_point_in_geometry_strategy);
if (geometry_code == -1)
{
projects / ceph.git / blobdiff