static inline void apply(std::size_t size_at_start,
Rings& rings, typename boost::range_value<Rings>::type& ring,
Turns& turns,
typename boost::range_value<Turns>::type const& turn,
Operation& operation,
detail::overlay::traverse_error_type traverse_error,
Geometry const& ,
Geometry const& ,
RobustPolicy const& ,
state_type& state,
Visitor& visitor
)
{
#if defined(BOOST_GEOMETRY_COUNT_BACKTRACK_WARNINGS)
extern int g_backtrack_warning_count;
g_backtrack_warning_count++;
#endif
//std::cout << "!";
//std::cout << "WARNING " << traverse_error_string(traverse_error) << std::endl;
state.m_good = false;
// Make bad output clean
rings.resize(size_at_start);
ring.clear();
// Reject this as a starting point
operation.visited.set_rejected();
// And clear all visit info
clear_visit_info(turns);
}
static inline void apply(std::size_t size_at_start,
Rings& rings, typename boost::range_value<Rings>::type& ring,
Turns& turns, Operation& operation,
std::string const& reason,
Geometry const& ,
Geometry const& ,
state_type& state
)
{
#if defined(BOOST_GEOMETRY_COUNT_BACKTRACK_WARNINGS)
extern int g_backtrack_warning_count;
g_backtrack_warning_count++;
#endif
//std::cout << "!";
//std::cout << "WARNING " << reason << std::endl;
// TODO this is a copy of dissolve, check this for buffer
state.m_good = false;
// Make bad output clean
rings.resize(size_at_start);
ring.clear();
// Reject this as a starting point
operation.visited.set_rejected();
// And clear all visit info
clear_visit_info(turns);
}
static inline OutputIterator apply(Geometry const& geometry,
OutputIterator out)
{
// Get the self-intersection points, including turns
typedef detail::overlay::traversal_turn_info
<
typename point_type<Geometry>::type
> turn_info;
std::vector<turn_info> turns;
detail::get_turns::no_interrupt_policy policy;
geometry::get_turns
<
detail::overlay::calculate_distance_policy
>(geometry, turns, policy);
typedef typename ring_type<Geometry>::type ring_type;
typedef std::vector<ring_type> out_vector;
out_vector rings;
// Enrich the turns
typedef typename strategy_side
<
typename cs_tag<Geometry>::type
>::type side_strategy_type;
enrich_intersection_points(turns, geometry, geometry,
side_strategy_type());
// Traverse the polygons twice in two different directions
traverse(geometry, geometry, detail::overlay::operation_union,
turns, rings);
clear_visit_info(turns);
traverse(geometry, geometry, detail::overlay::operation_intersection,
turns, rings);
return detail::overlay::assemble<Geometry>(rings, turns,
geometry, geometry, 1, true, out);
}
static inline void apply(std::size_t size_at_start,
Rings& rings, typename boost::range_value<Rings>::type& ring,
Turns& turns, Operation& operation,
std::string const& ,
Geometry const& ,
Geometry const& ,
state_type& state
)
{
state.m_good = false;
// Make bad output clean
rings.resize(size_at_start);
ring.clear();
// Reject this as a starting point
operation.visited.set_rejected();
// And clear all visit info
clear_visit_info(turns);
}
static inline OutputIterator apply(Geometry const& geometry,
OutputIterator out)
{
// Get the self-intersection points, including turns
typedef detail::overlay::traversal_turn_info
<
typename point_type<Geometry>::type
> turn_info;
std::vector<turn_info> turns;
detail::dissolve::no_interrupt_policy policy;
geometry::self_turns
<
detail::overlay::calculate_distance_policy
>(geometry, turns, policy);
// The dissolve process is not necessary if there are no turns at all
if (boost::size(turns) > 0)
{
typedef typename ring_type<Geometry>::type ring_type;
typedef std::vector<ring_type> out_vector;
out_vector rings;
// Enrich the turns
typedef typename strategy::side::services::default_strategy
<
typename cs_tag<Geometry>::type
>::type side_strategy_type;
enrich_intersection_points<false, false>(turns,
detail::overlay::operation_union,
geometry, geometry,
side_strategy_type());
typedef detail::overlay::traverse
<
false, false,
Geometry, Geometry,
backtrack_for_dissolve<Geometry>
> traverser;
// Traverse the polygons twice for union...
traverser::apply(geometry, geometry,
detail::overlay::operation_union,
turns, rings);
clear_visit_info(turns);
enrich_intersection_points<false, false>(turns,
detail::overlay::operation_intersection,
geometry, geometry,
side_strategy_type());
// ... and for intersection
traverser::apply(geometry, geometry,
detail::overlay::operation_intersection,
turns, rings);
std::map<ring_identifier, int> map;
map_turns(map, turns);
typedef detail::overlay::ring_properties<typename geometry::point_type<Geometry>::type> properties;
std::map<ring_identifier, properties> selected;
detail::overlay::select_rings<overlay_union>(geometry, map, selected, true);
// Add intersected rings
{
ring_identifier id(2, 0, -1);
for (typename boost::range_iterator<std::vector<ring_type> const>::type
it = boost::begin(rings);
it != boost::end(rings);
++it)
{
selected[id] = properties(*it, true);
id.multi_index++;
}
}
detail::overlay::assign_parents(geometry, rings, selected);
return detail::overlay::add_rings<GeometryOut>(selected, geometry, rings, out);
}
else
{
GeometryOut g;
geometry::convert(geometry, g);
*out++ = g;
return out;
}
}
