boost_mirror/geometry
1
0
Fork 0
mirror of https://github.com/boostorg/geometry.git synced 2025-05-09 15:14:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: major rewrite of traversal

Browse Source
This commit is contained in:
Barend Gehrels 2025-04-25 08:37:13 +02:00
parent 63104f0e27
commit 805ff654e8
86 changed files with 4053 additions and 6797 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -26,6 +26,7 @@ target_link_libraries(boost_geometry
Boost::core
Boost::crc
Boost::function_types
Boost::graph
Boost::iterator
Boost::lexical_cast
Boost::math
@ -103,6 +104,7 @@ if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
algorithm
any
crc
graph
lexical_cast
math
multiprecision
@ -131,4 +133,3 @@ if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
add_subdirectory(index/test EXCLUDE_FROM_ALL)
endif()

10
include/boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp
View File

@ -363,6 +363,11 @@ struct visit_pieces_default_policy
template <typename Collection>
static inline void apply(Collection const&, int)
{}
template <typename Turns, typename Cluster, typename Connections>
inline void visit_cluster_connections(signed_size_type cluster_id,
Turns const& turns, Cluster const& cluster, Connections const& connections) {}
};
template
@ -940,6 +945,7 @@ inline void buffer_inserter(GeometryInput const& geometry_input, OutputIterator
}
collection.handle_colocations();
collection.check_turn_in_pieces();
collection.assign_side_counts(visit_pieces_policy);
collection.make_traversable_consistent_per_cluster();
// Visit the piece collection. This does nothing (by default), but
@ -949,7 +955,7 @@ inline void buffer_inserter(GeometryInput const& geometry_input, OutputIterator
visit_pieces_policy.apply(const_collection, 0);
collection.discard_rings();
collection.block_turns();
collection.discard_non_traversable_turns();
collection.enrich();
// phase 1: turns (after enrichment/clustering)
@ -960,7 +966,7 @@ inline void buffer_inserter(GeometryInput const& geometry_input, OutputIterator
collection.deflate_check_turns();
}
collection.traverse();
collection.traverse(visit_pieces_policy);
// Reverse all offsetted rings / traversed rings if:
// - they were generated on the negative side (deflate) of polygons

58
include/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp
View File

@ -21,7 +21,8 @@
#include <boost/geometry/core/coordinate_type.hpp>
#include <boost/geometry/core/point_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp>
#include <boost/geometry/algorithms/disjoint.hpp>
#include <boost/geometry/algorithms/expand.hpp>
#include <boost/geometry/algorithms/detail/overlay/traversal_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
@ -36,54 +37,6 @@ namespace boost { namespace geometry
namespace detail { namespace buffer
{
class backtrack_for_buffer
{
public :
using state_type = detail::overlay::backtrack_state;
template
<
typename Operation,
typename Rings,
typename Turns,
typename Geometry,
typename Strategy,
typename Visitor
>
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& ,
Strategy 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);
}
};
struct buffer_overlay_visitor
{
public :
@ -98,11 +51,6 @@ public :
{
}
template <typename Turns, typename Turn, typename Operation>
void visit_traverse_reject(Turns const& , Turn const& , Operation const& ,
detail::overlay::traverse_error_type )
{}
template <typename Rings>
void visit_generated_rings(Rings const& )
{}
@ -141,7 +89,6 @@ struct buffer_turn_info
// Information if turn can be used. It is not traversable if it is within
// another piece, or within the original (depending on deflation),
// or (for deflate) if there are not enough points to traverse it.
bool is_turn_traversable;
bool is_linear_end_point;
bool within_original;
@ -149,7 +96,6 @@ struct buffer_turn_info
inline buffer_turn_info()
: turn_index(0)
, is_turn_traversable(true)
, is_linear_end_point(false)
, within_original(false)
, count_in_original(0)

85
include/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp
View File

@ -37,9 +37,12 @@
#include <boost/geometry/geometries/ring.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/assign_side_counts.hpp>
#include <boost/geometry/algorithms/detail/buffer/buffered_ring.hpp>
#include <boost/geometry/algorithms/detail/buffer/buffer_policies.hpp>
#include <boost/geometry/algorithms/detail/overlay/cluster_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/get_properties_ahead.hpp>
#include <boost/geometry/algorithms/detail/overlay/handle_colocations.hpp>
#include <boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp>
#include <boost/geometry/algorithms/detail/buffer/piece_border.hpp>
#include <boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp>
@ -308,7 +311,7 @@ struct buffered_piece_collection
// be three turns (which cannot be checked here - TODO: add to traverse)
for (auto& turn : m_turns)
{
if (! turn.is_turn_traversable)
if (! turn.is_traversable)
{
continue;
}
@ -348,18 +351,18 @@ struct buffered_piece_collection
for (auto& turn : m_turns)
{
if (turn.is_turn_traversable)
if (turn.is_traversable)
{
if (deflate && turn.count_in_original <= 0)
{
// For deflate/negative buffers:
// it is not in the original, so don't use it
turn.is_turn_traversable = false;
turn.is_traversable = false;
}
else if (! deflate && turn.count_in_original > 0)
{
// For inflate: it is in original, so don't use it
turn.is_turn_traversable = false;
turn.is_traversable = false;
}
}
}
@ -439,6 +442,21 @@ struct buffered_piece_collection
detail::section::overlaps_section_box<Strategy>(m_strategy));
}
// This fixes the fact that sometimes wrong ix or xi turns are generated.
// See comments in get_turn_info (block_q).
// The ix turns are not relevant for buffer anyway, it is fine to remove them,
// as long as they are removed before calculating turn indices.
// It will also enhance performance a bit (no need to calculate point in original,
// point in piece). Therefore we remove ii and xx as well.
m_turns.erase(std::remove_if(m_turns.begin(), m_turns.end(),
[](auto const& turn)
{
bool const is_ix = turn.combination(overlay::operation_intersection, overlay::operation_blocked);
bool const is_ii = turn.both(overlay::operation_intersection);
return is_ix || is_ii || turn.blocked();
}),
m_turns.end());
update_turn_administration();
}
@ -869,29 +887,27 @@ struct buffered_piece_collection
inline void handle_colocations()
{
if (! detail::overlay::handle_colocations
<
false, false, overlay_buffer,
ring_collection_t, ring_collection_t
>(m_turns, m_clusters))
{
return;
}
detail::overlay::handle_colocations(m_turns, m_clusters);
}
detail::overlay::gather_cluster_properties
<
false, false, overlay_buffer
>(m_clusters, m_turns, detail::overlay::operation_union,
offsetted_rings, offsetted_rings, m_strategy);
template <typename Visitor>
inline void assign_side_counts(Visitor& visitor)
{
// Assign count_left, count_right and open_count
detail::overlay::assign_side_counts
<false, false, overlay_buffer>
(offsetted_rings, offsetted_rings,
m_turns, m_clusters,
m_strategy, visitor);
// Mark closed clusters as not traversable
for (auto const& cluster : m_clusters)
{
if (cluster.second.open_count == 0 && cluster.second.spike_count == 0)
if (cluster.second.open_count == 0)
{
// If the cluster is completely closed, mark it as not traversable.
for (auto const& index : cluster.second.turn_indices)
{
m_turns[index].is_turn_traversable = false;
m_turns[index].is_traversable = false;
}
}
}
@ -904,7 +920,7 @@ struct buffered_piece_collection
bool is_traversable = false;
for (auto const& index : cluster.second.turn_indices)
{
if (m_turns[index].is_turn_traversable)
if (m_turns[index].is_traversable)
{
// If there is one turn traversable in the cluster,
// then all turns should be traversable.
@ -916,7 +932,7 @@ struct buffered_piece_collection
{
for (auto const& index : cluster.second.turn_indices)
{
m_turns[index].is_turn_traversable = true;
m_turns[index].is_traversable = true;
}
}
}
@ -924,9 +940,13 @@ struct buffered_piece_collection
inline void enrich()
{
enrich_intersection_points<false, false, overlay_buffer>(m_turns,
m_clusters, offsetted_rings, offsetted_rings,
m_strategy);
detail::overlay::enrich_discard_turns<overlay_buffer>(
m_turns, m_clusters, offsetted_rings, offsetted_rings, m_strategy);
detail::overlay::enrich_turns<false, false, overlay_buffer>(
m_turns, offsetted_rings, offsetted_rings, m_strategy);
detail::overlay::get_properties_ahead<false, false>(m_turns, m_clusters, offsetted_rings,
offsetted_rings, m_strategy);
}
// Discards all rings which do have not-OK intersection points only.
@ -935,7 +955,7 @@ struct buffered_piece_collection
{
for (auto const& turn : m_turns)
{
if (turn.is_turn_traversable)
if (turn.is_traversable)
{
offsetted_rings[turn.operations[0].seg_id.multi_index].has_accepted_intersections = true;
offsetted_rings[turn.operations[1].seg_id.multi_index].has_accepted_intersections = true;
@ -1013,28 +1033,27 @@ struct buffered_piece_collection
}
}
inline void block_turns()
inline void discard_non_traversable_turns()
{
for (auto& turn : m_turns)
{
if (! turn.is_turn_traversable)
if (! turn.is_traversable)
{
// Discard this turn (don't set it to blocked to avoid colocated
// clusters being discarded afterwards
// Discard the non traversable turn
turn.discarded = true;
}
}
}
inline void traverse()
template <typename PieceVisitor>
inline void traverse(PieceVisitor const& piece_visitor)
{
using traverser = detail::overlay::traverse
<
false, false,
buffered_ring_collection<buffered_ring<Ring> >,
buffered_ring_collection<buffered_ring<Ring > >,
overlay_buffer,
backtrack_for_buffer
overlay_buffer
>;
std::map<ring_identifier, overlay::ring_turn_info> turn_info_per_ring;

8
include/boost/geometry/algorithms/detail/buffer/turn_in_original_visitor.hpp
View File

@ -75,7 +75,7 @@ struct include_turn_policy
template <typename Turn>
static inline bool apply(Turn const& turn)
{
return turn.is_turn_traversable;
return turn.is_traversable;
}
};
@ -89,7 +89,7 @@ struct turn_in_original_overlaps_box
template <typename Box, typename Turn>
inline bool apply(Box const& box, Turn const& turn) const
{
if (! turn.is_turn_traversable || turn.within_original)
if (! turn.is_traversable || turn.within_original)
{
// Skip all points already processed
return false;
@ -237,7 +237,7 @@ public:
return true;
}
if (! turn.is_turn_traversable || turn.within_original)
if (! turn.is_traversable || turn.within_original)
{
// Skip all points already processed
return true;
@ -262,7 +262,7 @@ public:
if (code == 0)
{
// On border of original: always discard
mutable_turn.is_turn_traversable = false;
mutable_turn.is_traversable = false;
}
// Point is inside an original ring

6
include/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp
View File

@ -108,7 +108,7 @@ public:
template <typename Turn, typename Piece>
inline bool apply(Turn const& turn, Piece const& piece)
{
if (! turn.is_turn_traversable)
if (! turn.is_traversable)
{
// Already handled
return true;
@ -154,7 +154,7 @@ public:
if (d < border.m_min_comparable_radius)
{
Turn& mutable_turn = m_turns[turn.turn_index];
mutable_turn.is_turn_traversable = false;
mutable_turn.is_traversable = false;
return true;
}
if (d > border.m_max_comparable_radius)
@ -177,7 +177,7 @@ public:
if (state.is_inside() && ! state.is_on_boundary())
{
Turn& mutable_turn = m_turns[turn.turn_index];
mutable_turn.is_turn_traversable = false;
mutable_turn.is_traversable = false;
}
return true;

4
include/boost/geometry/algorithms/detail/overlay/approximately_equals.hpp
View File

@ -21,7 +21,7 @@ namespace boost { namespace geometry
namespace detail { namespace overlay
{
// Value for approximately_equals used by get_cluster and sort_by_side
// Value for approximately_equals used by get_cluster and assign_side_counts
// This is an "epsilon_multiplier" and, therefore, multiplied the epsilon
// belonging to the used floating point type with this value.
template <typename T>
@ -29,7 +29,7 @@ struct common_approximately_equals_epsilon_multiplier
{
static T value()
{
// The value is (a bit) arbitrary. For sort_by_side it should be large
// The value is (a bit) arbitrary. For assign_side_counts it should be large
// enough to not take a point which is too close by, to calculate the
// side value correctly. For get_cluster it is arbitrary as well, points
// close to each other should form a cluster, which is also important

205
include/boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp
View File

@ -1,205 +0,0 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
// This file was modified by Oracle on 2017-2024.
// Modifications copyright (c) 2017-2024, Oracle and/or its affiliates.
// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_BACKTRACK_CHECK_SI_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_BACKTRACK_CHECK_SI_HPP
#include <cstddef>
#include <string>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/value_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
#include <boost/geometry/algorithms/detail/has_self_intersections.hpp>
#if defined(BOOST_GEOMETRY_DEBUG_INTERSECTION) || defined(BOOST_GEOMETRY_OVERLAY_REPORT_WKT)
# include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
# include <boost/geometry/io/wkt/wkt.hpp>
#endif
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
template <typename Turns>
inline void clear_visit_info(Turns& turns)
{
for (auto& turn : turns)
{
for (auto& op : turn.operations)
{
op.visited.clear();
}
}
}
struct backtrack_state
{
bool m_good;
inline backtrack_state() : m_good(true) {}
inline void reset() { m_good = true; }
inline bool good() const { return m_good; }
};
enum traverse_error_type
{
traverse_error_none,
traverse_error_no_next_ip_at_start,
traverse_error_no_next_ip,
traverse_error_dead_end_at_start,
traverse_error_dead_end,
traverse_error_visit_again,
traverse_error_endless_loop
};
inline std::string traverse_error_string(traverse_error_type error)
{
switch (error)
{
case traverse_error_none : return "";
case traverse_error_no_next_ip_at_start : return "No next IP at start";
case traverse_error_no_next_ip : return "No next IP";
case traverse_error_dead_end_at_start : return "Dead end at start";
case traverse_error_dead_end : return "Dead end";
case traverse_error_visit_again : return "Visit again";
case traverse_error_endless_loop : return "Endless loop";
default : return "";
}
return "";
}
template
<
typename Geometry1,
typename Geometry2
>
class backtrack_check_self_intersections
{
struct state : public backtrack_state
{
bool m_checked;
inline state()
: m_checked(true)
{}
};
public :
using state_type = state;
template
<
typename Operation,
typename Rings, typename Ring, typename Turns,
typename Strategy,
typename Visitor
>
static inline void apply(std::size_t size_at_start,
Rings& rings,
Ring& ring,
Turns& turns,
typename boost::range_value<Turns>::type const& turn,
Operation& operation,
traverse_error_type traverse_error,
Geometry1 const& geometry1,
Geometry2 const& geometry2,
Strategy const& strategy,
state_type& state,
Visitor& visitor)
{
visitor.visit_traverse_reject(turns, turn, operation, traverse_error);
state.m_good = false;
// Check self-intersections and throw exception if appropriate
if (! state.m_checked)
{
state.m_checked = true;
has_self_intersections(geometry1, strategy);
has_self_intersections(geometry2, strategy);
}
// Make bad output clean
rings.resize(size_at_start);
geometry::traits::clear<typename boost::range_value<Rings>::type>::apply(ring);
// Reject this as a starting point
operation.visited.set_rejected();
// And clear all visit info
clear_visit_info(turns);
}
};
#ifdef BOOST_GEOMETRY_OVERLAY_REPORT_WKT
template
<
typename Geometry1,
typename Geometry2
>
class backtrack_debug
{
public :
using state_type = backtrack_state;
template <typename Operation, typename Rings, typename 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,
Geometry1 const& geometry1,
Geometry2 const& geometry2,
state_type& state
)
{
std::cout << " REJECT " << reason << std::endl;
state.m_good = false;
rings.resize(size_at_start);
ring.clear();
operation.visited.set_rejected();
clear_visit_info(turns);
int c = 0;
for (int i = 0; i < turns.size(); i++)
{
for (int j = 0; j < 2; j++)
{
if (turns[i].operations[j].visited.rejected())
{
c++;
}
}
}
std::cout << "BACKTRACK (" << reason << " )"
<< " " << c << " of " << turns.size() << " rejected"
<< std::endl;
std::cout
<< geometry::wkt(geometry1) << std::endl
<< geometry::wkt(geometry2) << std::endl;
}
};
#endif // BOOST_GEOMETRY_OVERLAY_REPORT_WKT
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_BACKTRACK_CHECK_SI_HPP

5
include/boost/geometry/algorithms/detail/overlay/cluster_info.hpp
View File

@ -21,17 +21,12 @@ namespace boost { namespace geometry
namespace detail { namespace overlay
{
struct cluster_info
{
std::set<signed_size_type> turn_indices;
//! Number of open spaces (e.g. 2 for touch)
std::size_t open_count{0};
//! Number of spikes, where a segment goes to the cluster point
//! and leaves immediately in the opposite direction.
std::size_t spike_count{0};
};

13
include/boost/geometry/algorithms/detail/overlay/colocate_clusters.hpp
View File

@ -34,15 +34,6 @@ struct cluster_colocator
template <typename TurnIndices, typename Turns>
static inline void apply(TurnIndices const& indices, Turns& turns)
{
// This approach works for all but one testcase (rt_p13)
// The problem is fill_sbs, which uses sides and these sides might change slightly
// depending on the exact location of the cluster.
// Using the centroid is, on the average, a safer choice for sides.
// Alternatively fill_sbs could be revised, but that requires a lot of work
// and is outside current scope.
// Integer coordinates are always colocated already and do not need centroid calculation.
// Geographic/spherical coordinates might (in extremely rare cases) cross the date line
// and therefore the first point is taken for them as well.
auto it = indices.begin();
auto const& first_point = turns[*it].point;
for (++it; it != indices.end(); ++it)
@ -81,6 +72,10 @@ struct cluster_colocator<Point, CoordinateType, geometry::cartesian_tag, false>
// Because clusters are intersection close together, and
// handled as one location. Then they should also have one location.
// It is necessary to avoid artefacts and invalidities.
// Integer coordinates are always colocated already and do not need centroid calculation.
// Geographic/spherical coordinates might (in extremely rare cases) cross the date line
// and therefore the first point is taken for them as well.
// Currently only necessary for one test case: issue_1211 (validation of sym difference)
template <typename Clusters, typename Turns>
inline void colocate_clusters(Clusters const& clusters, Turns& turns)
{

13
include/boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp
View File

@ -10,7 +10,6 @@
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DEBUG_TURN_INFO_HPP
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/visit_info.hpp>
namespace boost { namespace geometry
@ -49,18 +48,6 @@ inline char operation_char(detail::overlay::operation_type const& operation)
}
}
inline char visited_char(detail::overlay::visit_info const& v)
{
if (v.rejected()) return 'R';
if (v.started()) return 's';
if (v.visited()) return 'v';
if (v.none()) return '-';
if (v.finished()) return 'f';
return '?';
}
}} // namespace boost::geometry

6
include/boost/geometry/algorithms/detail/overlay/discard_duplicate_turns.hpp
View File

@ -104,6 +104,12 @@ void discard_duplicate_start_turns(Turns& turns,
return multi_and_ring_id_type{seg_id.multi_index, seg_id.ring_index};
};
#if defined(BOOST_GEOMETRY_CONCEPT_FIX_START_TURNS)
// Handle it by removing them from clusters.
// Not complete yet.
return;
#endif
for (auto& turn : turns)
{
// Any turn which "crosses" does not have a corresponding turn.

322
include/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp
View File

@ -37,7 +37,7 @@
#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
#include <boost/geometry/algorithms/detail/overlay/check_enrich.hpp>
#include <boost/geometry/algorithms/detail/overlay/discard_duplicate_turns.hpp>
#include <boost/geometry/algorithms/detail/overlay/handle_colocations.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/adapt_operations.hpp>
#include <boost/geometry/algorithms/detail/overlay/handle_self_turns.hpp>
#include <boost/geometry/algorithms/detail/overlay/is_self_turn.hpp>
#include <boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp>
@ -101,7 +101,6 @@ inline void enrich_sort(Operations& operations,
>(turns, geometry1, geometry2, strategy));
}
// Assign travel-to-vertex/ip index for each turn.
template <typename Operations, typename Turns>
inline void enrich_assign(Operations& operations, Turns& turns)
@ -110,16 +109,41 @@ inline void enrich_assign(Operations& operations, Turns& turns)
{
auto const& index = item.index;
auto const& indexed = item.value;
if (indexed.discarded)
{
continue;
}
auto& turn = turns[indexed.turn_index];
auto& op = turn.operations[indexed.operation_index];
std::size_t next_index = index + 1 < operations.size() ? index + 1 : 0;
auto advance = [&operations](auto index)
std::size_t skipped_count = 0;
auto advance = [&](auto index)
{
std::size_t const result = index + 1;
return result >= operations.size() ? 0 : result;
std::size_t result = (index + 1) % operations.size();
while (operations[result].discarded)
{
result = (result + 1) % operations.size();
auto const& next_turn = turns[operations[result].turn_index];
if (! next_turn.is_traversable)
{
// There might be more conditions to skip.
// But it should not skip ALL discarded turns.
skipped_count++;
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << " -> Skip for " << operations[index].turn_index << " because of blocked "
<< " " << operations[result].turn_index
<< std::endl;
#endif
}
}
return result;
};
std::size_t next_index = advance(index);
auto next_turn = [&operations, &turns, &next_index]()
{
return turns[operations[next_index].turn_index];
@ -142,18 +166,17 @@ inline void enrich_assign(Operations& operations, Turns& turns)
next_index = advance(next_index);
}
if (skipped_count > 0)
{
// Don't assign travel-info, because it is not reachable. But neither discard the turn,
// the other operation might be reachable.
continue;
}
op.enriched.travels_to_ip_index
= static_cast<signed_size_type>(operations[next_index].turn_index);
op.enriched.travels_to_vertex_index
= operations[next_index].subject->seg_id.segment_index;
auto const& next_op = next_operation();
if (op.seg_id.segment_index == next_op.seg_id.segment_index
&& op.fraction < next_op.fraction)
{
// Next turn is located further on same segment: assign next_ip_index
op.enriched.next_ip_index = static_cast<signed_size_type>(operations[next_index].turn_index);
}
}
#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
@ -169,11 +192,11 @@ inline void enrich_assign(Operations& operations, Turns& turns)
<< " op=" << operation_char(turns[indexed_op.turn_index].operations[0].operation)
<< operation_char(turns[indexed_op.turn_index].operations[1].operation)
<< " (" << operation_char(op.operation) << ")"
<< " nxt=" << op.enriched.next_ip_index
<< " / " << op.enriched.travels_to_ip_index
<< " to=" << op.enriched.travels_to_ip_index
<< " [vx " << op.enriched.travels_to_vertex_index << "]"
<< (turns[indexed_op.turn_index].discarded ? " [discarded]" : "")
<< (op.enriched.startable ? "" : " [not startable]")
<< (indexed_op.discarded ? " DISCARDED" : "")
<< std::endl;
}
#endif
@ -199,7 +222,7 @@ inline void enrich_adapt(Operations& operations, Turns& turns)
auto& turn = turns[indexed.turn_index];
auto& op = turn.operations[indexed.operation_index];
std::size_t const next_index = index + 1 < operations.size() ? index + 1 : 0;
std::size_t const next_index = (index + 1) % operations.size();
auto const& next_turn = turns[operations[next_index].turn_index];
auto const& next_op = next_turn.operations[operations[next_index].operation_index];
@ -261,7 +284,7 @@ template <typename Turns, typename IncludePolicy>
inline auto create_map(Turns const& turns, IncludePolicy const& include_policy)
{
using turn_type = typename boost::range_value<Turns>::type;
using indexed_turn_operation = detail::overlay::indexed_turn_operation
using indexed_turn_operation = indexed_turn_operation
<
typename turn_type::turn_operation_type
>;
@ -276,11 +299,6 @@ inline auto create_map(Turns const& turns, IncludePolicy const& include_policy)
{
auto const& index = turn_item.index;
auto const& turn = turn_item.value;
if (turn.discarded)
{
continue;
}
for (auto const& op_item : util::enumerate(turn.operations))
{
auto const& op_index = op_item.index;
@ -289,58 +307,144 @@ inline auto create_map(Turns const& turns, IncludePolicy const& include_policy)
{
mapped_vector[ring_id_by_seg_id(op.seg_id)].emplace_back
(
index, op_index, op, turn.operations[1 - op_index].seg_id
index, op_index, op, turn.operations[1 - op_index].seg_id, turn.discarded
);
}
}
}
return mapped_vector;
}
template <typename Point1, typename Point2>
inline geometry::coordinate_type_t<Point1> distance_measure(Point1 const& a, Point2 const& b)
template
<
overlay_type OverlayType,
typename Turns,
typename Clusters,
typename Geometry1, typename Geometry2,
typename IntersectionStrategy
>
inline void enrich_discard_turns(Turns& turns, Clusters& clusters,
Geometry1 const& geometry1, Geometry2 const& geometry2,
IntersectionStrategy const& strategy)
{
// TODO: use comparable distance for point-point instead - but that
// causes currently cycling include problems
using ctype = geometry::coordinate_type_t<Point1>;
ctype const dx = get<0>(a) - get<0>(b);
ctype const dy = get<1>(a) - get<1>(b);
return dx * dx + dy * dy;
}
constexpr operation_type target_operation = operation_from_overlay<OverlayType>::value;
template <typename Turns>
inline void calculate_remaining_distance(Turns& turns)
{
constexpr operation_type opposite_operation
= target_operation == operation_union
? operation_intersection
: operation_union;
// Turns are often used by index (in clusters, next_index, etc)
// and turns may therefore NOT be DELETED - they may only be flagged as discarded
discard_duplicate_turns(turns, geometry1, geometry2);
// Discard turns not part of target overlay
for (auto& turn : turns)
{
auto& op0 = turn.operations[0];
auto& op1 = turn.operations[1];
static decltype(op0.remaining_distance) const zero_distance = 0;
if (op0.remaining_distance != zero_distance
|| op1.remaining_distance != zero_distance)
if (turn.both(operation_none)
|| turn.both(opposite_operation)
|| turn.both(operation_blocked)
|| (is_self_turn<OverlayType>(turn)
&& ! turn.is_clustered()
&& ! turn.both(target_operation)))
{
continue;
// For all operations, discard xx and none/none
// For intersections, remove uu to avoid the need to travel
// a union (during intersection) in uu/cc clusters (e.g. #31,#32,#33)
// Similarly, for union, discard ii and ix
// For self-turns, only keep uu / ii
turn.discarded = true;
turn.cluster_id = -1;
}
auto const to_index0 = op0.enriched.get_next_turn_index();
auto const to_index1 = op1.enriched.get_next_turn_index();
if (to_index0 >= 0
&& to_index1 >= 0
&& to_index0 != to_index1)
#if defined(BOOST_GEOMETRY_CONCEPT_FIX_START_TURNS)
if (turn.is_clustered() && turn.method == method_start)
{
op0.remaining_distance = distance_measure(turn.point, turns[to_index0].point);
op1.remaining_distance = distance_measure(turn.point, turns[to_index1].point);
// Start turns are generated, in case the previous turn is missed.
// But often it is not missed, and then it should be deleted.
// TODO: only if the cluster NOT ONLY contains start turns, and there are turns left...
turn.discarded = true;
turn.cluster_id = -1;
}
#endif
}
// Discard self turns located within the other geometry (for union)
// or outside it (for intersection)
// For buffer or dissolve, nothing is called.
discard_closed_turns
<
OverlayType,
target_operation
>::apply(turns, clusters, geometry1, geometry2, strategy);
discard_open_turns
<
OverlayType,
target_operation
>::apply(turns, clusters, geometry1, geometry2, strategy);
// Remove discarded turns from clusters
cleanup_clusters(turns, clusters);
}
template
<
bool Reverse1, bool Reverse2,
overlay_type OverlayType,
typename Turns,
typename Geometry1, typename Geometry2,
typename IntersectionStrategy
>
inline void enrich_turns(Turns& turns,
Geometry1 const& geometry1, Geometry2 const& geometry2,
IntersectionStrategy const& strategy)
{
constexpr operation_type target_operation = operation_from_overlay<OverlayType>::value;
// Create a map of vectors of indexed operation-types to be able
// to sort intersection points PER RING
auto mapped_vector = create_map(turns, enriched_map_default_include_policy());
for (auto& pair : mapped_vector)
{
enrich_sort<Reverse1, Reverse2>(pair.second, turns, geometry1, geometry2, strategy);
}
for (auto& pair : mapped_vector)
{
#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
std::cout << "ENRICH-assign Ring " << pair.first << std::endl;
#endif
if BOOST_GEOMETRY_CONSTEXPR (OverlayType == overlay_dissolve)
{
enrich_adapt(pair.second, turns);
}
enrich_assign(pair.second, turns);
}
block_ux_uu_workaround(turns);
#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
constexpr bool do_check_graph = true;
#else
constexpr bool do_check_graph = false;
#endif
if BOOST_GEOMETRY_CONSTEXPR (do_check_graph)
{
check_graph(turns, target_operation);
}
}
}} // namespace detail::overlay
#endif //DOXYGEN_NO_DETAIL
/*!
\brief All intersection points are enriched with successor information
\ingroup overlay
@ -370,116 +474,8 @@ inline void enrich_intersection_points(Turns& turns,
Geometry1 const& geometry1, Geometry2 const& geometry2,
IntersectionStrategy const& strategy)
{
constexpr detail::overlay::operation_type target_operation
= detail::overlay::operation_from_overlay<OverlayType>::value;
constexpr detail::overlay::operation_type opposite_operation
= target_operation == detail::overlay::operation_union
? detail::overlay::operation_intersection
: detail::overlay::operation_union;
constexpr bool is_dissolve = OverlayType == overlay_dissolve;
// Turns are often used by index (in clusters, next_index, etc)
// and turns may therefore NOT be DELETED - they may only be flagged as discarded
discard_duplicate_turns(turns, geometry1, geometry2);
bool has_cc = false;
// Discard turns not part of target overlay
for (auto& turn : turns)
{
if (turn.both(detail::overlay::operation_none)
|| turn.both(opposite_operation)
|| turn.both(detail::overlay::operation_blocked)
|| (detail::overlay::is_self_turn<OverlayType>(turn)
&& ! turn.is_clustered()
&& ! turn.both(target_operation)))
{
// For all operations, discard xx and none/none
// For intersections, remove uu to avoid the need to travel
// a union (during intersection) in uu/cc clusters (e.g. #31,#32,#33)
// Similarly, for union, discard ii and ix
// For self-turns, only keep uu / ii
turn.discarded = true;
turn.cluster_id = -1;
continue;
}
if (! turn.discarded
&& turn.both(detail::overlay::operation_continue))
{
has_cc = true;
}
}
if (! is_dissolve)
{
detail::overlay::discard_closed_turns
<
OverlayType,
target_operation
>::apply(turns, clusters, geometry1, geometry2,
strategy);
detail::overlay::discard_open_turns
<
OverlayType,
target_operation
>::apply(turns, clusters, geometry1, geometry2,
strategy);
}
if (! clusters.empty())
{
detail::overlay::cleanup_clusters(turns, clusters);
detail::overlay::colocate_clusters(clusters, turns);
}
// Create a map of vectors of indexed operation-types to be able
// to sort intersection points PER RING
auto mapped_vector = detail::overlay::create_map(turns,
detail::overlay::enriched_map_default_include_policy());
for (auto& pair : mapped_vector)
{
detail::overlay::enrich_sort<Reverse1, Reverse2>(
pair.second, turns,
geometry1, geometry2,
strategy);
}
// After cleaning up clusters assign the next turns
for (auto& pair : mapped_vector)
{
#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
std::cout << "ENRICH-assign Ring " << pair.first << std::endl;
#endif
if (is_dissolve)
{
detail::overlay::enrich_adapt(pair.second, turns);
}
detail::overlay::enrich_assign(pair.second, turns);
}
if (has_cc)
{
detail::overlay::calculate_remaining_distance(turns);
}
#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
constexpr bool do_check_graph = true;
#else
constexpr bool do_check_graph = false;
#endif
if BOOST_GEOMETRY_CONSTEXPR (do_check_graph)
{
detail::overlay::check_graph(turns, target_operation);
}
detail::overlay::enrich_discard_turns<OverlayType>(turns, clusters, geometry1, geometry2, strategy);
detail::overlay::enrich_turns<Reverse1, Reverse2, OverlayType>(turns, geometry1, geometry2, strategy);
}
}} // namespace boost::geometry

65
include/boost/geometry/algorithms/detail/overlay/enrichment_info.hpp
View File

@ -9,6 +9,7 @@
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ENRICHMENT_INFO_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ENRICHMENT_INFO_HPP
#include <boost/geometry/core/coordinate_type.hpp>
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
@ -30,46 +31,54 @@ namespace detail { namespace overlay
template<typename Point>
struct enrichment_info
{
inline enrichment_info()
: travels_to_vertex_index(-1)
, travels_to_ip_index(-1)
, next_ip_index(-1)
, startable(true)
, prefer_start(true)
, count_left(0)
, count_right(0)
, rank(-1)
, zone(-1)
, region_id(-1)
, isolated(false)
{}
inline signed_size_type get_next_turn_index() const
{
return next_ip_index == -1 ? travels_to_ip_index : next_ip_index;
return travels_to_ip_index;
}
// vertex to which is free travel after this IP,
// so from "segment_index+1" to "travels_to_vertex_index", without IP-s,
// can be -1
signed_size_type travels_to_vertex_index;
signed_size_type travels_to_vertex_index{-1};
// same but now IP index, so "next IP index" but not on THIS segment
signed_size_type travels_to_ip_index;
signed_size_type travels_to_ip_index{-1};
// index of next IP on this segment, -1 if there is no one
signed_size_type next_ip_index;
bool startable{true}; // Can be used to start a traversal
bool startable; // Can be used to start in traverse
bool prefer_start; // Is preferred as starting point (if true)
// Counts if polygons left/right of this operation.
// Outgoing from this operation:
signed_size_type count_left{-1};
signed_size_type count_right{-1};
// Counts if polygons left/right of this operation
std::size_t count_left;
std::size_t count_right;
signed_size_type rank; // in cluster
signed_size_type zone; // open zone, in cluster
signed_size_type region_id;
bool isolated;
// Incoming:
signed_size_type count_left_incoming{-1};
signed_size_type count_right_incoming{-1};
// Set to true if the turn is traversed.
// This is used for one condition.
bool is_traversed{false};
// The component_id of the operation. At uu or ii turns, it will
// usually change components (dependent on the constellation).
// This is detected by detect_biconnected_components
signed_size_type component_id{-1};
// Rank of this operation in a cluster. It can be used to compare
// (again) two operations originating in the same cluster.
std::size_t rank{0};
// For CC turns, the distance ahead to the first side change
using comparable_distance_type = coordinate_type_t<Point>;
comparable_distance_type ahead_distance_of_side_change{-1};
// For CC turns, the side of the ahead segment.
// Indicated conform side strategies:
// 1 for left
// -1 for right
// 0 for collinear
// -99 for unassigned
int ahead_side{-99};
};

183
include/boost/geometry/algorithms/detail/overlay/get_properties_ahead.hpp Normal file
View File

@ -0,0 +1,183 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_PROPERTIES_AHEAD_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_PROPERTIES_AHEAD_HPP
#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
#if defined(BOOST_GEOMETRY_DEBUG_GET_PROPERTIES_AHEAD)
#include <boost/geometry/io/wkt/wkt.hpp>
#endif
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
// Get properties ahead of a turn. This is important for turns marked as cc (continue-continue).
// It walks over the ring (of each operation) into the direction of the next turn,
// as long as the points are collinear.
// It then reports both the collinear (comparable) distance, of the turn to the point where it bend,
// and the side of the next point. So where it bends to.
template
<
bool Reverse1, bool Reverse2,
typename Turns, typename Clusters,
typename Geometry1, typename Geometry2,
typename IntersectionStrategy
>
void get_properties_ahead(Turns& turns, Clusters const& clusters,
Geometry1 const& geometry1, Geometry2 const& geometry2,
IntersectionStrategy const& intersection_strategy)
{
using point_type = typename Turns::value_type::point_type;
auto const side_strategy = intersection_strategy.side();
auto const comparable_distance_strategy
= intersection_strategy.comparable_distance(point_type(), point_type());
auto walk_ahead = [&](auto const& turn, auto& op)
{
auto current_ring_id = ring_id_by_seg_id(op.seg_id);
auto const& next_turn = turns[op.enriched.travels_to_ip_index];
auto const next_ring_id0 = ring_id_by_seg_id(next_turn.operations[0].seg_id);
auto const next_op_index = next_ring_id0 == current_ring_id ? 0 : 1;
auto const& next_op = next_turn.operations[next_op_index];
signed_size_type const point_count_to_next_turn = current_ring_id.source_index == 0
? segment_distance(geometry1, op.seg_id, next_op.seg_id)
: segment_distance(geometry2, op.seg_id, next_op.seg_id);
int offset = 0;
point_type point_of_segment0;
geometry::copy_segment_point<Reverse1, Reverse2>(geometry1, geometry2, op.seg_id,
offset++, point_of_segment0);
#if defined(BOOST_GEOMETRY_DEBUG_GET_PROPERTIES_AHEAD)
std::cout << " EXAMINE AHEAD: ring " << current_ring_id
<< " segment: " << op.seg_id.segment_index
<< " [ until turn: " << op.enriched.travels_to_ip_index
<< " at: " << next_op.seg_id.segment_index
<< " count: " << point_count_to_next_turn
<< " " << geometry::wkt(next_turn.point)
<< " ]"
<< std::endl;
#endif
// It starts with the distance from the turn to the next point on the segment.
point_type point_of_segment1;
point_type side_changing_point_ahead = turn.point;
bool found = false;
int final_side = 0;
for (auto i = 0; i <= point_count_to_next_turn; i++, offset++)
{
point_type current_point;
if (i == point_count_to_next_turn)
{
current_point = next_turn.point;
}
else
{
geometry::copy_segment_point<Reverse1, Reverse2>(geometry1, geometry2,
op.seg_id, offset, current_point);
}
if (i == 0)
{
point_of_segment1 = current_point;
}
int const side = side_strategy.apply(point_of_segment0, point_of_segment1,
current_point);
#if defined(BOOST_GEOMETRY_DEBUG_GET_PROPERTIES_AHEAD)
std::cout << " " << i << " " << geometry::wkt(current_point)
<< " side: " << side
<< std::endl;
#endif
if (side != 0)
{
found = true;
final_side = side;
break;
}
if (! found)
{
side_changing_point_ahead = current_point;
}
}
op.enriched.ahead_distance_of_side_change
= comparable_distance_strategy.apply(point_of_segment0, side_changing_point_ahead);
op.enriched.ahead_side = final_side;
#if defined(BOOST_GEOMETRY_DEBUG_GET_PROPERTIES_AHEAD)
std::cout << " result: " << op.enriched.ahead_distance_of_side_change
<< " side: " << op.enriched.ahead_side
<< std::endl;
#endif
};
// First examine all clusters (this includes cc turns)
for (const auto& key_value : clusters)
{
auto const& cluster = key_value.second;
for (auto const& index : cluster.turn_indices)
{
auto& turn = turns[index];
for (auto& op : turn.operations)
{
if (op.enriched.travels_to_ip_index == -1)
{
continue;
}
#ifdef BOOST_GEOMETRY_DEBUG_GET_PROPERTIES_AHEAD
std::cout << "Cluster " << turn.cluster_id
<< " turn " << index
<< " " << operation_char(op.operation)
<< " travels to " << op.enriched.travels_to_ip_index
<< std::endl;
#endif
walk_ahead(turn, op);
}
}
}
// Then do the remaining cc turns
for (auto& turn : turns)
{
if (turn.discarded || turn.is_clustered() || ! turn.both(operation_continue))
{
continue;
}
auto& op0 = turn.operations[0];
auto& op1 = turn.operations[1];
// IMPLEMENTATION NOTE:
// This means: it should be called AFTER enrichment.
// Which is called after assigning counts.
if (op0.enriched.travels_to_ip_index == -1 || op1.enriched.travels_to_ip_index == -1)
{
continue;
}
walk_ahead(turn, op0);
walk_ahead(turn, op1);
}
}
}} // namespace detail::overlay
#endif //DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_PROPERTIES_AHEAD_HPP

48
include/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp
View File

@ -168,6 +168,12 @@ struct base_turn_handler
: info.fractions[index].rb;
}
}
#if defined(BOOST_GEOMETRY_CONCEPT_FIX_ARRIVAL)
// Override the assignments above, they are sometimes (but not always) wrong.
ti.operations[0].fraction = info.fractions[index].ra;
ti.operations[1].fraction = info.fractions[index].rb;
#endif
}
template <typename IntersectionInfo>
@ -220,23 +226,22 @@ struct turn_info_verification_functions
bool const p_in_range = index_p < range_p.size();
bool const q_in_range = index_q < range_q.size();
ti.operations[IndexP].remaining_distance
= p_in_range
? distance_measure(ti.point, range_p.at(index_p))
: distance_measure_result_type{0};
ti.operations[IndexQ].remaining_distance
= q_in_range
? distance_measure(ti.point, range_q.at(index_q))
: distance_measure_result_type{0};
std::array<distance_measure_result_type, 2> distance_measures{};
if (p_in_range)
{
distance_measures[IndexP] = distance_measure(ti.point, range_p.at(index_p));
}
if (q_in_range)
{
distance_measures[IndexQ] = distance_measure(ti.point, range_q.at(index_q));
}
if (p_in_range && q_in_range)
{
// pk/q2 is considered as collinear, but there might be
// a tiny measurable difference. If so, use that.
// Calculate pk // qj-qk
bool const p_closer
= ti.operations[IndexP].remaining_distance
< ti.operations[IndexQ].remaining_distance;
bool const p_closer = distance_measures[IndexP] < distance_measures[IndexQ];
auto const dm
= p_closer
? get_distance_measure(range_q.at(index_q - 1),
@ -723,6 +728,7 @@ struct touch : public base_turn_handler
ti.operations[0].operation = operation_blocked;
// Q turns right -> union (both independent),
// Q turns left -> intersection
// NOTE: the block is suspicious!
ti.operations[1].operation = block_q ? operation_blocked
: q_turns_left ? operation_intersection
: operation_union;
@ -736,6 +742,7 @@ struct touch : public base_turn_handler
ui_else_iu(q_turns_left, ti);
if (block_q)
{
// The block is suspicious! It is sometimes wrong!
ti.operations[1].operation = operation_blocked;
}
return;
@ -777,6 +784,15 @@ struct touch : public base_turn_handler
: side_qi_p1 == 1 || side_qk_p1 == 1
? operation_union
: operation_intersection;
#if defined(BOOST_GEOMETRY_CONCEPT_FIX_BLOCK_Q)
// NOTE: this block is suspicious! Override it.
// This concept fix is not complete.
// The exact situation should be adapted.
ti.operations[1].operation = side_qi_p1 == 1 || side_qk_p1 == 1
? operation_union
: operation_intersection;
#endif
if (! block_q)
{
ti.touch_only = true;
@ -1151,16 +1167,6 @@ struct collinear : public base_turn_handler
ui_else_iu(product == 1, ti);
}
// Calculate remaining distance. If it continues collinearly it is
// measured until the end of the next segment
ti.operations[0].remaining_distance
= side_p == 0 && has_pk
? fun::distance_measure(ti.point, range_p.at(2))
: fun::distance_measure(ti.point, range_p.at(1));
ti.operations[1].remaining_distance
= side_q == 0 && has_qk
? fun::distance_measure(ti.point, range_q.at(2))
: fun::distance_measure(ti.point, range_q.at(1));
}
};

120
include/boost/geometry/algorithms/detail/overlay/graph/adapt_operations.hpp Normal file
View File

@ -0,0 +1,120 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ADAPT_OPERATIONS_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ADAPT_OPERATIONS_HPP
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_operation_id.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
// Changes the operation of a UU turn, following a UX turn, to X (blocked)
// under certain conditions, such that it is not followed
// ADAPT: still necessary for just 2 cases. It should be possible to fix it in get_turn_info instead.
// It happens in issue_1100_rev (union) and in ticket_10108 (sym diff)
//
// Situation sketch (issue_1100 reversed - the non reversed version does not need the workaround).
//
// +-----\ +--------+
// | \ | |
// | \ | |
// | + UX |
// | | |
// | P | Q |
// | | |
// | | |
// +---------+--------+
// UU <- This UU turn is wrong, it should be UX
// If it is UU, it will travel right (as designed) and polygon P will
// not be part of the union.
//
template <typename Turns>
void block_ux_uu_workaround(Turns& turns)
{
auto get_op_index = [](auto const& turn, auto&& lambda)
{
for (int i = 0; i < 2; i++)
{
if (lambda(turn.operations[i]))
{
return i;
}
}
return -1;
};
for (std::size_t turn_index = 0; turn_index < turns.size(); turn_index++)
{
auto const& turn = turns[turn_index];
if (turn.is_clustered()
|| turn.discarded
|| turn.is_self()
|| ! turn.combination(operation_blocked, operation_union))
{
continue;
}
auto const blocked_index = get_op_index(turn, [](auto const& op)
{
return op.operation == operation_blocked;
});
auto const& blocked_op = turn.operations[blocked_index];
auto const next_index = blocked_op.enriched.travels_to_ip_index;
if (next_index < 0 || next_index >= static_cast<int>(turns.size()))
{
continue;
}
auto& next_turn = turns[next_index];
if (next_turn.is_self() || ! next_turn.both(operation_union))
{
// If it is a self-turn, they will both have the same source, and both are union.
// The "other source" is then ambiguous.
// It might be handled later, but only with extra conditions.
continue;
}
int const same_source_index = get_op_index(next_turn, [&](auto const& op)
{
return op.seg_id.source_index == blocked_op.seg_id.source_index;
});
if (same_source_index < 0)
{
continue;
}
int const other_index = 1 - same_source_index;
auto& opposite_op = next_turn.operations[other_index];
if (opposite_op.enriched.travels_to_ip_index != static_cast<signed_size_type>(turn_index))
{
// It is not opposite
continue;
}
opposite_op.operation = operation_blocked;
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "BLOCK XU/UU at turns " << turn_index << "/" << next_index << std::endl;
#endif
}
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ADAPT_OPERATIONS_HPP

582
include/boost/geometry/algorithms/detail/overlay/graph/assign_clustered_counts.hpp Normal file
View File

@ -0,0 +1,582 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_CLUSTERED_COUNTS_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_CLUSTERED_COUNTS_HPP
#include <boost/geometry/algorithms/detail/position_code.hpp>
#include <boost/geometry/algorithms/detail/overlay/approximately_equals.hpp>
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/cluster_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
#include <boost/geometry/algorithms/detail/overlay/get_distance_measure.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
#include <set>
#include <map>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
// Indicating if the segment is incoming (to cluster) or outgoing (from cluster)
enum class connection_type { unknown = -1, incoming = 0, outgoing = 1 };
// A turn contains four connections to a cluster:
// For both operations one incoming and one outgoing connection.
// They are stored in a map, with the (segment id, connection type) as key.
struct connection_key
{
segment_identifier seg_id;
connection_type connection{connection_type::unknown};
bool operator<(connection_key const& rhs) const
{
return std::tie(seg_id, connection) < std::tie(rhs.seg_id, rhs.connection);
}
};
// Properties of a connection in a property map
template <typename Point>
struct connection_properties
{
// Assigned at construction time
int position_code{0};
Point point{};
Point opposite_point{};
bool is_shifted{false};
// Assigned later
std::size_t zone_count_left{0};
std::size_t zone_count_right{0};
std::size_t rank{0};
};
// Convenience structure to store connections in a vector
template <typename Point>
struct connection_item
{
connection_key key{};
connection_properties<Point> properties{};
};
template <overlay_type OverlayType>
struct is_corresponding_connection
{
static inline bool apply(connection_key const& left, connection_key const& right)
{
return left.seg_id.source_index == right.seg_id.source_index;
}
};
template <>
struct is_corresponding_connection<overlay_buffer>
{
static inline bool apply(connection_key const& left, connection_key const& right)
{
// For buffer, the source_index is always the same.
// It needs to check where the incoming seg_id is outgoing.
return left.seg_id == right.seg_id;
}
};
template
<
bool Reverse1,
bool Reverse2,
overlay_type OverlayType,
typename Geometry1,
typename Geometry2,
typename Turns,
typename Clusters,
typename Strategy
>
struct clustered_count_handler
{
using point_type = typename Turns::value_type::point_type;
using connection_map_type = std::map<connection_key, connection_properties<point_type>>;
using ct_type = typename geometry::select_most_precise
<
geometry::coordinate_type_t<point_type>,
double
>::type;
clustered_count_handler(Geometry1 const& m_geometry1, Geometry2 const& m_geometry2,
Turns& m_turns, Clusters& clusters,
Strategy const& strategy)
: m_geometry1(m_geometry1)
, m_geometry2(m_geometry2)
, m_turns(m_turns)
, m_clusters(clusters)
, m_intersection_strategy(strategy)
, m_side_strategy(m_intersection_strategy.side())
{}
// Walks over a ring to get the point after the turn.
// The turn can be located at the very end of a segment.
// Therefore it can be the first point on the next segment.
template <typename Operation>
bool get_segment_points(Operation const& op, point_type const& point_turn,
point_type& point_from, point_type& point_to)
{
// Use the coordinate type, but if it is too small (e.g. std::int16), use a double
static const ct_type tolerance
= common_approximately_equals_epsilon_multiplier<ct_type>::value();
// For a defensive check.
constexpr int max_iterations = 10;
int from_offset = 0;
do
{
geometry::copy_segment_point<Reverse1, Reverse2>(m_geometry1, m_geometry2,
op.seg_id, from_offset--, point_from);
} while (approximately_equals(point_from, point_turn, tolerance) && from_offset > -max_iterations);
int to_offset = 1;
do
{
geometry::copy_segment_point<Reverse1, Reverse2>(m_geometry1, m_geometry2,
op.seg_id, to_offset++, point_to);
} while (approximately_equals(point_to, point_turn, tolerance) && to_offset < max_iterations);
return from_offset < -1 || to_offset > 2;
}
void get_connection_map(cluster_info const& cluster, point_type const& point_turn,
connection_map_type& connection_map, point_type& point_origin)
{
auto const get_position_code = [&](point_type const& point)
{
return detail::get_position_code(point_origin, point_turn, point, m_side_strategy);
};
auto insert = [&connection_map](auto const& op, connection_type conn,
auto const& point, int position_code, auto const& opposite_point, bool is_shifted)
{
connection_key const key{op.seg_id, conn};
connection_properties<point_type> properties{position_code, point, opposite_point, is_shifted};
connection_map.insert({key, properties});
};
// Add them to the set, which keeps them unique on (seg_id,from/to)
bool first = true;
for (std::size_t index : cluster.turn_indices)
{
auto const& turn = m_turns[index];
for (auto const& op : turn.operations)
{
point_type point_from, point_to;
bool const is_shifted = get_segment_points(op, point_turn, point_from, point_to);
if (first)
{
// One of the incoming points is the origin. For the algorithm,
// it does not matter which one.
first = false;
point_origin = point_from;
}
// Insert the four connections. Insert all operations (even if they are blocked).
insert(op, connection_type::incoming, point_from, get_position_code(point_from), point_to, is_shifted);
insert(op, connection_type::outgoing, point_to, get_position_code(point_to), point_from, is_shifted);
}
}
}
void sort(point_type const& point_turn, std::vector<connection_item<point_type>>& item_vector)
{
auto compare_by_connection = [](auto const& left, auto const& right)
{
// Reversing it gives only one failure in ticket_9942 (difference)...
return left.key.connection > right.key.connection;
};
// Compare by side, then by connection.
// Left-side (1) goes before right-side (-1).
// Outgoing (1) goes before incoming (0).
auto compare_by_side = [&](auto const& left, auto const& right)
{
int const side_left = m_side_strategy.apply(point_turn, right.properties.point, left.properties.point);
int const side_right = m_side_strategy.apply(point_turn, left.properties.point, right.properties.point);
if (side_right == side_left)
{
return compare_by_connection(left, right);
}
return side_left < side_right;
};
std::sort(item_vector.begin(), item_vector.end(),
[&](auto const& left, auto const& right)
{
if (left.properties.position_code == right.properties.position_code)
{
if (left.properties.position_code == 1 || left.properties.position_code == 3)
{
// For collinear cases, side is be the same.
return compare_by_connection(left, right);
}
return compare_by_side(left, right);
}
return left.properties.position_code < right.properties.position_code;
});
}
// Assign ranks, counter clockwise from the first incoming segment.
void assign_ranks(point_type const& point_turn,
std::vector<connection_item<point_type>>& item_vector)
{
std::size_t rank = 0;
item_vector.front().properties.rank = 0;
for (std::size_t i = 0; i + 1 < item_vector.size(); i++)
{
auto const& previous = item_vector[i];
auto& item = item_vector[i + 1];
if (item.properties.position_code != previous.properties.position_code)
{
item.properties.rank = ++rank;
continue;
}
if (item.properties.position_code == 1 || item.properties.position_code == 3)
{
// Collinear cases always get the same rank.
item.properties.rank = rank;
continue;
}
// If it is collinear, it gets the same rank.
// In other cases the side should be 1 (left) because the connections
// are sorted counter clockwise.
int const side = m_side_strategy.apply(point_turn, previous.properties.point,
item.properties.point);
item.properties.rank = side == 0 ? rank : ++rank;
}
}
auto get_zone_counts(std::vector<connection_item<point_type>> const& item_vector,
std::size_t rank_size)
{
std::size_t const vector_size = item_vector.size();
auto get_next_item = [&vector_size](std::size_t counter)
{
return (counter + 1) % vector_size;
};
auto get_next_zone = [&rank_size](std::size_t counter)
{
return (counter + 1) % rank_size;
};
// Each segment occurs twice, once as from, once as to.
// As soon as it comes in, increase the zone count, until it goes out.
std::vector<std::size_t> zone_counts(rank_size, 0);
for (std::size_t i = 0; i < item_vector.size(); i++)
{
auto const& item = item_vector[i];
if (item.key.connection != connection_type::incoming)
{
continue;
}
// Walk ahead, cyclic, to find the next item with the same seg_id.
// The iteration is a defensive check.
std::size_t end_rank = item.properties.rank;
for (std::size_t j = get_next_item(i), iteration = 0; ; j = get_next_item(j), iteration++)
{
if (iteration > vector_size)
{
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cerr << " *** ERROR: infinite loop in cluster" << std::endl;
#endif
return zone_counts;
}
auto const& next = item_vector[j];
end_rank = next.properties.rank;
if (next.key.connection == connection_type::outgoing
&& is_corresponding_connection<OverlayType>::apply(item.key, next.key))
{
// Found the corresponding outgoing segment for this incoming segment.
break;
}
}
// Assign the ring count to the zone_counts in the rank range.
for (std::size_t r = item.properties.rank; r != end_rank; r = get_next_zone(r))
{
zone_counts[r]++;
}
}
return zone_counts;
}
void assign_zone_counts(std::vector<connection_item<point_type>>& item_vector,
std::vector<std::size_t> const& zone_counts, std::size_t rank_size)
{
// The main goal is to get the number of polygons in the zone_counts.
// The zone_counts on the right side of the seg_ids.
for (auto& item : item_vector)
{
std::size_t const zone_right =
item.key.connection == connection_type::incoming
? item.properties.rank
: (item.properties.rank + rank_size - 1) % rank_size;
std::size_t const zone_left =
item.key.connection == connection_type::incoming
? (item.properties.rank + rank_size - 1) % rank_size
: item.properties.rank;
item.properties.zone_count_left = zone_counts[zone_left];
item.properties.zone_count_right = zone_counts[zone_right];
}
}
std::size_t get_open_count(std::vector<std::size_t> const& zone_counts, std::size_t rank_size)
{
std::size_t result = 0;
for (std::size_t i = 0; i < rank_size; i++)
{
if (zone_counts[i] == 0)
{
result++;
}
}
return result;
}
// Get the number of spikes in a cluster, and mark them as spikes.
void handle_spikes(cluster_info& cluster, std::vector<connection_item<point_type>>& item_vector)
{
for (std::size_t i = 0; i < item_vector.size(); i++)
{
auto const next_i = (i + 1) % item_vector.size();
if (item_vector[i].key.connection == item_vector[next_i].key.connection)
{
// The connection should be different
continue;
}
auto& current = item_vector[i].properties;
auto& next = item_vector[next_i].properties;
if (current.rank != next.rank
|| current.zone_count_left != 1 || current.zone_count_right != 1
|| next.zone_count_left != 1 || next.zone_count_right != 1)
{
// The rank should be the same
// It should have one zone on either side
continue;
}
if (current.is_shifted || next.is_shifted) {
// The opposite point is shifted. Therefore a spike measurement
// cannot be done.
continue;
}
// Precise measurement, not from the turn, but over the whole intersecting segment.
// If it is positive (on the left side), it is a spike.
auto const dm = get_distance_measure(current.opposite_point, current.point, next.point,
m_intersection_strategy);
if (dm.measure <= 0)
{
continue;
}
// There is a small measurable difference.
// Make the cluster open and adapt the counts.
cluster.open_count++;
current.zone_count_left = 0;
next.zone_count_right = 0;
}
}
void assign_turn_operations(cluster_info const& cluster,
connection_map_type const& connection_map)
{
// Assign the items, per seg_id, back to the outgoing turn operations.
for (std::size_t index : cluster.turn_indices)
{
auto& turn = m_turns[index];
for (int i = 0; i < 2; i++)
{
auto& op = turn.operations[i];
connection_key const key{op.seg_id, connection_type::outgoing};
auto const it = connection_map.find(key);
if (it != connection_map.end())
{
op.enriched.count_left = it->second.zone_count_left;
op.enriched.count_right = it->second.zone_count_right;
op.enriched.rank = it->second.rank;
}
}
}
}
// Currently necessary for some failing cases in buffer only, where due to floating point
// precision the i/u turns get unexpected counts for left/right.
// rt_w10, rt_w11, rt_w14, rt_w15
// The original sides are measured over the two whole intersecting segments.
// The sides in clusters are measured w.r.t. the turn point, which is the point of the first cluster.
// This can differ.
// It should be possible to fix it in another way.
void change_reversed_operations(signed_size_type const cluster_id, cluster_info const& cluster,
point_type const& point_turn, point_type const& point_origin)
{
std::set<std::size_t> reversed_indices;
for (std::size_t index : cluster.turn_indices)
{
auto const& turn = m_turns[index];
if (! turn.combination(operation_union, operation_intersection))
{
continue;
}
int const union_index = turn.operations[0].operation == operation_union ? 0 : 1;
auto const& op_u = turn.operations[union_index];
auto const& op_i = turn.operations[1 - union_index];
if (op_u.enriched.count_left > 0 && op_i.enriched.count_left == 0)
{
reversed_indices.insert(index);
}
}
if (reversed_indices.empty())
{
return;
}
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << " *** REVERSED OPERATIONS in cluster: " << cluster_id
<< " cluster size: " << cluster.turn_indices.size()
<< " reversed: " << reversed_indices.size()
<< std::endl;
#endif
for (std::size_t index : cluster.turn_indices)
{
auto& turn = m_turns[index];
auto& op0 = turn.operations[0];
auto& op1 = turn.operations[1];
bool const is_same_target = op0.enriched.travels_to_ip_index == op1.enriched.travels_to_ip_index;
if (is_same_target && reversed_indices.find(index) != reversed_indices.end())
{
// Best choice: i/u are nearly collinear, so we can let them continue.
op0.operation = operation_continue;
op1.operation = operation_continue;
// Also adapt the left/right-counts, both should get the minimum of both.
op0.enriched.count_left = (std::min)(op0.enriched.count_left, op1.enriched.count_left);
op1.enriched.count_left = op0.enriched.count_left;
op0.enriched.count_right = (std::min)(op0.enriched.count_right, op1.enriched.count_right);
op1.enriched.count_right = op0.enriched.count_right;
}
}
}
template <typename Visitor>
void apply(signed_size_type const cluster_id, cluster_info& cluster, Visitor& visitor)
{
if (cluster.turn_indices.empty())
{
// Defensive check.
return;
}
point_type const& point_turn = m_turns[*cluster.turn_indices.begin()].point;
point_type point_origin;
connection_map_type connection_map;
get_connection_map(cluster, point_turn, connection_map, point_origin);
// Sort the items by position code, and if equal, by side.
// For this they are copied into a vector.
std::vector<connection_item<point_type>> item_vector;
for (auto const& key_value : connection_map)
{
connection_item<point_type> item;
item.key = key_value.first;
item.properties = key_value.second;
item_vector.push_back(std::move(item));
}
sort(point_turn, item_vector);
assign_ranks(point_turn, item_vector);
auto const rank_size = item_vector.back().properties.rank + 1;
auto const zone_counts = get_zone_counts(item_vector, rank_size);
assign_zone_counts(item_vector, zone_counts, rank_size);
cluster.open_count = get_open_count(zone_counts, rank_size);
if (cluster.open_count == 0)
{
handle_spikes(cluster, item_vector);
}
// Assign the updated properties back to the connection map
for (auto const& item : item_vector)
{
connection_map[item.key] = item.properties;
}
assign_turn_operations(cluster, connection_map);
change_reversed_operations(cluster_id, cluster, point_turn, point_origin);
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
// List the connections
std::cout << "Cluster " << cluster_id << " size: " << cluster.turn_indices.size() << std::endl;
for (auto const& item : item_vector)
{
std::cout << " " << item.key.seg_id
<< " " << (item.key.connection == connection_type::incoming ? " in" : "out")
<< " " << item.properties.position_code
<< " " << item.properties.rank
<< " " << item.properties.zone_count_left
<< " " << item.properties.zone_count_right
<< std::endl;
}
#endif
visitor.visit_cluster_connections(cluster_id, m_turns, cluster, item_vector);
}
template <typename Visitor>
void apply(Visitor& visitor)
{
for (auto& key_value : m_clusters)
{
auto& cluster = key_value.second;
if (cluster.turn_indices.empty())
{
continue;
}
apply(key_value.first, cluster, visitor);
}
}
private:
Geometry1 const& m_geometry1;
Geometry2 const& m_geometry2;
Turns& m_turns;
Clusters& m_clusters;
Strategy const& m_intersection_strategy;
decltype(m_intersection_strategy.side()) m_side_strategy;
};
}} // namespace detail::overlay
#endif //DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CLUSTER_INFO_HPP

162
include/boost/geometry/algorithms/detail/overlay/graph/assign_counts.hpp Normal file
View File

@ -0,0 +1,162 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_COUNTS_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_COUNTS_HPP
#include <boost/geometry/algorithms/detail/overlay/cluster_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_operation_id.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
template <typename Turns, typename Clusters>
void assign_clustered_self_counts(Turns& turns, Clusters const& clusters)
{
auto is_self_cluster = [&turns](auto const& cinfo)
{
return std::all_of(cinfo.turn_indices.cbegin(), cinfo.turn_indices.cend(),
[&](auto index) { return turns[index].is_self(); });
};
for (auto const& cluster : clusters)
{
if (! is_self_cluster(cluster.second))
{
continue;
}
// If a cluster only contains self-intersections, their previously assigned right counts
// should be adapted, they are within the other geometry,
// and otherwise they were discarded already in handle_self_turns
for (auto index : cluster.second.turn_indices)
{
for (auto& op : turns[index].operations)
{
op.enriched.count_right += 1;
}
}
}
}
template <typename Turn>
void assign_counts(Turn& turn)
{
using counts_per_op_t = std::pair<operation_type, std::size_t>;
auto assign_left = [&turn](std::size_t count)
{
for (auto& op : turn.operations)
{
op.enriched.count_left = count;
}
};
auto assign_right = [&turn](std::size_t count)
{
for (auto& op : turn.operations)
{
op.enriched.count_right = count;
}
};
auto assign_for = [&turn](counts_per_op_t const& op1, counts_per_op_t op2, auto&& assign)
{
for (auto& op : turn.operations)
{
if (op.operation == op1.first) { assign(op.enriched, op1.second); }
else if (op.operation == op2.first) { assign(op.enriched, op2.second); }
}
};
auto assign_left_for = [&turn, &assign_for](counts_per_op_t const& op1, counts_per_op_t op2)
{
assign_for(op1, op2, [](auto& enriched, auto count) { enriched.count_left = count; });
};
auto assign_right_for = [&turn, &assign_for](counts_per_op_t const& op1, counts_per_op_t op2)
{
assign_for(op1, op2, [](auto& enriched, auto count) { enriched.count_right = count; });
};
auto assign_left_incoming_for = [&turn, &assign_for](counts_per_op_t const& op1, counts_per_op_t op2)
{
assign_for(op1, op2, [](auto& enriched, auto count) { enriched.count_left_incoming = count; });
};
auto assign_right_incoming_for = [&turn, &assign_for](counts_per_op_t const& op1, counts_per_op_t op2)
{
assign_for(op1, op2, [](auto& enriched, auto count) { enriched.count_right_incoming = count; });
};
if (turn.combination(operation_intersection, operation_union))
{
assign_left_for({operation_union, 0}, {operation_intersection, 1});
assign_right_for({operation_union, 1}, {operation_intersection, 2});
// For i/u (either originating from a "cross" or from a touch, but the segments cross
// one another), the incoming counts can be assigned.
// For other operations, this is not trivial (without retrieving the geometry).
// It is only necessary for some collinear cases to see how they arrive at the target.
// If it is not available, distance ahead is used.
assign_left_incoming_for({operation_union, 1}, {operation_intersection, 0});
assign_right_incoming_for({operation_union, 2}, {operation_intersection, 1});
}
else if (turn.combination(operation_blocked, operation_union))
{
assign_left_for({operation_union, 0}, {operation_blocked, 1});
assign_right(1);
}
else if (turn.combination(operation_blocked, operation_intersection))
{
assign_left(1);
assign_right_for({operation_blocked, 1}, {operation_intersection, 2});
}
else if (turn.both(operation_continue))
{
assign_left(0);
assign_right(2);
}
else if (turn.both(operation_union))
{
assign_left(0);
assign_right(1);
}
else if (turn.both(operation_intersection))
{
assign_left(1);
assign_right(2);
}
}
template <typename Turns>
void assign_unclustered_counts(Turns& turns)
{
for (auto& turn : turns)
{
if (turn.is_clustered() || turn.discarded)
{
continue;
}
assign_counts(turn);
}
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_COUNTS_HPP

63
include/boost/geometry/algorithms/detail/overlay/graph/assign_side_counts.hpp Normal file
View File

@ -0,0 +1,63 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_SIDE_COUNTS_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_SIDE_COUNTS_HPP
#include <boost/geometry/algorithms/detail/overlay/graph/assign_counts.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/assign_clustered_counts.hpp>
#include <boost/geometry/algorithms/detail/overlay/handle_self_turns.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
template
<
bool Reverse1,
bool Reverse2,
overlay_type OverlayType,
typename Geometry1,
typename Geometry2,
typename Turns,
typename Clusters,
typename IntersectionStrategy,
typename Visitor
>
void assign_side_counts(Geometry1 const& geometry1, Geometry2 const& geometry2,
Turns& turns, Clusters& clusters,
IntersectionStrategy const& intersection_strategy, Visitor& visitor)
{
clustered_count_handler
<
Reverse1, Reverse2, OverlayType,
Geometry1, Geometry2,
Turns, Clusters,
IntersectionStrategy
> processor(geometry1, geometry2, turns, clusters, intersection_strategy);
processor.apply(visitor);
if (OverlayType != overlay_buffer)
{
// Increase right-count for self-intersections. This should not be called for buffers
// (for buffers, all is self-cluster)
assign_clustered_self_counts(turns, clusters);
}
assign_unclustered_counts(turns);
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_SIDE_COUNTS_HPP

112
include/boost/geometry/algorithms/detail/overlay/graph/debug_graph.hpp Normal file
View File

@ -0,0 +1,112 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DEBUG_GRAPH_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DEBUG_GRAPH_HPP
#include <boost/geometry/core/access.hpp>
#include <ostream>
#include <iostream>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
// For debug purposes only
template <typename Turns, typename Clusters, typename Graph, typename Components, typename VertexMap>
void write_graph_viz(std::ostream& out, Turns const& turns, Clusters const& clusters,
Graph const& g, Components const& component, VertexMap const& vertex_map,
bool use_absolute_position = true)
{
out << "graph A {\n node[shape=\"circle\"]\n";
auto add_pos = [&](auto const& point)
{
out << ", pos=\"" << geometry::get<0>(point) << "," << geometry::get<1>(point) << "!\"";
};
// List all nodes
for (auto const& vertex_pair : vertex_map)
{
auto const& vertex = vertex_pair.second;
out << vertex.node_id << "[label=\"" << vertex.node_id << "\"";
if (use_absolute_position)
{
if (vertex.node_id < 0)
{
// Use any point from the cluster
auto it = clusters.find(vertex.node_id);
if (it != clusters.end())
{
auto const& cluster = it->second;
if (! cluster.turn_indices.empty())
{
add_pos(turns[*cluster.turn_indices.begin()].point);
}
}
}
else if (vertex.node_id < static_cast<int>(turns.size()))
{
add_pos(turns[vertex.node_id].point);
}
else if (vertex.original_node_id >= 0 && vertex.original_node_id < turns.size())
{
// It is an extra node. It should be placed somewhere in the neighborhood
// of the connected node. Where depends on the situation, it is currently not worth
// the effort to get that. Just displace it a bit to the lower left.
auto point = turns[vertex.original_node_id].point;
geometry::set<0>(point, geometry::get<0>(point) - 1.0);
geometry::set<1>(point, geometry::get<1>(point) - 1.0);
add_pos(point);
}
}
out << "]\n";
}
typename graph_traits<Graph>::edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
auto const source_vertex = source(*ei, g);
auto const target_vertex = target(*ei, g);
auto it_source = vertex_map.find(source_vertex);
auto it_target = vertex_map.find(target_vertex);
if (it_source == vertex_map.end() || it_target == vertex_map.end())
{
std::cerr << "Edge not found FOR GRAPH_VIZ "
<< source_vertex << " -- " << target_vertex
<< std::endl;
continue;
}
auto const source_node_id = it_source->second.node_id;
auto const target_node_id = it_target->second.node_id;
out << source_node_id << " -- " << target_node_id
<< "[label=\""
//<< source_node_id << ".." << target_node_id << " ("
<< component[*ei]
// << ")"
<< "\"]"
<< '\n';
}
out << "}\n";
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DEBUG_GRAPH_HPP

276
include/boost/geometry/algorithms/detail/overlay/graph/detect_biconnected_components.hpp Normal file
View File

@ -0,0 +1,276 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DETECT_ARTICULATION_POINTS_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DETECT_ARTICULATION_POINTS_HPP
#include <map>
#include <set>
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/node_util.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/graph_util.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/debug_graph.hpp>
#include <boost/graph/biconnected_components.hpp>
#include <boost/graph/adjacency_list.hpp>
#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
#include <boost/geometry/core/exception.hpp>
#include <boost/throw_exception.hpp>
#endif
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
#include <fstream>
#endif
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
struct vertex_info
{
signed_size_type node_id{0};
set_of_size_t target_vertex_indices;
bool is_extra{false};
// For extra nodes, also store the original node
signed_size_type original_node_id{0};
};
struct state_type
{
// Using a flatmap changes behavior and cause errors.
// Using an ordered map gives a just a tiny bit of performance improvement, sometimes.
// Maps from vertex to vertex info
std::map<std::size_t, vertex_info> vertex_map;
// Reverse mapping. Every node (turn or cluster) has only ONE vertex,
// but there might be so called "extra" vertices, not associated with a node.
std::map<signed_size_type, std::size_t> node_to_vertex_index;
// For each edge, store the segment identifier
std::map<std::pair<std::size_t, std::size_t>, segment_identifier> edge_to_seg_id;
// Keeps track of vertex index, which must, for Boost.Graph, be consecutive.
// The turn index is not consecutive (because of discarded, and of clusters).
std::size_t vertex_index{0};
// For round-trips extra nodes are inserted.
// Round-trips are operations returning to itself, for example in some uu cases.
// They are numbered from turn.size() and up, such that they have a unique positive id.
std::size_t extra_node_id{0};
};
inline void add_edge(signed_size_type source_node_id, signed_size_type target_node_id,
segment_identifier const& seg_id, state_type& state)
{
// Insert the source and target node (turn or cluster)
auto it_source = state.node_to_vertex_index.find(source_node_id);
if (it_source == state.node_to_vertex_index.end())
{
it_source = state.node_to_vertex_index.insert({source_node_id, state.vertex_index++}).first;
}
auto it_target = state.node_to_vertex_index.find(target_node_id);
if (it_target == state.node_to_vertex_index.end())
{
it_target = state.node_to_vertex_index.insert({target_node_id, state.vertex_index++}).first;
// Get the accompanying vertex info (might be a new record)
auto& target_vertex_info = state.vertex_map[it_target->second];
target_vertex_info.node_id = target_node_id;
}
// Get the accompanying vertex info (might be a new record)
// and store node and the segment id for this edge
auto& vertex_info = state.vertex_map[it_source->second];
vertex_info.node_id = source_node_id;
state.edge_to_seg_id[{it_source->second, it_target->second}] = seg_id;
if (target_node_id != source_node_id)
{
// The normal case, Not a round trip
vertex_info.target_vertex_indices.insert(it_target->second);
return;
}
// For a round trip, add an extra vertex.
// It is not necessary to add them to the node_to_vertex_index,
// because they won't be looked up further.
std::size_t const extra_node_id = state.extra_node_id++;
std::size_t const extra_vertex_index = state.vertex_index++;
// Store the segment id in both of these edges
auto& extra_vertex_info = state.vertex_map[extra_vertex_index];
extra_vertex_info.node_id = extra_node_id;
state.edge_to_seg_id[{it_source->second, extra_vertex_index}] = seg_id;
state.edge_to_seg_id[{extra_vertex_index, it_target->second}] = seg_id;
extra_vertex_info.is_extra = true;
extra_vertex_info.original_node_id = source_node_id;
extra_vertex_info.target_vertex_indices.insert(it_target->second);
vertex_info.target_vertex_indices.insert(extra_vertex_index);
}
template <operation_type TargetOperation, typename Turns, typename Clusters>
void fill_vertex_map(Turns const& turns, Clusters const& clusters, state_type& state)
{
std::set<edge_info> edges;
for (auto const& key_value : clusters)
{
// The node id is negative for clusters
auto const cluster_node_id = -key_value.first;
auto const& cluster = key_value.second;
for (std::size_t turn_index : cluster.turn_indices)
{
auto const& turn = turns[turn_index];
get_target_operations<TargetOperation>(turns, turn, turn_index, cluster_node_id, edges);
}
}
for (std::size_t i = 0; i < turns.size(); i++)
{
auto const& turn = turns[i];
if (turn.discarded || turn.is_clustered())
{
continue;
}
get_target_operations<TargetOperation>(turns, turn, i, i, edges);
}
for (auto const& edge : edges)
{
add_edge(edge.source_node_id, edge.target_node_id, edge.seg_id, state);
}
}
// Assigns biconnected components to turns
template <typename Turns, typename Clusters, typename Graph, typename Components>
void assign_biconnected_component_ids(Turns& turns, Clusters const& clusters, bool allow_closed,
Graph const& graph, Components const& component, state_type const& state)
{
auto node_id_from_it = [&state](auto const& it)
{
return it->second.is_extra
? it->second.original_node_id
: it->second.node_id;
};
typename graph_traits<Graph>::edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = edges(graph); ei != ei_end; ++ei)
{
auto it_source = state.vertex_map.find(source(*ei, graph));
auto it_target = state.vertex_map.find(target(*ei, graph));
if (it_source == state.vertex_map.end() || it_target == state.vertex_map.end())
{
#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
BOOST_THROW_EXCEPTION(logic_exception("Edge not found in vertex map"));
#endif
continue;
}
auto const source_node_id = node_id_from_it(it_source);
auto const target_node_id = node_id_from_it(it_target);
auto const edge_seg_id = state.edge_to_seg_id.at({source(*ei, graph), target(*ei, graph)});
auto const turn_indices = get_turn_indices_by_node_id(turns, clusters, source_node_id,
allow_closed);
// Assign the component to all the operations
// going from the source node to the target node.
for (auto const& turn_index : turn_indices)
{
auto& turn = turns[turn_index];
for (std::size_t j = 0; j < 2; j++)
{
auto& op = turn.operations[j];
if (op.enriched.travels_to_ip_index < 0)
{
continue;
}
auto const travels_to_node_id = get_node_id(turns, op.enriched.travels_to_ip_index);
if (travels_to_node_id == target_node_id && op.seg_id == edge_seg_id)
{
op.enriched.component_id = static_cast<int>(component[*ei]);
if (turn.both(operation_continue))
{
// For cc, always set both operations (only one of them is returned by get_node_id)
auto& other_op = turn.operations[1 - j];
other_op.enriched.component_id = op.enriched.component_id;
}
}
}
}
}
}
template <operation_type TargetOperation, typename Turns, typename Clusters>
void detect_biconnected_components(Turns& turns, Clusters const& clusters)
{
using graph_t = boost::adjacency_list
<
boost::vecS,
boost::vecS,
boost::undirectedS,
boost::no_property,
boost::property<edge_component, std::size_t>
>;
// Mapping to add turns to vertices, count them, and then build the graph.
// (It is convenient if the vertex index is the same as the turn index.
// Therefore the default mapping is made like that, extra vertices
// are added later)
state_type state;
state.extra_node_id = static_cast<std::size_t>(turns.size());
fill_vertex_map<TargetOperation>(turns, clusters, state);
// Build the graph from the vertices
graph_t graph(state.vertex_map.size());
for (auto const& key_value : state.vertex_map)
{
auto const vertex_index = key_value.first;
for (auto const target_vertex_index : key_value.second.target_vertex_indices)
{
boost::add_edge(vertex_index, target_vertex_index, graph);
}
}
edge_component ec;
auto component = boost::get(ec, graph);
biconnected_components(graph, component);
fix_components(component, graph);
assign_biconnected_component_ids(turns, clusters,
TargetOperation == operation_intersection,
graph, component, state);
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
{
std::ofstream out("/tmp/graph_viz.dot");
write_graph_viz(out, turns, clusters, graph, component, state.vertex_map);
}
#endif
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DETECT_ARTICULATION_POINTS_HPP

54
include/boost/geometry/algorithms/detail/overlay/graph/fill_ring_turn_info_map.hpp Normal file
View File

@ -0,0 +1,54 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_FILL_RING_TURN_INFO_MAP_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_FILL_RING_TURN_INFO_MAP_HPP
#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
template <typename TurnInfoMap, typename Turns>
void update_ring_turn_info_map(TurnInfoMap& ring_turn_info_map, Turns const& turns)
{
for (auto const& turn : turns)
{
for (int i = 0; i < 2; i++)
{
auto const& op = turn.operations[i];
if (op.enriched.is_traversed)
{
ring_identifier const ring_id = ring_id_by_seg_id(op.seg_id);
ring_turn_info_map[ring_id].has_traversed_turn = true;
if (op.operation == operation_continue)
{
// Continue operations should mark the other operation
// as traversed too
auto const& other_op = turn.operations[1 - i];
ring_identifier const other_ring_id = ring_id_by_seg_id(other_op.seg_id);
ring_turn_info_map[other_ring_id].has_traversed_turn = true;
}
}
}
}
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_FILL_RING_TURN_INFO_MAP_HPP

131
include/boost/geometry/algorithms/detail/overlay/graph/get_tois.hpp Normal file
View File

@ -0,0 +1,131 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TOIS_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TOIS_HPP
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/is_operation_included.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/node_util.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
template <operation_type TargetOperation, typename Turns, typename Clusters>
void add_tois(Turns const& turns, Clusters const& clusters,
signed_size_type source_node_id, signed_size_type target_node_id,
set_of_tois& result)
{
using is_included = is_operation_included<TargetOperation>;
auto get_tois_from_turns = [&](std::size_t const source_index, std::size_t const target_index)
{
for (int i = 0; i < 2; i++)
{
auto const& op = turns[source_index].operations[i];
if (op.enriched.travels_to_ip_index == static_cast<signed_size_type>(target_index)
&& is_included::apply(op))
{
turn_operation_id const toi{source_index, i};
if (is_target_operation<TargetOperation>(turns, toi))
{
result.insert(std::move(toi));
}
}
}
};
constexpr bool allow_closed = TargetOperation == operation_intersection;
if (source_node_id >= 0 && target_node_id >= 0)
{
get_tois_from_turns(source_node_id, target_node_id);
}
else if (source_node_id < 0 && target_node_id >= 0)
{
const auto source_turn_indices = get_turn_indices_by_node_id(turns, clusters,
source_node_id, allow_closed);
for (auto source_turn_index : source_turn_indices)
{
get_tois_from_turns(source_turn_index, target_node_id);
}
}
else if (source_node_id >= 0 && target_node_id < 0)
{
const auto target_turn_indices = get_turn_indices_by_node_id(turns, clusters,
target_node_id, allow_closed);
for (auto target_turn_index : target_turn_indices)
{
get_tois_from_turns(source_node_id, target_turn_index);
}
}
else
{
// Combine two sets together, quadratically
const auto source_turn_indices = get_turn_indices_by_node_id(turns, clusters,
source_node_id, allow_closed);
const auto target_turn_indices = get_turn_indices_by_node_id(turns, clusters,
target_node_id, allow_closed);
for (auto source_turn_index : source_turn_indices)
{
for (auto target_turn_index : target_turn_indices)
{
get_tois_from_turns(source_turn_index, target_turn_index);
}
}
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
// This happens, for example, in multi line cases where lines are on top of each other.
// Then there will be many turns, and many clusters with many turns.
// It gives listings like:
// quadratic: -272 -> -273 sizes 55 x 55 = 110
// It is currently probably not worth to cache these cases, as these are rare cases.
// In the bitset_grids robustness test, the clusters are small and the listings are like:
// quadratic: -5 -> -1 sizes 2 x 3 = 1
std::cout << "quadratic: "
<< source_node_id << " -> " << target_node_id
<< " sizes " << source_turn_indices.size() << " x " << target_turn_indices.size()
<< " = " << result.size()
<< std::endl;
#endif
}
}
// Variant with one node
template <operation_type TargetOperation, typename Turns, typename Clusters>
set_of_tois get_tois(Turns const& turns, Clusters const& clusters,
signed_size_type source_node_id, signed_size_type target_node_id)
{
set_of_tois result;
add_tois<TargetOperation>(turns, clusters, source_node_id, target_node_id, result);
return result;
}
// Variant with multiple target nodes
template <operation_type TargetOperation, typename Turns, typename Clusters>
set_of_tois get_tois(Turns const& turns, Clusters const& clusters,
signed_size_type source_node_id, std::set<signed_size_type> const& target_node_ids)
{
set_of_tois result;
for (auto const& target : target_node_ids)
{
add_tois<TargetOperation>(turns, clusters, source_node_id, target, result);
}
return result;
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TOIS_HPP

62
include/boost/geometry/algorithms/detail/overlay/graph/graph_util.hpp Normal file
View File

@ -0,0 +1,62 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GRAPH_UTIL_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GRAPH_UTIL_HPP
#include <boost/graph/biconnected_components.hpp>
#include <boost/graph/adjacency_list.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
struct edge_component
{
using kind = edge_property_tag;
};
// It appears that in an undirected graph, the components for two edges are sometimes different.
// It happens a lot in the unit tests, for example in test case "#case_recursive_boxes_93"
// Fix that. To be found out why this is.
template <typename Graph, typename Components>
void fix_components(Components& components, Graph const& g)
{
typename graph_traits<Graph>::edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
auto& component = components[*ei];
auto const source_vertex = source(*ei, g);
auto const target_vertex = target(*ei, g);
// Get the reverse edge and its component
auto const reverse_edge_pair = edge(target_vertex, source_vertex, g);
if (! reverse_edge_pair.second)
{
continue;
}
auto& reverse_component = components[reverse_edge_pair.first];
if (component != reverse_component)
{
component = reverse_component;
}
}
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GRAPH_UTIL_HPP

50
include/boost/geometry/algorithms/detail/overlay/graph/is_operation_included.hpp Normal file
View File

@ -0,0 +1,50 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GRAPH_IS_OPERATION_INCLUDED_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GRAPH_IS_OPERATION_INCLUDED_HPP
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
template <operation_type target_operation>
struct is_operation_included {};
template <>
struct is_operation_included<operation_intersection>
{
template <typename Operation>
static bool apply(Operation const& op)
{
return op.enriched.count_right >= 2;
}
};
template <>
struct is_operation_included<operation_union>
{
template <typename Operation>
static bool apply(Operation const& op)
{
return op.enriched.count_left == 0;
}
};
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GRAPH_IS_OPERATION_INCLUDED_HPP

215
include/boost/geometry/algorithms/detail/overlay/graph/is_target_operation.hpp Normal file
View File

@ -0,0 +1,215 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GRAPH_IS_TARGET_OPERATION_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GRAPH_IS_TARGET_OPERATION_HPP
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_operation_id.hpp>
#include <set>
#include <utility>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
// For continue/continue cases where one of the targets
// is the same as a target of the other target.
// If is_target_ahead_op == true:
// CC turn -------> target_op -----> target_other
// ------------------------> target_other
// In this case, take the target_op
template <typename Turns>
std::pair<bool, bool> is_cc_target_ahead(Turns const& turns, turn_operation_id const& toi)
{
auto const& turn = turns[toi.turn_index];
auto const& op = turn.operations[toi.operation_index];
auto const& other_op = turn.operations[1 - toi.operation_index];
auto const target_op = op.enriched.travels_to_ip_index;
auto const target_other = other_op.enriched.travels_to_ip_index;
auto const nop_result = std::make_pair(false, false);
if (target_op < 0 || target_other < 0 || target_op == target_other)
{
return nop_result;
}
if (turn.is_clustered()
&& (turns[target_op].cluster_id == turn.cluster_id
|| turns[target_other].cluster_id == turn.cluster_id))
{
return nop_result;
}
auto has_target = [](auto const& turn, signed_size_type target)
{
return turn.operations[0].enriched.travels_to_ip_index == target
|| turn.operations[1].enriched.travels_to_ip_index == target;
};
bool const is_target_ahead_op = has_target(turns[target_op], target_other);
bool const is_target_ahead_other = has_target(turns[target_other], target_op);
if (is_target_ahead_op == is_target_ahead_other)
{
// It is not so that one is the target of the operation of the other,
// or it is the case for both of them (this cannot be handled or
// it does not occur).
return nop_result;
}
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "Decide for turn " << toi.turn_index << " " << toi.operation_index
<< " targets: " << target_op
<< " / " << target_other
<< " clusters: " << turns[target_op].cluster_id
<< " / " << turns[target_other].cluster_id
<< " via " << std::boolalpha << is_target_ahead_op << " / " << is_target_ahead_other
<< std::endl;
#endif
return std::make_pair(true, is_target_ahead_op);
}
template <typename Operation>
bool is_better_collinear_for_union(Operation const& op, Operation const& other_op,
turn_operation_id const& toi, turn_operation_id const& other_toi)
{
// Continue, prefer the one having no polygon on the left
if (op.enriched.count_left > 0 && other_op.enriched.count_left == 0)
{
return false;
}
if (op.enriched.count_left == 0 && other_op.enriched.count_left > 0)
{
return true;
}
// For union the cc target ahead should not be called.
// In some cases, one goes to a target further, while the other goes to a target closer,
// and that target than goes to that same next target.
if (op.enriched.ahead_side != other_op.enriched.ahead_side)
{
// If one of them goes left (1), this one is preferred above collinear or right (-1),
// whatever the distance.
// ^
// (empty) / going left
// /
// >----------------------------
// \ .
// (polygon) \ going right
// v
//
// The left is also preferred above the other one going collinearly.
// Finally, if one of them is collinear, it is preferred above the one going right.
return op.enriched.ahead_side > other_op.enriched.ahead_side;
}
// If both have the same side, the preference depends on which side.
// For a left turn (1), the one with the smallest distance is preferred.
// For a right turn (-1), the one with the largest distance is preferred.
// For collinear (0), it should not matter.
return
op.enriched.ahead_side == 1
? op.enriched.ahead_distance_of_side_change
<= other_op.enriched.ahead_distance_of_side_change
: op.enriched.ahead_distance_of_side_change
>= other_op.enriched.ahead_distance_of_side_change;
}
// The same for intersection - but it needs turns for the same target ahead check.
template <typename Operation, typename Turns>
bool is_better_collinear_for_intersection(Operation const& op, Operation const& other_op,
turn_operation_id const& toi, turn_operation_id const& other_toi, Turns const& turns)
{
// Continue, prefer the one having no polygon on the left
if (op.enriched.count_right < 2 && other_op.enriched.count_right >= 2)
{
return false;
}
if (op.enriched.count_right >= 0 && other_op.enriched.count_right < 2)
{
return true;
}
auto const target_ahead = is_cc_target_ahead(turns, toi);
if (target_ahead.first)
{
return target_ahead.second;
}
return op.enriched.ahead_distance_of_side_change
<= other_op.enriched.ahead_distance_of_side_change;
}
template <operation_type Operation>
struct is_better_collinear_target {};
template <>
struct is_better_collinear_target<operation_union>
{
template <typename Operation, typename Turns>
static bool apply(Operation const& op, Operation const& other_op,
turn_operation_id const& toi, turn_operation_id const& other_toi, Turns const&)
{
return is_better_collinear_for_union(op, other_op, toi, other_toi);
}
};
template <>
struct is_better_collinear_target<operation_intersection>
{
template <typename Operation, typename Turns>
static bool apply(Operation const& op, Operation const& other_op,
turn_operation_id const& toi, turn_operation_id const& other_toi, Turns const& turns)
{
return is_better_collinear_for_intersection(op, other_op, toi, other_toi, turns);
}
};
template <operation_type TargetOperation, typename Turns>
bool is_target_operation(Turns const& turns, turn_operation_id const& toi)
{
auto const& turn = turns[toi.turn_index];
auto const& op = turn.operations[toi.operation_index];
if (op.enriched.travels_to_ip_index < 0
|| op.enriched.travels_to_ip_index >= static_cast<int>(turns.size()))
{
return false;
}
if (op.operation == TargetOperation)
{
return true;
}
if (op.operation != operation_continue)
{
return false;
}
turn_operation_id const other_toi{toi.turn_index, 1 - toi.operation_index};
auto const& other_op = turn.operations[other_toi.operation_index];
return is_better_collinear_target<TargetOperation>
::apply(op, other_op, toi, other_toi, turns);
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GRAPH_IS_TARGET_OPERATION_HPP

159
include/boost/geometry/algorithms/detail/overlay/graph/node_util.hpp Normal file
View File

@ -0,0 +1,159 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_NODE_UTIL_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_NODE_UTIL_HPP
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/is_operation_included.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/is_target_operation.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_operation_id.hpp>
#include <set>
#include <tuple>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
using set_of_tois = std::set<turn_operation_id>;
using set_of_size_t = std::set<std::size_t>;
struct edge_info
{
signed_size_type source_node_id{0};
signed_size_type target_node_id{0};
segment_identifier seg_id{};
bool operator<(edge_info const& other) const
{
return std::tie(source_node_id, target_node_id, seg_id)
< std::tie(other.source_node_id, other.target_node_id, other.seg_id);
}
};
template <typename Turns, typename Clusters>
set_of_size_t get_turn_indices_by_cluster_id(Turns const& turns, Clusters const& clusters,
signed_size_type cluster_id, bool allow_closed)
{
set_of_size_t result;
auto it = clusters.find(cluster_id);
if (it == clusters.end())
{
return result;
}
if (! allow_closed && it->second.open_count == 0)
{
return result;
}
for (std::size_t turn_index : it->second.turn_indices)
{
result.insert(turn_index);
}
return result;
}
// Returns the node id of the turn:
// - if it is clustered, the negative cluster_id
// - if it is not clustered, the turn index
// - there can also be extra nodes for the round trip (>= turns.size())
// but they are not returned by this function.
template <typename Turns>
signed_size_type get_node_id(Turns const& turns, std::size_t turn_index)
{
auto const& turn = turns[turn_index];
return turn.is_clustered() ? -turn.cluster_id : turn_index;
}
template <typename Turns, typename Clusters>
set_of_size_t get_turn_indices_by_node_id(Turns const& turns, Clusters const& clusters,
signed_size_type node_id, bool allow_closed)
{
if (node_id < 0)
{
return get_turn_indices_by_cluster_id(turns, clusters, -node_id, allow_closed);
}
auto const turn_index = static_cast<std::size_t>(node_id);
if (turn_index >= turns.size())
{
// It is 'allowed' to have node_ids larger than the largest turn index (for example extra
// nodes in a graph). But they are not related to turns.
return {};
}
auto const& turn = turns[turn_index];
if (turn.is_clustered())
{
return get_turn_indices_by_cluster_id(turns, clusters, turn.cluster_id, allow_closed);
}
return {turn_index};
}
template <operation_type TargetOperation, typename Turns>
void get_target_operations(Turns const& turns,
typename Turns::value_type const& turn,
std::size_t turn_index,
signed_size_type source_node_id,
std::set<edge_info>& edges)
{
using is_included = is_operation_included<TargetOperation>;
for (int j = 0; j < 2; j++)
{
auto const& op = turn.operations[j];
if (is_included::apply(op)
&& is_target_operation<TargetOperation>(turns, {turn_index, j}))
{
auto const& target_node_id = get_node_id(turns, op.enriched.travels_to_ip_index);
edges.insert({source_node_id, target_node_id, op.seg_id});
}
}
}
// Get the target nodes of a specific component_id only.
template <operation_type TargetOperation, typename Turns, typename Clusters, typename Set>
auto get_target_nodes(Turns const& turns, Clusters const& clusters,
Set const& turn_indices,
signed_size_type component_id)
{
using is_included = is_operation_included<TargetOperation>;
std::set<signed_size_type> result;
for (auto turn_index : turn_indices)
{
auto const& turn = turns[turn_index];
if (turn.discarded)
{
continue;
}
for (int j = 0; j < 2; j++)
{
auto const& op = turn.operations[j];
if (op.enriched.component_id == component_id
&& is_included::apply(op)
&& is_target_operation<TargetOperation>(turns, {turn_index, j}))
{
result.insert(get_node_id(turns, op.enriched.travels_to_ip_index));
}
}
}
return result;
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_NODE_UTIL_HPP

315
include/boost/geometry/algorithms/detail/overlay/graph/select_edge.hpp Normal file
View File

@ -0,0 +1,315 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELECT_EDGE_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELECT_EDGE_HPP
#include <boost/core/ignore_unused.hpp>
#include <boost/geometry/algorithms/detail/overlay/approximately_equals.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_operation_id.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/node_util.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/select_toi_by_incoming.hpp>
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
#include <boost/geometry/io/wkt/wkt.hpp>
#endif
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
template <typename Point>
struct edge_and_side
{
turn_operation_id toi{0};
Point point{};
int side{0};
};
template
<
bool Reverse1,
bool Reverse2,
overlay_type OverlayType,
typename Geometry1,
typename Geometry2,
typename Turns,
typename Clusters,
typename Strategy
>
struct edge_selector
{
private:
static constexpr operation_type target_operation = operation_from_overlay<OverlayType>::value;
using point_type = typename Turns::value_type::point_type;
using edge_type = edge_and_side<point_type>;
using edges_type = std::vector<edge_type>;
// Use the coordinate type, but if it is too small (e.g. std::int16), use a double
using coor_type = typename geometry::select_most_precise
<
geometry::coordinate_type_t<point_type>,
double
>::type;
// Walks over a ring to get the point after the turn.
// The turn can be located at the very end of a segment.
// Therefore it can be the first point on the next segment.
template <typename Operation>
point_type walk_to_point_after_turn(Operation const& op, point_type const& turn_point) const
{
static const coor_type tolerance
= common_approximately_equals_epsilon_multiplier<coor_type>::value();
int offset = 1;
point_type point;
do
{
geometry::copy_segment_point<Reverse1, Reverse2>(m_geometry1, m_geometry2,
op.seg_id, offset, point);
++offset;
} while (approximately_equals(point, turn_point, tolerance) && offset < 10);
return point;
}
// Compares and returns true for the left most operation.
// p1 is the point before the current turn.
// p2 is the current turn.
// So (p1, p2) together define the direction of the segment.
bool select_collinear_target_edge(edge_type const& a, edge_type const& b) const
{
auto const& turn_a = m_turns[a.toi.turn_index];
auto const& turn_b = m_turns[b.toi.turn_index];
auto const& op_a = turn_a.operations[a.toi.operation_index];
auto const& op_b = turn_b.operations[b.toi.operation_index];
auto const target_a = get_node_id(m_turns, op_a.enriched.travels_to_ip_index);
auto const target_b = get_node_id(m_turns, op_b.enriched.travels_to_ip_index);
auto const& other_op_a = turn_a.operations[1 - a.toi.operation_index];
auto const& other_op_b = turn_b.operations[1 - b.toi.operation_index];
if (other_op_a.enriched.travels_to_ip_index == -1)
{
return true;
}
if (other_op_b.enriched.travels_to_ip_index == -1)
{
return false;
}
auto const other_target_a = get_node_id(m_turns, other_op_a.enriched.travels_to_ip_index);
auto const other_target_b = get_node_id(m_turns, other_op_b.enriched.travels_to_ip_index);
if (target_b == other_target_a || target_b == other_target_b)
{
// The second edge goes via one of the targets of the first
return false;
}
if (target_a == other_target_a || target_a == other_target_b)
{
// Vice versa
return true;
}
return true;
}
void report(const char* caption, edges_type const& edges,
point_type const& p1, point_type const& p2) const
{
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << " *** Sorted edges " << caption
<< " from " << geometry::wkt(p1) << " to " << geometry::wkt(p2)
<< std::endl;
for (auto const& item : edges)
{
auto const& op = m_turns[item.toi.turn_index].operations[item.toi.operation_index];
std::cout << " -> " << item.toi
<< " to " << op.enriched.travels_to_ip_index
<< " side: " << item.side
<< std::endl;
}
#endif
}
turn_operation_id select_by_side(edges_type& edges, point_type const& p1, point_type const& p2) const
{
// Select point and calculate side for each edge
auto const side_strategy = m_intersection_strategy.side();
for (auto& edge : edges)
{
auto const& op = m_turns[edge.toi.turn_index].operations[edge.toi.operation_index];
edge.point = walk_to_point_after_turn(op, p2);
edge.side = side_strategy.apply(p1, p2, edge.point);
}
// Sort by side (with respect to segment [p1..p2]) (TEMPORARY: and then by toi)
// Right = -1 will come first. Left = 1 will come last.
// This works for both union and intersection operations, because it should always
// take the right turn (even in uu in buffer/union).
std::sort(edges.begin(), edges.end(), [](auto const& a, auto const& b)
{
return std::tie(a.side, a.toi) < std::tie(b.side, b.toi);
});
report("by side", edges, p1, p2);
if (edges.size() == 1 || (edges.size() > 1 && edges.front().side != edges[1].side))
{
return edges.front().toi;
}
if (edges.front().side != edges.back().side)
{
// Remove all edges with different side than the first
auto it = std::find_if(edges.begin() + 1, edges.end(), [&](auto const& item)
{
return item.side != edges.front().side;
});
edges.erase(it, edges.end());
}
if (edges.front().side == 0)
{
// Select for collinearity (it makes no sense to sort on mutual side)
auto compare = [&](edge_type const& a, edge_type const& b) -> bool
{
return select_collinear_target_edge(a, b);
};
std::sort(edges.begin(), edges.end(), compare);
return edges.front().toi;
}
// Phase 2, sort by mutual side, of the edges having the front edge's side.
auto compare_one_side = [&](auto const& a, auto const& b) -> bool
{
// Calculating one side is enough. Either both are 0, or they are opposite.
int const side = side_strategy.apply(p2, a.point, b.point);
return side == 1;
};
std::sort(edges.begin(), edges.end(), compare_one_side);
report("by mutual side", edges, p1, p2);
return edges.front().toi;
}
public:
edge_selector(Geometry1 const& m_geometry1, Geometry2 const& m_geometry2,
Turns const& m_turns, Clusters const& clusters,
Strategy const& strategy)
: m_geometry1(m_geometry1)
, m_geometry2(m_geometry2)
, m_turns(m_turns)
, m_clusters(clusters)
, m_intersection_strategy(strategy)
{}
// Select one operation which is the leftmost or rightmost operation.
// p1 is the point before the current turn.
// p2 is the current turn.
// So (p1, p2) together define the direction of the segment.
turn_operation_id select_target_edge(set_of_tois const& turn_operation_ids,
point_type const& p1, point_type const& p2) const
{
if (turn_operation_ids.empty())
{
return {};
}
if (turn_operation_ids.size() == 1)
{
return *turn_operation_ids.begin();
}
edges_type edges;
edges.reserve(turn_operation_ids.size());
for (auto const& toi : turn_operation_ids)
{
edges.emplace_back(edge_type{toi});
}
// Verification function for clusters: if it is clustered, all should come from one cluster.
auto assert_one_cluster = [&]() -> bool
{
auto const& turn0 = m_turns[edges[0].toi.turn_index];
auto const cluster_id = turn0.cluster_id;
for (auto const& toi : turn_operation_ids)
{
auto const& turn = m_turns[toi.turn_index];
if (turn.cluster_id != cluster_id)
{
return false;
}
}
return true;
};
boost::ignore_unused(assert_one_cluster);
// It often happens there are just two collinear edges.
// If they travel to the same target, take either.
if (edges.size() == 2)
{
auto const& turn0 = m_turns[edges[0].toi.turn_index];
auto const& turn1 = m_turns[edges[1].toi.turn_index];
auto const& op0 = turn0.operations[edges[0].toi.operation_index];
auto const& op1 = turn1.operations[edges[1].toi.operation_index];
if (op0.operation == operation_continue
&& op1.operation == operation_continue
&& op0.enriched.travels_to_ip_index == op1.enriched.travels_to_ip_index)
{
return edges.front().toi;
}
if (target_operation == operation_union
&& turn0.is_clustered()
&& op0.operation == operation_union
&& op1.operation == operation_union
&& op0.enriched.rank == op1.enriched.rank)
{
// Because it is clustered, and all operations come from the same cluster,
// the rank can be used, which is more efficient.
BOOST_GEOMETRY_ASSERT(assert_one_cluster());
turn_operation_id result;
if (select_toi_for_union(result, op0, op1, edges[0].toi, edges[1].toi, m_turns))
{
return result;
}
bool const better = is_better_collinear_for_union(
op0, op1, edges.front().toi, edges.back().toi);
return better ? edges.front().toi : edges.back().toi;
}
}
return select_by_side(edges, p1, p2);
}
private:
Geometry1 const& m_geometry1;
Geometry2 const& m_geometry2;
Turns const& m_turns;
Clusters const& m_clusters;
Strategy const& m_intersection_strategy;
};
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELECT_EDGE_HPP

96
include/boost/geometry/algorithms/detail/overlay/graph/select_toi_by_incoming.hpp Normal file
View File

@ -0,0 +1,96 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELECT_TOI_BY_INCOMING_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELECT_TOI_BY_INCOMING_HPP
#include <boost/geometry/algorithms/detail/overlay/turn_operation_id.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
// For two operations from a cluster, having the same target, and having the same rank,
// the outgoing side makes it unclear. This function inspects the target and uses the incoming
// side, which should be more clear.
template <typename Turns, typename Operation>
bool select_toi_for_union(turn_operation_id& result, Operation const& op0, Operation const& op1,
turn_operation_id const& toi0, turn_operation_id const& toi1,
Turns const& turns)
{
if (op0.enriched.travels_to_ip_index != op1.enriched.travels_to_ip_index
|| op0.enriched.travels_to_ip_index < 0)
{
// Not the same target
return false;
}
auto const& target_turn = turns[op0.enriched.travels_to_ip_index];
auto const& target_op0 = target_turn.operations[0];
auto const& target_op1 = target_turn.operations[1];
bool const is_target_for_union0 = target_op0.enriched.count_left_incoming == 0;
bool const is_target_for_union1 = target_op1.enriched.count_left_incoming == 0;
if (is_target_for_union0 == is_target_for_union1)
{
// There is no incoming operation usable for union, or both are the same.
return false;
}
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "SELECT_BY_INCOMING " << toi0 << " vs " << toi1
<< " " << operation_char(op0.operation) << operation_char(op1.operation)
<< " traveling to " << op0.enriched.travels_to_ip_index
<< std::endl;
#endif
if (target_op0.seg_id.multi_index == target_op1.seg_id.multi_index)
{
// They have the same ring (should not occur normally, in buffer)
// so they cannot be used for selection.
return false;
}
if (is_target_for_union0)
{
if (target_op0.seg_id.multi_index == op0.seg_id.multi_index)
{
result = toi0;
return true;
}
if (target_op0.seg_id.multi_index == op1.seg_id.multi_index)
{
result = toi1;
return true;
}
}
else
{
if (target_op1.seg_id.multi_index == op0.seg_id.multi_index)
{
result = toi0;
return true;
}
if (target_op1.seg_id.multi_index == op1.seg_id.multi_index)
{
result = toi1;
return true;
}
}
return false;
}
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELECT_TOI_BY_INCOMING_HPP

437
include/boost/geometry/algorithms/detail/overlay/graph/traverse_graph.hpp Normal file
View File

@ -0,0 +1,437 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSE_GRAPH_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSE_GRAPH_HPP
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/is_operation_included.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/get_tois.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/node_util.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/select_edge.hpp>
#include <boost/geometry/algorithms/num_points.hpp>
#include <boost/geometry/core/closure.hpp>
#include <boost/assert.hpp>
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
#include <boost/geometry/io/wkt/wkt.hpp>
#endif
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
template
<
bool Reverse1,
bool Reverse2,
overlay_type OverlayType,
typename Geometry1,
typename Geometry2,
typename Turns,
typename Clusters,
typename Strategy
>
struct traverse_graph
{
static constexpr operation_type target_operation = operation_from_overlay<OverlayType>::value;
static constexpr bool allow_closed = target_operation == operation_intersection;
static constexpr bool is_buffer = OverlayType == overlay_buffer;
using turn_type = typename boost::range_value<Turns>::type;
using is_included = is_operation_included<target_operation>;
using point_type = typename turn_type::point_type;
using toi_set = std::set<turn_operation_id>;
inline traverse_graph(Geometry1 const& geometry1, Geometry2 const& geometry2,
Turns& turns, Clusters const& clusters,
Strategy const& strategy)
: m_edge_selector(geometry1, geometry2, turns, clusters, strategy)
, m_geometry1(geometry1)
, m_geometry2(geometry2)
, m_turns(turns)
, m_clusters(clusters)
, m_strategy(strategy)
{
}
template <typename Ring>
void copy_segments(Ring& ring, turn_operation_id const& toi) const
{
auto const& op = m_turns[toi.turn_index].operations[toi.operation_index];
auto const to_vertex_index = op.enriched.travels_to_vertex_index;
if (op.seg_id.source_index == 0)
{
geometry::copy_segments<Reverse1>(m_geometry1,
op.seg_id, to_vertex_index,
m_strategy, ring);
}
else
{
geometry::copy_segments<Reverse2>(m_geometry2,
op.seg_id, to_vertex_index,
m_strategy, ring);
}
}
template <typename Ring>
void use_vertices(Ring& ring, turn_operation_id const& toi, bool is_round_trip = false) const
{
auto const& op = m_turns[toi.turn_index].operations[toi.operation_index];
auto const to_vertex_index = op.enriched.travels_to_vertex_index;
if (to_vertex_index < 0)
{
return;
}
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "At : " << toi << std::endl;
#endif
if (op.seg_id.segment_index == to_vertex_index && ! is_round_trip)
{
auto const& next_turn = m_turns[op.enriched.travels_to_ip_index];
bool allow = false;
for (int j = 0; j < 2; j++)
{
auto const& next_op = next_turn.operations[j];
if (next_op.seg_id == op.seg_id)
{
// It is on the same segment. Determine if it is located before or after
if (next_op.fraction < op.fraction)
{
// It is before, so we can continue
allow = true;
}
}
}
if (! allow)
{
return;
}
}
copy_segments(ring, toi);
}
// Set the turn operation as visited.
void set_visited(turn_operation_id const& toi)
{
// std::cout << "Set visited: " << toi << std::endl;
m_visited_tois.insert(toi);
// From the same cluster, set other operations with the same segment id,
// going to the same target, as visited as well.
auto const& turn = m_turns[toi.turn_index];
if (! turn.is_clustered())
{
return;
}
auto cluster_it = m_clusters.find(turn.cluster_id);
if (cluster_it == m_clusters.end())
{
return;
}
auto const& cluster = cluster_it->second;
auto const& op = turn.operations[toi.operation_index];
for (std::size_t turn_index : cluster.turn_indices)
{
if (turn_index == toi.turn_index)
{
continue;
}
auto const& other_turn = m_turns[turn_index];
for (int j = 0; j < 2; j++)
{
auto const& other_op = other_turn.operations[j];
if (other_op.enriched.travels_to_ip_index == op.enriched.travels_to_ip_index
&& other_op.seg_id == op.seg_id)
{
m_visited_tois.insert({turn_index, j});
}
}
}
}
template <typename Ring>
bool continue_traverse(Ring& ring,
signed_size_type component_id,
signed_size_type start_node_id,
signed_size_type current_node_id)
{
auto const current_turn_indices = get_turn_indices_by_node_id(m_turns, m_clusters,
current_node_id, allow_closed);
// Any valid node should always deliver at least one turn
BOOST_ASSERT(! current_turn_indices.empty());
auto const next_target_nodes = get_target_nodes<target_operation>(m_turns, m_clusters,
current_turn_indices, component_id);
if (next_target_nodes.empty())
{
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "Stuck, start: " << start_node_id
<< " stuck: " << current_node_id
<< " (no targets) " << std::endl;
#endif
return false;
}
auto const tois = get_tois<target_operation>(m_turns, m_clusters,
current_node_id, next_target_nodes);
if (tois.empty())
{
return false;
}
auto const& turn_point = m_turns[*current_turn_indices.begin()].point;
auto toi = *tois.begin();
if (tois.size() > 1)
{
// Select the best target edge, using the last point of the ring and the turn point
// for side calculations (if any).
toi = m_edge_selector.select_target_edge(tois, ring.back(), turn_point);
}
if (m_visited_tois.count(toi) > 0 || m_finished_tois.count(toi) > 0)
{
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "ALREADY visited, turn " << toi
<< " in {" << current_node_id
<< " -> size " << next_target_nodes.size() << "}" << std::endl;
#endif
return false;
}
detail::overlay::append_no_collinear(ring, turn_point, m_strategy);
set_visited(toi);
use_vertices(ring, toi);
auto const& selected_op = m_turns[toi.turn_index].operations[toi.operation_index];
auto const next_target_node_id = get_node_id(m_turns,
selected_op.enriched.travels_to_ip_index);
if (next_target_node_id == start_node_id)
{
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "Finished at: " << next_target_node_id << std::endl;
#endif
return true;
}
return continue_traverse(ring, component_id, start_node_id, next_target_node_id);
}
template <typename Rings>
void start_traverse(Rings& rings, point_type const& start_point,
signed_size_type component_id,
signed_size_type start_node_id,
signed_size_type target_node_id)
{
// Select the first toi which is not yet visited and has the requested component.
// If all tois are visited, not having the same component, it is not possible to continue,
// and it returns an invalid toi.
auto select_first_toi = [&](auto const& tois)
{
for (auto const& toi : tois)
{
if (m_finished_tois.count(toi) > 0)
{
// Visited in the meantime
continue;
}
auto const& op = m_turns[toi.turn_index].operations[toi.operation_index];
if (op.enriched.component_id != component_id)
{
continue;
}
return toi;
}
return turn_operation_id{0, -1};
};
auto const toi = select_first_toi(get_tois<target_operation>(m_turns, m_clusters,
start_node_id, target_node_id));
if (toi.operation_index < 0)
{
return;
}
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "\n" << "-> Start traversing component " << component_id
<< " at: " << toi
<< " to " << target_node_id << std::endl;
#endif
using ring_type = typename boost::range_value<Rings>::type;
constexpr std::size_t min_size
= core_detail::closure::minimum_ring_size
<
geometry::closure<ring_type>::value
>::value;
ring_type ring;
detail::overlay::append_no_collinear(ring, start_point, m_strategy);
m_visited_tois.clear();
set_visited(toi);
bool const is_round_trip = start_node_id == target_node_id;
use_vertices(ring, toi, is_round_trip);
// Traverse the graph. If the target is at the start, it is a round trip,
// and it is finished immediately.
// The continuation could fail (no target nodes, or no target edges).
bool const is_finished = is_round_trip
|| continue_traverse(ring, component_id, start_node_id, target_node_id);
if (! is_finished)
{
return;
}
detail::overlay::append_no_collinear(ring, start_point, m_strategy);
remove_spikes_at_closure(ring, m_strategy);
fix_closure(ring, m_strategy);
if (geometry::num_points(ring) >= min_size)
{
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "Add ring: " << geometry::wkt(ring) << std::endl;
#endif
rings.push_back(std::move(ring));
}
m_finished_tois.insert(m_visited_tois.begin(), m_visited_tois.end());
}
void update_administration()
{
for (auto const& toi : m_finished_tois)
{
auto& op = m_turns[toi.turn_index].operations[toi.operation_index];
op.enriched.is_traversed = true;
}
}
template <typename Rings>
void iterate(Rings& rings, std::size_t turn_index)
{
auto const& turn = m_turns[turn_index];
if (turn.discarded)
{
return;
}
auto const source_node_id = get_node_id(m_turns, turn_index);
auto const turn_indices = get_turn_indices_by_node_id(m_turns, m_clusters,
source_node_id, allow_closed);
for (int j = 0; j < 2; j++)
{
auto const& op = turn.operations[j];
if (! op.enriched.startable || ! is_included::apply(op))
{
continue;
}
turn_operation_id const toi{turn_index, j};
if (m_finished_tois.count(toi) > 0
|| ! is_target_operation<target_operation>(m_turns, toi))
{
continue;
}
auto const component_id = op.enriched.component_id;
auto const target_nodes = get_target_nodes<target_operation>(m_turns, m_clusters,
turn_indices, component_id);
for (auto const target_node_id : target_nodes)
{
auto const start = std::make_tuple(source_node_id, target_node_id, component_id);
if (m_starts.count(start) > 0)
{
// Don't repeat earlier or finished trials. This speeds up some cases by 1.5x
continue;
}
m_starts.insert(start);
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE_GRAPH)
std::cout << "\n" << "Traversing component " << component_id
<< " from " << source_node_id << " to " << target_node_id << std::endl;
#endif
start_traverse(rings, turn.point, component_id, source_node_id, target_node_id);
}
}
}
template <typename Rings>
void iterate(Rings& rings)
{
for (std::size_t i = 0; i < m_turns.size(); i++)
{
iterate(rings, i);
}
update_administration();
}
private:
edge_selector
<
Reverse1, Reverse2, OverlayType,
Geometry1, Geometry2,
Turns, Clusters,
Strategy
> m_edge_selector;
Geometry1 const& m_geometry1;
Geometry2 const& m_geometry2;
Turns& m_turns;
Clusters const& m_clusters;
Strategy const& m_strategy;
// Visited turn operations on currenly traversed ring - they are either
// inserted into the final set, or cleared before the next trial.
toi_set m_visited_tois;
// Visited turn operations after a ring is added
toi_set m_finished_tois;
// Keep track of started combinations (either finished, or stuck)
std::set<std::tuple<signed_size_type, signed_size_type, signed_size_type>> m_starts;
};
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSE_GRAPH_HPP

390
include/boost/geometry/algorithms/detail/overlay/handle_colocations.hpp
View File

@ -34,7 +34,6 @@
#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
#include <boost/geometry/algorithms/detail/overlay/is_self_turn.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/sort_by_side.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
#include <boost/geometry/util/constexpr.hpp>
@ -99,188 +98,6 @@ inline void cleanup_clusters(Turns& turns, Clusters& clusters)
remove_clusters(turns, clusters);
}
template <typename Turn, typename IndexSet>
inline void discard_colocated_turn(Turn& turn, IndexSet& indices, signed_size_type index)
{
turn.discarded = true;
// Set cluster id to -1, but don't clear colocated flags
turn.cluster_id = -1;
// To remove it later from clusters
indices.insert(index);
}
template <bool Reverse>
inline bool is_interior(segment_identifier const& seg_id)
{
return Reverse ? seg_id.ring_index == -1 : seg_id.ring_index >= 0;
}
template <bool Reverse0, bool Reverse1>
inline bool is_ie_turn(segment_identifier const& ext_seg_0,
segment_identifier const& ext_seg_1,
segment_identifier const& int_seg_0,
segment_identifier const& other_seg_1)
{
if (ext_seg_0.source_index == ext_seg_1.source_index)
{
// External turn is a self-turn, dont discard internal turn for this
return false;
}
// Compares two segment identifiers from two turns (external / one internal)
// From first turn [0], both are from same polygon (multi_index),
// one is exterior (-1), the other is interior (>= 0),
// and the second turn [1] handles the same ring
// For difference, where the rings are processed in reversal, all interior
// rings become exterior and vice versa. But also the multi property changes:
// rings originally from the same multi should now be considered as from
// different multi polygons.
// But this is not always the case, and at this point hard to figure out
// (not yet implemented, TODO)
bool const same_multi0 = ! Reverse0
&& ext_seg_0.multi_index == int_seg_0.multi_index;
bool const same_multi1 = ! Reverse1
&& ext_seg_1.multi_index == other_seg_1.multi_index;
boost::ignore_unused(same_multi1);
return same_multi0
&& same_multi1
&& ! is_interior<Reverse0>(ext_seg_0)
&& is_interior<Reverse0>(int_seg_0)
&& ext_seg_1.ring_index == other_seg_1.ring_index;
// The other way round is tested in another call
}
template
<
bool Reverse0, bool Reverse1, // Reverse interpretation interior/exterior
typename Turns,
typename Clusters
>
inline void discard_interior_exterior_turns(Turns& turns, Clusters& clusters)
{
std::set<signed_size_type> indices_to_remove;
for (auto& pair : clusters)
{
cluster_info& cinfo = pair.second;
indices_to_remove.clear();
for (auto index : cinfo.turn_indices)
{
auto& turn = turns[index];
segment_identifier const& seg_0 = turn.operations[0].seg_id;
segment_identifier const& seg_1 = turn.operations[1].seg_id;
if (! (turn.both(operation_union)
|| turn.combination(operation_union, operation_blocked)))
{
// Not a uu/ux, so cannot be colocated with a iu turn
continue;
}
for (auto interior_index : cinfo.turn_indices)
{
if (index == interior_index)
{
continue;
}
// Turn with, possibly, an interior ring involved
auto& interior_turn = turns[interior_index];
segment_identifier const& int_seg_0 = interior_turn.operations[0].seg_id;
segment_identifier const& int_seg_1 = interior_turn.operations[1].seg_id;
if (is_ie_turn<Reverse0, Reverse1>(seg_0, seg_1, int_seg_0, int_seg_1))
{
discard_colocated_turn(interior_turn, indices_to_remove, interior_index);
}
if (is_ie_turn<Reverse1, Reverse0>(seg_1, seg_0, int_seg_1, int_seg_0))
{
discard_colocated_turn(interior_turn, indices_to_remove, interior_index);
}
}
}
// Erase from the indices (which cannot be done above)
for (auto index : indices_to_remove)
{
cinfo.turn_indices.erase(index);
}
}
}
template
<
overlay_type OverlayType,
typename Turns,
typename Clusters
>
inline void set_colocation(Turns& turns, Clusters const& clusters)
{
for (auto const& pair : clusters)
{
cluster_info const& cinfo = pair.second;
bool both_target = false;
for (auto index : cinfo.turn_indices)
{
auto const& turn = turns[index];
if (turn.both(operation_from_overlay<OverlayType>::value))
{
both_target = true;
break;
}
}
if (both_target)
{
for (auto index : cinfo.turn_indices)
{
auto& turn = turns[index];
turn.has_colocated_both = true;
}
}
}
}
template
<
typename Turns,
typename Clusters
>
inline void check_colocation(bool& has_blocked,
signed_size_type cluster_id, Turns const& turns, Clusters const& clusters)
{
using turn_type = typename boost::range_value<Turns>::type;
has_blocked = false;
auto mit = clusters.find(cluster_id);
if (mit == clusters.end())
{
return;
}
cluster_info const& cinfo = mit->second;
for (auto index : cinfo.turn_indices)
{
turn_type const& turn = turns[index];
if (turn.any_blocked())
{
has_blocked = true;
}
}
}
template
<
@ -302,213 +119,12 @@ inline void assign_cluster_ids(Turns& turns, Clusters const& clusters)
}
}
// Checks colocated turns and flags combinations of uu/other, possibly a
// combination of a ring touching another geometry's interior ring which is
// tangential to the exterior ring
// This function can be extended to replace handle_tangencies: at each
// colocation incoming and outgoing vectors should be inspected
template
<
bool Reverse1, bool Reverse2,
overlay_type OverlayType,
typename Geometry0,
typename Geometry1,
typename Turns,
typename Clusters
>
inline bool handle_colocations(Turns& turns, Clusters& clusters)
// Get clusters and assign their ids
template<typename Turns, typename Clusters>
inline void handle_colocations(Turns& turns, Clusters& clusters)
{
static const detail::overlay::operation_type target_operation
= detail::overlay::operation_from_overlay<OverlayType>::value;
get_clusters(turns, clusters);
if (clusters.empty())
{
return false;
}
assign_cluster_ids(turns, clusters);
// Get colocated information here, and not later, to keep information
// on turns which are discarded afterwards
set_colocation<OverlayType>(turns, clusters);
if BOOST_GEOMETRY_CONSTEXPR (target_operation == operation_intersection)
{
discard_interior_exterior_turns
<
do_reverse<geometry::point_order<Geometry0>::value>::value != Reverse1,
do_reverse<geometry::point_order<Geometry1>::value>::value != Reverse2
>(turns, clusters);
}
// There might be clusters having only one turn, if the rest is discarded
// This is cleaned up later, after gathering the properties.
#if defined(BOOST_GEOMETRY_DEBUG_HANDLE_COLOCATIONS)
std::cout << "*** Colocations " << map.size() << std::endl;
for (auto const& kv : map)
{
std::cout << kv.first << std::endl;
for (auto const& toi : kv.second)
{
detail::debug::debug_print_turn(turns[toi.turn_index]);
std::cout << std::endl;
}
}
#endif
return true;
}
template
<
typename Sbs,
typename Point,
typename Turns,
typename Geometry1,
typename Geometry2
>
inline bool fill_sbs(Sbs& sbs, Point& turn_point,
cluster_info const& cinfo,
Turns const& turns,
Geometry1 const& geometry1, Geometry2 const& geometry2)
{
if (cinfo.turn_indices.empty())
{
return false;
}
bool first = true;
for (auto turn_index : cinfo.turn_indices)
{
auto const& turn = turns[turn_index];
if (first)
{
turn_point = turn.point;
}
for (int i = 0; i < 2; i++)
{
sbs.add(turn, turn.operations[i], turn_index, i, geometry1, geometry2, first);
first = false;
}
}
return true;
}
template
<
bool Reverse1, bool Reverse2,
overlay_type OverlayType,
typename Turns,
typename Clusters,
typename Geometry1,
typename Geometry2,
typename Strategy
>
inline void gather_cluster_properties(Clusters& clusters, Turns& turns,
operation_type for_operation,
Geometry1 const& geometry1, Geometry2 const& geometry2,
Strategy const& strategy)
{
using turn_type = typename boost::range_value<Turns>::type;
using point_type = typename turn_type::point_type;
using turn_operation_type = typename turn_type::turn_operation_type;
// Define sorter, sorting counter-clockwise such that polygons are on the right side
using sbs_type = sort_by_side::side_sorter
<
Reverse1, Reverse2, OverlayType, point_type, Strategy, std::less<int>
>;
for (auto& pair : clusters)
{
cluster_info& cinfo = pair.second;
sbs_type sbs(strategy);
point_type turn_point; // should be all the same for all turns in cluster
if (! fill_sbs(sbs, turn_point, cinfo, turns, geometry1, geometry2))
{
continue;
}
sbs.apply(turn_point);
sbs.find_open();
sbs.assign_zones(for_operation);
cinfo.open_count = sbs.open_count(for_operation);
// Determine spikes
cinfo.spike_count = 0;
for (std::size_t i = 0; i + 1 < sbs.m_ranked_points.size(); i++)
{
auto const& current = sbs.m_ranked_points[i];
auto const& next = sbs.m_ranked_points[i + 1];
if (current.rank == next.rank
&& current.direction == detail::overlay::sort_by_side::dir_from
&& next.direction == detail::overlay::sort_by_side::dir_to)
{
// It leaves, from cluster point, and immediately returns.
cinfo.spike_count += 1;
}
}
bool const set_startable = OverlayType != overlay_dissolve;
// Unset the startable flag for all 'closed' zones. This does not
// apply for self-turns, because those counts are not from both
// polygons
for (std::size_t i = 0; i < sbs.m_ranked_points.size(); i++)
{
typename sbs_type::rp const& ranked = sbs.m_ranked_points[i];
turn_type& turn = turns[ranked.turn_index];
turn_operation_type& op = turn.operations[ranked.operation_index];
if (set_startable
&& for_operation == operation_union
&& cinfo.open_count == 0)
{
op.enriched.startable = false;
}
if (ranked.direction != sort_by_side::dir_to)
{
continue;
}
op.enriched.count_left = ranked.count_left;
op.enriched.count_right = ranked.count_right;
op.enriched.rank = ranked.rank;
op.enriched.zone = ranked.zone;
if (! set_startable)
{
continue;
}
if BOOST_GEOMETRY_CONSTEXPR (OverlayType == overlay_difference)
{
if (is_self_turn<OverlayType>(turn))
{
// TODO: investigate
continue;
}
}
if ((for_operation == operation_union
&& ranked.count_left != 0)
|| (for_operation == operation_intersection
&& ranked.count_right != 2))
{
op.enriched.startable = false;
}
}
}
}

16
include/boost/geometry/algorithms/detail/overlay/handle_self_turns.hpp
View File

@ -52,6 +52,22 @@ struct check_within
};
template <>
struct check_within<overlay_buffer>
{
template
<
typename Turn, typename Geometry0, typename Geometry1,
typename UmbrellaStrategy
>
static inline
bool apply(Turn const& turn, Geometry0 const& geometry0,
Geometry1 const& geometry1, UmbrellaStrategy const& strategy)
{
return false;
}
};
template <>
struct check_within<overlay_difference>
{

1
include/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp
View File

@ -154,7 +154,6 @@ struct intersection_of_linestring_with_areal
<< " at " << op.seg_id
<< " meth: " << method_char(turn.method)
<< " op: " << operation_char(op.operation)
<< " vis: " << visited_char(op.visited)
<< " of: " << operation_char(turn.operations[0].operation)
<< operation_char(turn.operations[1].operation)
<< " " << geometry::wkt(turn.point)

10
include/boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp
View File

@ -24,7 +24,9 @@
#include <boost/range/value_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
#include <boost/geometry/algorithms/detail/overlay/sort_by_side.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
#include <boost/geometry/strategies/side.hpp>
namespace boost { namespace geometry
@ -46,14 +48,18 @@ struct indexed_turn_operation
// use pointers to avoid copies, const& is not possible because of usage in vector
segment_identifier const* other_seg_id; // segment id of other segment of intersection of two segments
TurnOperation const* subject;
bool discarded{false};
bool skip{false};
inline indexed_turn_operation(std::size_t ti, std::size_t oi,
TurnOperation const& sub,
segment_identifier const& oid)
segment_identifier const& oid,
bool dc = false)
: turn_index(ti)
, operation_index(oi)
, other_seg_id(&oid)
, subject(boost::addressof(sub))
, discarded(dc)
{}
};

74
include/boost/geometry/algorithms/detail/overlay/overlay.hpp
View File

@ -24,10 +24,13 @@
#include <boost/range/end.hpp>
#include <boost/range/value_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/assign_side_counts.hpp>
#include <boost/geometry/algorithms/detail/overlay/cluster_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp>
#include <boost/geometry/algorithms/detail/overlay/enrichment_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/get_properties_ahead.hpp>
#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
#include <boost/geometry/algorithms/detail/overlay/handle_colocations.hpp>
#include <boost/geometry/algorithms/detail/overlay/is_self_turn.hpp>
#include <boost/geometry/algorithms/detail/overlay/needs_self_turns.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
@ -66,12 +69,12 @@ struct overlay_null_visitor
template <typename Clusters, typename Turns>
void visit_clusters(Clusters const& , Turns const& ) {}
template <typename Turns, typename Turn, typename Operation>
void visit_traverse(Turns const& , Turn const& , Operation const& , char const*)
{}
template <typename Turns, typename Cluster, typename Connections>
inline void visit_cluster_connections(signed_size_type cluster_id,
Turns const& turns, Cluster const& cluster, Connections const& connections) {}
template <typename Turns, typename Turn, typename Operation>
void visit_traverse_reject(Turns const& , Turn const& , Operation const& , traverse_error_type )
void visit_traverse(Turns const& , Turn const& , Operation const& , char const*)
{}
template <typename Rings>
@ -98,9 +101,6 @@ inline void get_ring_turn_info(TurnInfoMap& turn_info_map, Turns const& turns, C
for (auto const& turn : turns)
{
bool cluster_checked = false;
bool has_blocked = false;
if (turn.discarded && (turn.method == method_start || is_self_turn<OverlayType>(turn)))
{
// Discarded self-turns or start turns don't need to block the ring
@ -113,15 +113,15 @@ inline void get_ring_turn_info(TurnInfoMap& turn_info_map, Turns const& turns, C
auto const& other_op = turn.operations[1 - i];
ring_identifier const ring_id = ring_id_by_seg_id(op.seg_id);
// The next condition is necessary for just two test cases.
// TODO: fix it in get_turn_info
// If the turn (one of its operations) is used during traversal,
// and it is an intersection or difference, it cannot be set to blocked.
// This is a rare case, related to floating point precision,
// and can happen if there is, for example, only one start turn which is
// used to traverse through one of the rings (the other should be marked
// as not traversed, but neither blocked).
bool const can_block
= is_union
|| ! (op.visited.finalized() || other_op.visited.finalized());
bool const can_block = is_union || ! (op.enriched.is_traversed || other_op.enriched.is_traversed);
if (! is_self_turn<OverlayType>(turn) && can_block)
{
@ -139,24 +139,15 @@ inline void get_ring_turn_info(TurnInfoMap& turn_info_map, Turns const& turns, C
continue;
}
// Check information in colocated turns
if (! cluster_checked && turn.is_clustered())
{
check_colocation(has_blocked, turn.cluster_id, turns, clusters);
cluster_checked = true;
}
// Block rings where any other turn is blocked,
// and (with exceptions): i for union and u for intersection
// Exceptions: don't block self-uu for intersection
// don't block self-ii for union
// don't block (for union) i/u if there is an self-ii too
if (has_blocked
|| (op.operation == opposite_operation
if (op.operation == opposite_operation
&& can_block
&& ! turn.has_colocated_both
&& ! (turn.both(opposite_operation)
&& is_self_turn<OverlayType>(turn))))
&& is_self_turn<OverlayType>(turn)))
{
turn_info_map[ring_id].has_blocked_turn = true;
}
@ -263,8 +254,6 @@ struct overlay
cluster_info
>;
constexpr operation_type target_operation = operation_from_overlay<OverlayType>::value;
turn_container_type turns;
detail::get_turns::no_interrupt_policy policy;
@ -295,33 +284,40 @@ struct overlay
#endif
cluster_type clusters;
std::map<ring_identifier, ring_turn_info> turn_info_per_ring;
// Handle colocations, gathering clusters and (below) their properties.
detail::overlay::handle_colocations
<
Reverse1, Reverse2, OverlayType, Geometry1, Geometry2
>(turns, clusters);
detail::overlay::handle_colocations(turns, clusters);
// Gather cluster properties (using even clusters with
// discarded turns - for open turns)
detail::overlay::gather_cluster_properties
<
Reverse1,
Reverse2,
OverlayType
>(clusters, turns, target_operation, geometry1, geometry2, strategy);
geometry::enrich_intersection_points<Reverse1, Reverse2, OverlayType>(
detail::overlay::enrich_discard_turns<OverlayType>(
turns, clusters, geometry1, geometry2, strategy);
detail::overlay::enrich_turns<Reverse1, Reverse2, OverlayType>(
turns, geometry1, geometry2, strategy);
visitor.visit_turns(2, turns);
visitor.visit_clusters(clusters, turns);
detail::overlay::colocate_clusters(clusters, turns);
// AssignCounts should be called:
// * after "colocate_clusters"
// * and "colocate_clusters" after "enrich_discard_turns"
// because assigning side counts needs cluster centroids.
//
// For BUFFER - it is called before, to be able to block closed clusters
// before enrichment.
assign_side_counts
<
Reverse1, Reverse2, OverlayType
>(geometry1, geometry2, turns, clusters, strategy, visitor);
get_properties_ahead<Reverse1, Reverse2>(turns, clusters, geometry1, geometry2, strategy);
// Traverse through intersection/turn points and create rings of them.
// These rings are always in clockwise order.
// In CCW polygons they are marked as "to be reversed" below.
std::map<ring_identifier, ring_turn_info> turn_info_per_ring;
ring_container_type rings;
traverse<Reverse1, Reverse2, Geometry1, Geometry2, OverlayType>::apply
(
@ -332,6 +328,8 @@ struct overlay
clusters,
visitor
);
visitor.visit_clusters(clusters, turns);
visitor.visit_turns(3, turns);
get_ring_turn_info<OverlayType>(turn_info_per_ring, turns, clusters);

8
include/boost/geometry/algorithms/detail/overlay/segment_identifier.hpp
View File

@ -76,13 +76,11 @@ struct segment_identifier
#if defined(BOOST_GEOMETRY_DEBUG_SEGMENT_IDENTIFIER)
friend std::ostream& operator<<(std::ostream &os, segment_identifier const& seg_id)
{
os
<< "s:" << seg_id.source_index
<< ", v:" << seg_id.segment_index // v:vertex because s is used for source
;
if (seg_id.ring_index >= 0) os << ", r:" << seg_id.ring_index;
os << "g:" << seg_id.source_index; // ('geometry' i/o source)
if (seg_id.multi_index >= 0) os << ", m:" << seg_id.multi_index;
if (seg_id.piece_index >= 0) os << ", p:" << seg_id.piece_index;
os << ", r:" << seg_id.ring_index;
os << ", s:" << seg_id.segment_index;
return os;
}
#endif

746
include/boost/geometry/algorithms/detail/overlay/sort_by_side.hpp
View File

@ -1,746 +0,0 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2017-2023 Adam Wulkiewicz, Lodz, Poland.
// This file was modified by Oracle on 2017-2023.
// Modifications copyright (c) 2017-2023 Oracle and/or its affiliates.
// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SORT_BY_SIDE_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SORT_BY_SIDE_HPP
#include <algorithm>
#include <map>
#include <set>
#include <vector>
#include <boost/geometry/algorithms/detail/overlay/approximately_equals.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
#include <boost/geometry/algorithms/detail/direction_code.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
#include <boost/geometry/util/constexpr.hpp>
#include <boost/geometry/util/math.hpp>
#include <boost/geometry/util/select_coordinate_type.hpp>
#include <boost/geometry/util/select_most_precise.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay { namespace sort_by_side
{
// From means: from intersecting-segment-begin-point to cluster
// To means: from cluster to intersecting-segment-end-point
enum direction_type { dir_unknown = -1, dir_from = 0, dir_to = 1 };
using rank_type = signed_size_type;
// Point-wrapper, adding some properties
template <typename Point>
struct ranked_point
{
ranked_point(Point const& p, signed_size_type ti, int oi,
direction_type d, operation_type op, segment_identifier const& si)
: point(p)
, turn_index(ti)
, operation_index(oi)
, direction(d)
, operation(op)
, seg_id(si)
{}
using point_type = Point;
Point point;
rank_type rank{0};
signed_size_type zone{-1}; // index of closed zone, in uu turn there would be 2 zones
signed_size_type turn_index{-1};
int operation_index{-1}; // 0,1
direction_type direction{dir_unknown};
// The number of polygons on the left side
std::size_t count_left{0};
// The number of polygons on the right side
std::size_t count_right{0};
operation_type operation{operation_none};
segment_identifier seg_id;
};
struct less_by_turn_index
{
template <typename T>
inline bool operator()(T const& first, T const& second) const
{
return std::tie(first.turn_index, first.index)
< std::tie(second.turn_index, second.index);
}
};
struct less_by_index
{
template <typename T>
inline bool operator()(T const& first, T const& second) const
{
// First order by direction (from/to)
// Then by turn index
// This can also be the same (for example in buffer), but seg_id is
// never the same
// (Length might be considered too)
return std::tie(first.direction, first.turn_index, first.seg_id)
< std::tie(second.direction, second.turn_index, second.seg_id);
}
};
struct less_false
{
template <typename T>
inline bool operator()(T const&, T const& ) const
{
return false;
}
};
template <typename PointOrigin, typename PointTurn, typename Strategy, typename LessOnSame, typename Compare>
struct less_by_side
{
less_by_side(PointOrigin const& p1, PointTurn const& p2, Strategy const& strategy)
: m_origin(p1)
, m_turn_point(p2)
, m_strategy(strategy)
{}
template <typename T>
inline bool operator()(T const& first, T const& second) const
{
using cs_tag = typename Strategy::cs_tag;
LessOnSame on_same;
Compare compare;
auto const side_strategy = m_strategy.side();
int const side_first = side_strategy.apply(m_origin, m_turn_point, first.point);
int const side_second = side_strategy.apply(m_origin, m_turn_point, second.point);
if (side_first == 0 && side_second == 0)
{
// Both collinear. They might point into different directions: <------*------>
// If so, order the one going backwards as the very first.
int const first_code = direction_code<cs_tag>(m_origin, m_turn_point, first.point);
int const second_code = direction_code<cs_tag>(m_origin, m_turn_point, second.point);
// Order by code, backwards first, then forward.
return first_code != second_code
? first_code < second_code
: on_same(first, second)
;
}
else if (side_first == 0
&& direction_code<cs_tag>(m_origin, m_turn_point, first.point) == -1)
{
// First collinear and going backwards.
// Order as the very first, so return always true
return true;
}
else if (side_second == 0
&& direction_code<cs_tag>(m_origin, m_turn_point, second.point) == -1)
{
// Second is collinear and going backwards
// Order as very last, so return always false
return false;
}
// They are not both collinear
if (side_first != side_second)
{
return compare(side_first, side_second);
}
// They are both left, both right, and/or both collinear (with each other and/or with p1,p2)
// Check mutual side
int const side_second_wrt_first = side_strategy.apply(m_turn_point, first.point, second.point);
if (side_second_wrt_first == 0)
{
return on_same(first, second);
}
int const side_first_wrt_second = side_strategy.apply(m_turn_point, second.point, first.point);
if (side_second_wrt_first != -side_first_wrt_second)
{
// (FP) accuracy error in side calculation, the sides are not opposite.
// In that case they can be handled as collinear.
// If not, then the sort-order might not be stable.
return on_same(first, second);
}
// Both are on same side, and not collinear
// Union: return true if second is right w.r.t. first, so -1,
// so other is 1. union has greater as compare functor
// Intersection: v.v.
return compare(side_first_wrt_second, side_second_wrt_first);
}
private :
PointOrigin const& m_origin;
PointTurn const& m_turn_point;
// Umbrella strategy containing side strategy
Strategy const& m_strategy;
};
// Sorts vectors in counter clockwise order (by default)
// Purposes:
// - from one entry vector, find the next exit vector
// - find the open counts
// - find zones
template
<
bool Reverse1,
bool Reverse2,
overlay_type OverlayType,
typename Point,
typename Strategy,
typename Compare
>
struct side_sorter
{
using rp = ranked_point<Point>;
private :
struct include_union
{
inline bool operator()(rp const& ranked_point) const
{
// New candidate if there are no polygons on left side,
// but there are on right side
return ranked_point.count_left == 0
&& ranked_point.count_right > 0;
}
};
struct include_intersection
{
inline bool operator()(rp const& ranked_point) const
{
// New candidate if there are two polygons on right side,
// and less on the left side
return ranked_point.count_left < 2
&& ranked_point.count_right >= 2;
}
};
public :
side_sorter(Strategy const& strategy)
: m_origin_count(0)
, m_origin_segment_distance(0)
, m_strategy(strategy)
{}
template <typename Operation>
void add_segment_from(signed_size_type turn_index, int op_index,
Point const& point_from,
Operation const& op,
bool is_origin)
{
m_ranked_points.push_back(rp(point_from, turn_index, op_index,
dir_from, op.operation, op.seg_id));
if (is_origin)
{
m_origin = point_from;
m_origin_count++;
}
}
template <typename Operation>
void add_segment_to(signed_size_type turn_index, int op_index,
Point const& point_to,
Operation const& op)
{
m_ranked_points.push_back(rp(point_to, turn_index, op_index,
dir_to, op.operation, op.seg_id));
}
template <typename Operation>
void add_segment(signed_size_type turn_index, int op_index,
Point const& point_from, Point const& point_to,
Operation const& op, bool is_origin)
{
// The segment is added in two parts (sub-segment).
// In picture:
//
// from -----> * -----> to
//
// where * means: cluster point (intersection point)
// from means: start point of original segment
// to means: end point of original segment
// So from/to is from the perspective of the segment.
// From the perspective of the cluster, it is the other way round
// (from means: from-segment-to-cluster, to means: from-cluster-to-segment)
add_segment_from(turn_index, op_index, point_from, op, is_origin);
add_segment_to(turn_index, op_index, point_to, op);
}
template <typename Operation, typename Geometry1, typename Geometry2>
static Point walk_over_ring(Operation const& op, int offset,
Geometry1 const& geometry1,
Geometry2 const& geometry2)
{
Point point;
geometry::copy_segment_point<Reverse1, Reverse2>(geometry1, geometry2, op.seg_id, offset, point);
return point;
}
template <typename Turn, typename Operation, typename Geometry1, typename Geometry2>
Point add(Turn const& turn, Operation const& op, signed_size_type turn_index, int op_index,
Geometry1 const& geometry1,
Geometry2 const& geometry2,
bool is_origin)
{
Point point_from, point2, point3;
geometry::copy_segment_points<Reverse1, Reverse2>(geometry1, geometry2,
op.seg_id, point_from, point2, point3);
Point point_to = op.fraction.is_one() ? point3 : point2;
// If the point is in the neighbourhood (the limit is arbitrary),
// then take a point (or more) further back.
// The limit of offset avoids theoretical infinite loops.
// In practice it currently walks max 1 point back in all cases.
// Use the coordinate type, but if it is too small (e.g. std::int16), use a double
using ct_type = typename geometry::select_most_precise
<
geometry::coordinate_type_t<Point>,
double
>::type;
static auto const tolerance
= common_approximately_equals_epsilon_multiplier<ct_type>::value();
int offset = 0;
while (approximately_equals(point_from, turn.point, tolerance)
&& offset > -10)
{
point_from = walk_over_ring(op, --offset, geometry1, geometry2);
}
// Similarly for the point_to, walk forward
offset = 0;
while (approximately_equals(point_to, turn.point, tolerance)
&& offset < 10)
{
point_to = walk_over_ring(op, ++offset, geometry1, geometry2);
}
add_segment(turn_index, op_index, point_from, point_to, op, is_origin);
return point_from;
}
template <typename Turn, typename Operation, typename Geometry1, typename Geometry2>
void add(Turn const& turn,
Operation const& op, signed_size_type turn_index, int op_index,
segment_identifier const& departure_seg_id,
Geometry1 const& geometry1,
Geometry2 const& geometry2,
bool is_departure)
{
auto const potential_origin = add(turn, op, turn_index, op_index, geometry1, geometry2, false);
if (is_departure)
{
bool const is_origin
= op.seg_id.source_index == departure_seg_id.source_index
&& op.seg_id.ring_index == departure_seg_id.ring_index
&& op.seg_id.multi_index == departure_seg_id.multi_index;
if (is_origin)
{
signed_size_type const sd
= departure_seg_id.source_index == 0
? segment_distance(geometry1, departure_seg_id, op.seg_id)
: segment_distance(geometry2, departure_seg_id, op.seg_id);
if (m_origin_count == 0 || sd < m_origin_segment_distance)
{
m_origin = potential_origin;
m_origin_segment_distance = sd;
}
m_origin_count++;
}
}
}
template <typename PointTurn>
void apply(PointTurn const& turn_point)
{
// We need three compare functors:
// 1) to order clockwise (union) or counter clockwise (intersection)
// 2) to order by side, resulting in unique ranks for all points
// 3) to order by side, resulting in non-unique ranks
// to give colinear points
// Sort by side and assign rank
less_by_side<Point, PointTurn, Strategy, less_by_index, Compare> less_unique(m_origin, turn_point, m_strategy);
less_by_side<Point, PointTurn, Strategy, less_false, Compare> less_non_unique(m_origin, turn_point, m_strategy);
std::sort(m_ranked_points.begin(), m_ranked_points.end(), less_unique);
std::size_t colinear_rank = 0;
for (std::size_t i = 0; i < m_ranked_points.size(); i++)
{
if (i > 0
&& less_non_unique(m_ranked_points[i - 1], m_ranked_points[i]))
{
// It is not collinear
colinear_rank++;
}
m_ranked_points[i].rank = colinear_rank;
}
}
void find_open_by_piece_index()
{
// For buffers, use piece index
std::set<signed_size_type> handled;
for (std::size_t i = 0; i < m_ranked_points.size(); i++)
{
rp const& ranked = m_ranked_points[i];
if (ranked.direction != dir_from)
{
continue;
}
signed_size_type const& index = ranked.seg_id.piece_index;
if (handled.count(index) > 0)
{
continue;
}
find_polygons_for_source<&segment_identifier::piece_index>(index, i);
handled.insert(index);
}
}
void find_open_by_source_index()
{
// Check for source index 0 and 1
bool handled[2] = {false, false};
for (std::size_t i = 0; i < m_ranked_points.size(); i++)
{
rp const& ranked = m_ranked_points[i];
if (ranked.direction != dir_from)
{
continue;
}
signed_size_type const& index = ranked.seg_id.source_index;
if (index < 0 || index > 1 || handled[index])
{
continue;
}
find_polygons_for_source<&segment_identifier::source_index>(index, i);
handled[index] = true;
}
}
void find_open()
{
if BOOST_GEOMETRY_CONSTEXPR (OverlayType == overlay_buffer)
{
find_open_by_piece_index();
}
else
{
find_open_by_source_index();
}
}
void reverse()
{
if (m_ranked_points.empty())
{
return;
}
std::size_t const last = 1 + m_ranked_points.back().rank;
// Move iterator after rank==0
bool has_first = false;
auto it = m_ranked_points.begin() + 1;
for (; it != m_ranked_points.end() && it->rank == 0; ++it)
{
has_first = true;
}
if (has_first)
{
// Reverse first part (having rank == 0), if any,
// but skip the very first row
std::reverse(m_ranked_points.begin() + 1, it);
for (auto fit = m_ranked_points.begin(); fit != it; ++fit)
{
BOOST_ASSERT(fit->rank == 0);
}
}
// Reverse the rest (main rank > 0)
std::reverse(it, m_ranked_points.end());
for (; it != m_ranked_points.end(); ++it)
{
BOOST_ASSERT(it->rank > 0);
it->rank = last - it->rank;
}
}
bool has_origin() const
{
return m_origin_count > 0;
}
//private :
using container_type = std::vector<rp>;
container_type m_ranked_points;
Point m_origin;
std::size_t m_origin_count;
signed_size_type m_origin_segment_distance;
// Umbrella strategy containing side strategy
Strategy m_strategy;
private :
//! Check how many open spaces there are
template <typename Include>
inline std::size_t open_count(Include const& include_functor) const
{
std::size_t result = 0;
rank_type last_rank = 0;
for (std::size_t i = 0; i < m_ranked_points.size(); i++)
{
rp const& ranked_point = m_ranked_points[i];
if (ranked_point.rank > last_rank
&& ranked_point.direction == sort_by_side::dir_to
&& include_functor(ranked_point))
{
result++;
last_rank = ranked_point.rank;
}
}
return result;
}
std::size_t move(std::size_t index) const
{
std::size_t const result = index + 1;
return result >= m_ranked_points.size() ? 0 : result;
}
//! member is pointer to member (source_index or multi_index)
template <signed_size_type segment_identifier::*Member>
std::size_t move(signed_size_type member_index, std::size_t index) const
{
std::size_t result = move(index);
while (m_ranked_points[result].seg_id.*Member != member_index)
{
result = move(result);
}
return result;
}
void assign_ranks(rank_type min_rank, rank_type max_rank, int side_index)
{
for (std::size_t i = 0; i < m_ranked_points.size(); i++)
{
rp& ranked = m_ranked_points[i];
// Suppose there are 8 ranks, if min=4,max=6: assign 4,5,6
// if min=5,max=2: assign from 5,6,7,1,2
bool const in_range
= max_rank >= min_rank
? ranked.rank >= min_rank && ranked.rank <= max_rank
: ranked.rank >= min_rank || ranked.rank <= max_rank
;
if (in_range)
{
if (side_index == 1)
{
ranked.count_left++;
}
else if (side_index == 2)
{
ranked.count_right++;
}
}
}
}
template <signed_size_type segment_identifier::*Member>
void find_polygons_for_source(signed_size_type the_index,
std::size_t start_index)
{
bool in_polygon = true; // Because start_index is "from", arrives at the turn
rp const& start_rp = m_ranked_points[start_index];
rank_type last_from_rank = start_rp.rank;
rank_type previous_rank = start_rp.rank;
for (std::size_t index = move<Member>(the_index, start_index);
;
index = move<Member>(the_index, index))
{
rp& ranked = m_ranked_points[index];
if (ranked.rank != previous_rank && ! in_polygon)
{
assign_ranks(last_from_rank, previous_rank - 1, 1);
assign_ranks(last_from_rank + 1, previous_rank, 2);
}
if (index == start_index)
{
return;
}
if (ranked.direction == dir_from)
{
last_from_rank = ranked.rank;
in_polygon = true;
}
else if (ranked.direction == dir_to)
{
in_polygon = false;
}
previous_rank = ranked.rank;
}
}
//! Find closed zones and assign it
template <typename Include>
std::size_t assign_zones(Include const& include_functor)
{
// Find a starting point (the first rank after an outgoing rank
// with no polygons on the left side)
rank_type start_rank = m_ranked_points.size() + 1;
std::size_t start_index = 0;
rank_type max_rank = 0;
for (std::size_t i = 0; i < m_ranked_points.size(); i++)
{
rp const& ranked_point = m_ranked_points[i];
if (ranked_point.rank > max_rank)
{
max_rank = ranked_point.rank;
}
if (ranked_point.direction == sort_by_side::dir_to
&& include_functor(ranked_point))
{
start_rank = ranked_point.rank + 1;
}
if (ranked_point.rank == start_rank && start_index == 0)
{
start_index = i;
}
}
// Assign the zones
rank_type const undefined_rank = max_rank + 1;
std::size_t zone_id = 0;
rank_type last_rank = 0;
rank_type rank_at_next_zone = undefined_rank;
std::size_t index = start_index;
for (std::size_t i = 0; i < m_ranked_points.size(); i++)
{
rp& ranked_point = m_ranked_points[index];
// Implement cyclic behavior
index++;
if (index == m_ranked_points.size())
{
index = 0;
}
if (ranked_point.rank != last_rank)
{
if (ranked_point.rank == rank_at_next_zone)
{
zone_id++;
rank_at_next_zone = undefined_rank;
}
if (ranked_point.direction == sort_by_side::dir_to
&& include_functor(ranked_point))
{
rank_at_next_zone = ranked_point.rank + 1;
if (rank_at_next_zone > max_rank)
{
rank_at_next_zone = 0;
}
}
last_rank = ranked_point.rank;
}
ranked_point.zone = zone_id;
}
return zone_id;
}
public :
inline std::size_t open_count(operation_type for_operation) const
{
return for_operation == operation_union
? open_count(include_union())
: open_count(include_intersection())
;
}
inline std::size_t assign_zones(operation_type for_operation)
{
return for_operation == operation_union
? assign_zones(include_union())
: assign_zones(include_intersection())
;
}
};
//! Metafunction to define side_order (clockwise, ccw) by operation_type
template <operation_type OpType>
struct side_compare {};
template <>
struct side_compare<operation_union>
{
using type = std::greater<int>;
};
template <>
struct side_compare<operation_intersection>
{
using type = std::less<int>;
};
}}} // namespace detail::overlay::sort_by_side
#endif //DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SORT_BY_SIDE_HPP

1
include/boost/geometry/algorithms/detail/overlay/stream_info.hpp
View File

@ -57,7 +57,6 @@ namespace detail { namespace overlay
<< dir(info.sides.template get<1,1>())
<< " nxt seg " << info.travels_to_vertex_index
<< " , ip " << info.travels_to_ip_index
<< " , or " << info.next_ip_index
<< " frac " << info.fraction
<< info.visit_state;
if (info.flagged)

1017
include/boost/geometry/algorithms/detail/overlay/traversal.hpp
View File

File diff suppressed because it is too large Load Diff

2
include/boost/geometry/algorithms/detail/overlay/traversal_info.hpp
View File

@ -12,7 +12,6 @@
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/enrichment_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/visit_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
@ -28,7 +27,6 @@ template <typename Point, typename SegmentRatio>
struct traversal_turn_operation : public turn_operation<Point, SegmentRatio>
{
enrichment_info<Point> enriched;
visit_info visited;
};
template <typename Point, typename SegmentRatio>

427
include/boost/geometry/algorithms/detail/overlay/traversal_ring_creator.hpp
View File

@ -1,427 +0,0 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
// This file was modified by Oracle on 2017-2024.
// Modifications copyright (c) 2017-2024, Oracle and/or its affiliates.
// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_RING_CREATOR_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_RING_CREATOR_HPP
#include <cstddef>
#include <boost/range/value_type.hpp>
#include <boost/range/size.hpp>
#include <boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/traversal.hpp>
#include <boost/geometry/algorithms/num_points.hpp>
#include <boost/geometry/core/assert.hpp>
#include <boost/geometry/core/closure.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
template
<
bool Reverse1,
bool Reverse2,
overlay_type OverlayType,
typename Geometry1,
typename Geometry2,
typename Turns,
typename TurnInfoMap,
typename Clusters,
typename Strategy,
typename Visitor,
typename Backtrack
>
struct traversal_ring_creator
{
using traversal_type = traversal
<
Reverse1, Reverse2, OverlayType,
Geometry1, Geometry2, Turns, Clusters,
Strategy,
Visitor
>;
using turn_type = typename boost::range_value<Turns>::type;
using turn_operation_type = typename turn_type::turn_operation_type;
static const operation_type target_operation
= operation_from_overlay<OverlayType>::value;
inline traversal_ring_creator(Geometry1 const& geometry1, Geometry2 const& geometry2,
Turns& turns, TurnInfoMap& turn_info_map,
Clusters const& clusters,
Strategy const& strategy,
Visitor& visitor)
: m_trav(geometry1, geometry2, turns, clusters,
strategy, visitor)
, m_geometry1(geometry1)
, m_geometry2(geometry2)
, m_turns(turns)
, m_turn_info_map(turn_info_map)
, m_clusters(clusters)
, m_strategy(strategy)
, m_visitor(visitor)
{
}
template <typename Ring>
inline traverse_error_type travel_to_next_turn(signed_size_type start_turn_index,
int start_op_index,
signed_size_type& turn_index,
int& op_index,
Ring& current_ring,
bool is_start)
{
int const previous_op_index = op_index;
signed_size_type const previous_turn_index = turn_index;
turn_type& previous_turn = m_turns[turn_index];
turn_operation_type& previous_op = previous_turn.operations[op_index];
segment_identifier previous_seg_id;
signed_size_type to_vertex_index = -1;
if (! m_trav.select_turn_from_enriched(turn_index, previous_seg_id,
to_vertex_index, start_turn_index, start_op_index,
previous_turn, previous_op, is_start))
{
return is_start
? traverse_error_no_next_ip_at_start
: traverse_error_no_next_ip;
}
if (to_vertex_index >= 0)
{
if (previous_op.seg_id.source_index == 0)
{
geometry::copy_segments<Reverse1>(m_geometry1,
previous_op.seg_id, to_vertex_index,
m_strategy, current_ring);
}
else
{
geometry::copy_segments<Reverse2>(m_geometry2,
previous_op.seg_id, to_vertex_index,
m_strategy, current_ring);
}
}
if (m_turns[turn_index].discarded)
{
return is_start
? traverse_error_dead_end_at_start
: traverse_error_dead_end;
}
if (is_start)
{
// Register the start
previous_op.visited.set_started();
m_visitor.visit_traverse(m_turns, previous_turn, previous_op, "Start");
}
if (! m_trav.select_turn(start_turn_index, start_op_index,
turn_index, op_index,
previous_op_index, previous_turn_index, previous_seg_id,
is_start, boost::size(current_ring) > 1))
{
return is_start
? traverse_error_no_next_ip_at_start
: traverse_error_no_next_ip;
}
{
// Check operation (TODO: this might be redundant or should be catched before)
turn_type const& current_turn = m_turns[turn_index];
turn_operation_type const& op = current_turn.operations[op_index];
if (op.visited.finalized()
|| m_trav.is_visited(current_turn, op, turn_index, op_index))
{
return traverse_error_visit_again;
}
}
// Update registration and append point
turn_type& current_turn = m_turns[turn_index];
turn_operation_type& op = current_turn.operations[op_index];
detail::overlay::append_no_collinear(current_ring, current_turn.point,
m_strategy);
// Register the visit
m_trav.set_visited(current_turn, op);
m_visitor.visit_traverse(m_turns, current_turn, op, "Visit");
return traverse_error_none;
}
template <typename Ring>
inline traverse_error_type traverse(Ring& ring,
signed_size_type start_turn_index, int start_op_index)
{
turn_type const& start_turn = m_turns[start_turn_index];
turn_operation_type& start_op = m_turns[start_turn_index].operations[start_op_index];
detail::overlay::append_no_collinear(ring, start_turn.point,
m_strategy);
signed_size_type current_turn_index = start_turn_index;
int current_op_index = start_op_index;
traverse_error_type error = travel_to_next_turn(start_turn_index,
start_op_index,
current_turn_index, current_op_index,
ring, true);
if (error != traverse_error_none)
{
// This is not necessarily a problem, it happens for clustered turns
// which are "build in" or otherwise point inwards
return error;
}
if (current_turn_index == start_turn_index)
{
start_op.visited.set_finished();
m_visitor.visit_traverse(m_turns, m_turns[current_turn_index], start_op, "Early finish");
return traverse_error_none;
}
if (start_turn.is_clustered())
{
turn_type& turn = m_turns[current_turn_index];
turn_operation_type& op = turn.operations[current_op_index];
if (turn.cluster_id == start_turn.cluster_id
&& op.enriched.get_next_turn_index() == start_turn_index)
{
op.visited.set_finished();
m_visitor.visit_traverse(m_turns, m_turns[current_turn_index], start_op, "Early finish (cluster)");
return traverse_error_none;
}
}
std::size_t const max_iterations = 2 + 2 * m_turns.size();
for (std::size_t i = 0; i <= max_iterations; i++)
{
// We assume clockwise polygons only, non self-intersecting, closed.
// However, the input might be different, and checking validity
// is up to the library user.
// Therefore we make here some sanity checks. If the input
// violates the assumptions, the output polygon will not be correct
// but the routine will stop and output the current polygon, and
// will continue with the next one.
// Below three reasons to stop.
error = travel_to_next_turn(start_turn_index, start_op_index,
current_turn_index, current_op_index,
ring, false);
if (error != traverse_error_none)
{
return error;
}
if (current_turn_index == start_turn_index
&& current_op_index == start_op_index)
{
start_op.visited.set_finished();
m_visitor.visit_traverse(m_turns, start_turn, start_op, "Finish");
return traverse_error_none;
}
}
return traverse_error_endless_loop;
}
template <typename Rings>
void traverse_with_operation(turn_type const& start_turn,
std::size_t turn_index, int op_index,
Rings& rings, std::size_t& finalized_ring_size,
typename Backtrack::state_type& state)
{
using ring_type = typename boost::range_value<Rings>::type;
turn_operation_type const& start_op = start_turn.operations[op_index];
if (! start_op.visited.none()
|| ! start_op.enriched.startable
|| start_op.visited.rejected()
|| ! (start_op.operation == target_operation
|| start_op.operation == detail::overlay::operation_continue))
{
return;
}
ring_type ring;
traverse_error_type traverse_error = traverse(ring, turn_index, op_index);
if (traverse_error == traverse_error_none)
{
remove_spikes_at_closure(ring, m_strategy);
fix_closure(ring, m_strategy);
std::size_t const min_num_points
= core_detail::closure::minimum_ring_size
<
geometry::closure<ring_type>::value
>::value;
if (geometry::num_points(ring) >= min_num_points)
{
rings.push_back(ring);
m_trav.finalize_visit_info(m_turn_info_map);
finalized_ring_size++;
}
}
else
{
Backtrack::apply(finalized_ring_size,
rings, ring, m_turns, start_turn,
m_turns[turn_index].operations[op_index],
traverse_error,
m_geometry1, m_geometry2,
m_strategy,
state, m_visitor);
}
}
int get_operation_index(turn_type const& turn) const
{
// When starting with a continue operation, the one
// with the smallest (for intersection) or largest (for union)
// remaining distance (#8310b)
// Also to avoid skipping a turn in between, which can happen
// in rare cases (e.g. #130)
static const bool is_union
= operation_from_overlay<OverlayType>::value == operation_union;
turn_operation_type const& op0 = turn.operations[0];
turn_operation_type const& op1 = turn.operations[1];
return op0.remaining_distance <= op1.remaining_distance
? (is_union ? 1 : 0)
: (is_union ? 0 : 1);
}
template <typename Rings>
void iterate(Rings& rings, std::size_t& finalized_ring_size,
typename Backtrack::state_type& state)
{
auto do_iterate = [&](int phase)
{
for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
{
turn_type const& turn = m_turns[turn_index];
if (turn.discarded || turn.blocked() || (phase == 0 && turn.is_clustered()))
{
// Skip discarded and blocked turns
continue;
}
if (turn.both(operation_continue))
{
traverse_with_operation(turn, turn_index,
get_operation_index(turn),
rings, finalized_ring_size, state);
}
else
{
for (int op_index = 0; op_index < 2; op_index++)
{
traverse_with_operation(turn, turn_index, op_index,
rings, finalized_ring_size, state);
}
}
}
};
// Traverse all turns, first starting with the non-clustered ones.
do_iterate(0);
// Traverse remaining clustered turns, if any.
do_iterate(1);
}
template <typename Rings>
void iterate_with_preference(std::size_t phase,
Rings& rings, std::size_t& finalized_ring_size,
typename Backtrack::state_type& state)
{
for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
{
turn_type const& turn = m_turns[turn_index];
if (turn.discarded || turn.blocked())
{
// Skip discarded and blocked turns
continue;
}
turn_operation_type const& op0 = turn.operations[0];
turn_operation_type const& op1 = turn.operations[1];
if (phase == 0)
{
if (! op0.enriched.prefer_start && ! op1.enriched.prefer_start)
{
// Not preferred, take next one
continue;
}
}
if (turn.both(operation_continue))
{
traverse_with_operation(turn, turn_index,
get_operation_index(turn),
rings, finalized_ring_size, state);
}
else
{
bool const forward = op0.enriched.prefer_start;
int op_index = forward ? 0 : 1;
int const increment = forward ? 1 : -1;
for (int i = 0; i < 2; i++, op_index += increment)
{
traverse_with_operation(turn, turn_index, op_index,
rings, finalized_ring_size, state);
}
}
}
}
private:
traversal_type m_trav;
Geometry1 const& m_geometry1;
Geometry2 const& m_geometry2;
Turns& m_turns;
TurnInfoMap& m_turn_info_map; // contains turn-info information per ring
Clusters const& m_clusters;
Strategy const& m_strategy;
Visitor& m_visitor;
};
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_RING_CREATOR_HPP

746
include/boost/geometry/algorithms/detail/overlay/traversal_switch_detector.hpp
View File

@ -1,746 +0,0 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2015-2016 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2023 Adam Wulkiewicz, Lodz, Poland.
// This file was modified by Oracle on 2018-2024.
// Modifications copyright (c) 2018-2024 Oracle and/or its affiliates.
// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_SWITCH_DETECTOR_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_SWITCH_DETECTOR_HPP
#include <boost/range/value_type.hpp>
#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
#include <boost/geometry/algorithms/detail/overlay/cluster_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/is_self_turn.hpp>
#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
#include <boost/geometry/core/access.hpp>
#endif
#include <boost/geometry/util/constexpr.hpp>
#include <cstddef>
#include <map>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
// The switch detector, the first phase in traversal, inspects UU and II turns.
// Suppose you have these two polygons in a union. There is one UU turn.
// +-------+
// | |
// | A |
// | |
// +-------U---------+ U = UU turn
// | |
// | B |
// | |
// +---------+
// It first assigns region ids, A gets id 1 and B gets id 2.
// Because of that, it should NOT switch sources in traversal at U.
// So coming from upper left, it follows A, and also at U it keeps following A.
// The result is two rings. (See for example testcase "case_31" or others.)
//
// But suppose you have two larger input polygons, partially overlapping:
// +-----------------+
// | |
// | A +-----T---C I = interior in output
// | | I | O | O = overlap A & B (included in output)
// +-------U-----T---C U = UU turn
// | | T = normal turn (u/i)
// | B | C = collinear turn (c/c)
// | |
// +---------+
// Rings A and B will be connected (by inspecting turn information)
// and there will be one region 1.
// Because of that, it will switch sources in traversal at U.
// So coming from lower right, it follows B but at U it will switch to A.
// Also for the generated interior ring, coming from the top via A it will at U
// switch to B and go to the right, generating I. (See for example "case_91")
// Switching using region_id is only relevant for UU or II turns.
// In all T turns it will follow "u" for union or "i" for intersection,
// and in C turns it will follow either direction (they are the same).
// There is also "isolated", making it more complex, and documented below.
template
<
bool Reverse1,
bool Reverse2,
overlay_type OverlayType,
typename Geometry1,
typename Geometry2,
typename Turns,
typename Clusters,
typename Visitor
>
struct traversal_switch_detector
{
static const operation_type target_operation
= operation_from_overlay<OverlayType>::value;
enum isolation_type
{
isolation_no = 0,
isolation_yes = 1,
isolation_multiple = 2
};
using turn_type = typename boost::range_value<Turns>::type;
using set_type= std::set<signed_size_type>;
// Per ring, first turns are collected (in turn_indices), and later
// a region_id is assigned
struct merged_ring_properties
{
signed_size_type region_id = -1;
set_type turn_indices;
};
struct connection_properties
{
std::size_t count = 0;
// Set with turn-index OR (if clustered) the negative cluster_id
set_type unique_turn_ids;
};
// Maps region_id -> properties
using connection_map = std::map<signed_size_type, connection_properties>;
// Per region, a set of properties is maintained, including its connections
// to other regions
struct region_properties
{
signed_size_type region_id = -1;
isolation_type isolated = isolation_no;
set_type unique_turn_ids;
connection_map connected_region_counts;
};
// Maps ring -> properties
using merge_map = std::map<ring_identifier, merged_ring_properties>;
// Maps region_id -> properties
using region_connection_map = std::map<signed_size_type, region_properties>;
inline traversal_switch_detector(Geometry1 const& geometry1,
Geometry2 const& geometry2,
Turns& turns, Clusters const& clusters,
Visitor& visitor)
: m_geometry1(geometry1)
, m_geometry2(geometry2)
, m_turns(turns)
, m_clusters(clusters)
, m_visitor(visitor)
{
}
bool one_connection_to_another_region(region_properties const& region) const
{
// For example:
// +----------------------+
// | __ |
// | / \|
// | | x
// | \__/|
// | |
// +----------------------+
if (region.connected_region_counts.size() == 1)
{
auto const& cprop = region.connected_region_counts.begin()->second;
return cprop.count <= 1;
}
return region.connected_region_counts.empty();
}
// TODO: might be combined with previous
bool multiple_connections_to_one_region(region_properties const& region) const
{
// For example:
// +----------------------+
// | __ |
// | / \|
// | | x
// | \ /|
// | / \|
// | | x
// | \__/|
// | |
// +----------------------+
if (region.connected_region_counts.size() == 1)
{
auto const& cprop = region.connected_region_counts.begin()->second;
return cprop.count > 1;
}
return false;
}
bool one_connection_to_multiple_regions(region_properties const& region) const
{
// For example:
// +----------------------+
// | __ | __
// | / \|/ |
// | | x |
// | \__/|\__|
// | |
// +----------------------+
bool first = true;
signed_size_type first_turn_id = 0;
for (auto const& key_val : region.connected_region_counts)
{
auto const& cprop = key_val.second;
if (cprop.count != 1)
{
return false;
}
auto const unique_turn_id = *cprop.unique_turn_ids.begin();
if (first)
{
first_turn_id = unique_turn_id;
first = false;
}
else if (first_turn_id != unique_turn_id)
{
return false;
}
}
return true;
}
bool ii_turn_connects_two_regions(region_properties const& region,
region_properties const& connected_region,
signed_size_type turn_index) const
{
turn_type const& turn = m_turns[turn_index];
if (! turn.both(operation_intersection))
{
return false;
}
signed_size_type const id0 = turn.operations[0].enriched.region_id;
signed_size_type const id1 = turn.operations[1].enriched.region_id;
return (id0 == region.region_id && id1 == connected_region.region_id)
|| (id1 == region.region_id && id0 == connected_region.region_id);
}
bool isolated_multiple_connection(region_properties const& region,
region_properties const& connected_region) const
{
if (connected_region.isolated != isolation_multiple)
{
return false;
}
// First step: compare turns of regions with turns of connected region
set_type turn_ids = region.unique_turn_ids;
for (auto turn_id : connected_region.unique_turn_ids)
{
turn_ids.erase(turn_id);
}
// There should be one connection (turn or cluster) left
if (turn_ids.size() != 1)
{
return false;
}
for (auto id_or_index : connected_region.unique_turn_ids)
{
if (id_or_index >= 0)
{
if (! ii_turn_connects_two_regions(region, connected_region, id_or_index))
{
return false;
}
}
else
{
signed_size_type const cluster_id = -id_or_index;
auto it = m_clusters.find(cluster_id);
if (it != m_clusters.end())
{
cluster_info const& cinfo = it->second;
for (auto turn_index : cinfo.turn_indices)
{
if (! ii_turn_connects_two_regions(region, connected_region, turn_index))
{
return false;
}
}
}
}
}
return true;
}
bool has_only_isolated_children(region_properties const& region) const
{
bool first_with_turn = true;
signed_size_type first_turn_id = 0;
for (auto const& key_val : region.connected_region_counts)
{
signed_size_type const region_id = key_val.first;
connection_properties const& cprop = key_val.second;
auto mit = m_connected_regions.find(region_id);
if (mit == m_connected_regions.end())
{
// Should not occur
return false;
}
region_properties const& connected_region = mit->second;
if (cprop.count != 1)
{
// If there are more connections, check their isolation
if (! isolated_multiple_connection(region, connected_region))
{
return false;
}
}
if (connected_region.isolated != isolation_yes
&& connected_region.isolated != isolation_multiple)
{
signed_size_type const unique_turn_id = *cprop.unique_turn_ids.begin();
if (first_with_turn)
{
first_turn_id = unique_turn_id;
first_with_turn = false;
}
else if (first_turn_id != unique_turn_id)
{
return false;
}
}
}
// If there is only one connection (with a 'parent'), and all other
// connections are itself isolated, it is isolated
return true;
}
void get_isolated_regions()
{
// First time: check regions isolated (one connection only),
// semi-isolated (multiple connections between same region),
// and complex isolated (connection with multiple rings but all
// at same point)
for (auto& key_val : m_connected_regions)
{
region_properties& properties = key_val.second;
if (one_connection_to_another_region(properties))
{
properties.isolated = isolation_yes;
}
else if (multiple_connections_to_one_region(properties))
{
properties.isolated = isolation_multiple;
}
else if (one_connection_to_multiple_regions(properties))
{
properties.isolated = isolation_yes;
}
}
// Propagate isolation to next level
// TODO: should be optimized
std::size_t defensive_check = 0;
bool changed = true;
while (changed && defensive_check++ < m_connected_regions.size())
{
changed = false;
for (auto& key_val : m_connected_regions)
{
region_properties& properties = key_val.second;
if (properties.isolated == isolation_no
&& has_only_isolated_children(properties))
{
properties.isolated = isolation_yes;
changed = true;
}
}
}
}
void assign_isolation_to_enriched()
{
for (turn_type& turn : m_turns)
{
constexpr auto order1 = geometry::point_order<Geometry1>::value;
constexpr bool reverse1 = (order1 == boost::geometry::counterclockwise)
? ! Reverse1 : Reverse1;
constexpr auto order2 = geometry::point_order<Geometry2>::value;
constexpr bool reverse2 = (order2 == boost::geometry::counterclockwise)
? ! Reverse2 : Reverse2;
// For difference, for the input walked through in reverse,
// the meaning is reversed: what is isolated is actually not,
// and vice versa.
bool const reverseMeaningInTurn
= (reverse1 || reverse2)
&& ! turn.is_self()
&& ! turn.is_clustered()
&& uu_or_ii(turn)
&& turn.operations[0].enriched.region_id
!= turn.operations[1].enriched.region_id;
for (auto& op : turn.operations)
{
auto mit = m_connected_regions.find(op.enriched.region_id);
if (mit != m_connected_regions.end())
{
bool const reverseMeaningInOp
= reverseMeaningInTurn
&& ((op.seg_id.source_index == 0 && reverse1)
|| (op.seg_id.source_index == 1 && reverse2));
// It is assigned to isolated if it's property is "Yes",
// (one connected interior, or chained).
// "Multiple" doesn't count for isolation,
// neither for intersection, neither for difference.
region_properties const& prop = mit->second;
op.enriched.isolated
= reverseMeaningInOp
? false
: prop.isolated == isolation_yes;
}
}
}
}
void assign_region_ids_to_enriched()
{
for (auto const& key_val : m_turns_per_ring)
{
ring_identifier const& ring_id = key_val.first;
merged_ring_properties const& properties = key_val.second;
for (auto turn_index : properties.turn_indices)
{
turn_type& turn = m_turns[turn_index];
if (! acceptable(turn))
{
// No assignment necessary
continue;
}
for (auto& op : turn.operations)
{
if (ring_id_by_seg_id(op.seg_id) == ring_id)
{
op.enriched.region_id = properties.region_id;
}
}
}
}
}
void assign_connected_regions()
{
for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
{
turn_type const& turn = m_turns[turn_index];
signed_size_type const unique_turn_id
= turn.is_clustered() ? -turn.cluster_id : turn_index;
signed_size_type const& id0 = turn.operations[0].enriched.region_id;
signed_size_type const& id1 = turn.operations[1].enriched.region_id;
// Add region (by assigning) and add involved turns
if (id0 != -1)
{
m_connected_regions[id0].region_id = id0;
m_connected_regions[id0].unique_turn_ids.insert(unique_turn_id);
}
if (id1 != -1 && id0 != id1)
{
m_connected_regions[id1].region_id = id1;
m_connected_regions[id1].unique_turn_ids.insert(unique_turn_id);
}
if (id0 != id1 && id0 != -1 && id1 != -1)
{
// Assign connections
connection_properties& prop0 = m_connected_regions[id0].connected_region_counts[id1];
connection_properties& prop1 = m_connected_regions[id1].connected_region_counts[id0];
// Reference this turn or cluster to later check uniqueness on ring
if (prop0.unique_turn_ids.count(unique_turn_id) == 0)
{
prop0.count++;
prop0.unique_turn_ids.insert(unique_turn_id);
}
if (prop1.unique_turn_ids.count(unique_turn_id) == 0)
{
prop1.count++;
prop1.unique_turn_ids.insert(unique_turn_id);
}
}
}
}
inline bool acceptable(turn_type const& turn) const
{
// Discarded turns don't connect rings to the same region
// Also xx are not relevant
// (otherwise discarded colocated uu turn could make a connection)
return ! turn.discarded && ! turn.both(operation_blocked);
}
inline bool uu_or_ii(turn_type const& turn) const
{
return turn.both(operation_union) || turn.both(operation_intersection);
}
inline bool connects_same_region(turn_type const& turn) const
{
if (! acceptable(turn))
{
return false;
}
if (! turn.is_clustered())
{
// If it is a uu/ii-turn (non clustered), it is never same region
return ! uu_or_ii(turn);
}
if BOOST_GEOMETRY_CONSTEXPR (target_operation == operation_union)
{
// It is a cluster, check zones
// (assigned by sort_by_side/handle colocations) of both operations
return turn.operations[0].enriched.zone
== turn.operations[1].enriched.zone;
}
else // else prevents unreachable code warning
{
// For an intersection, two regions connect if they are not ii
// (ii-regions are isolated) or, in some cases, not iu (for example
// when a multi-polygon is inside an interior ring and connecting it)
return ! (turn.both(operation_intersection)
|| turn.combination(operation_intersection, operation_union));
}
}
void create_region(signed_size_type& new_region_id, ring_identifier const& ring_id,
merged_ring_properties& properties, signed_size_type region_id = -1)
{
if (properties.region_id > 0)
{
// Already handled
return;
}
// Assign new id if this is a new region
if (region_id == -1)
{
region_id = new_region_id++;
}
// Assign this ring to specified region
properties.region_id = region_id;
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
std::cout << " ADD " << ring_id << " TO REGION " << region_id << std::endl;
#endif
// Find connecting rings, recursively
for (auto turn_index : properties.turn_indices)
{
turn_type const& turn = m_turns[turn_index];
if (! connects_same_region(turn))
{
// This is a non clustered uu/ii-turn, or a cluster connecting different 'zones'
continue;
}
// Union: This turn connects two rings (interior connected), create the region
// Intersection: This turn connects two rings, set same regions for these two rings
for (auto const& op : turn.operations)
{
ring_identifier connected_ring_id = ring_id_by_seg_id(op.seg_id);
if (connected_ring_id != ring_id)
{
propagate_region(new_region_id, connected_ring_id, region_id);
}
}
}
}
void propagate_region(signed_size_type& new_region_id,
ring_identifier const& ring_id, signed_size_type region_id)
{
auto it = m_turns_per_ring.find(ring_id);
if (it != m_turns_per_ring.end())
{
create_region(new_region_id, ring_id, it->second, region_id);
}
}
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
void debug_show_results()
{
auto isolation_to_string = [](isolation_type const& iso) -> std::string
{
switch(iso)
{
case isolation_no : return "no";
case isolation_yes : return "yes";
case isolation_multiple : return "multiple";
}
return "error";
};
auto set_to_string = [](auto const& s) -> std::string
{
std::ostringstream result;
for (auto item : s) { result << " " << item; }
return result.str();
};
for (auto const& kv : m_connected_regions)
{
auto const& prop = kv.second;
std::ostringstream sub;
sub << "[turns" << set_to_string(prop.unique_turn_ids)
<< "] regions";
for (auto const& kvs : prop.connected_region_counts)
{
sub << " { " << kvs.first
<< " : via [" << set_to_string(kvs.second.unique_turn_ids)
<< " ] }";
}
std::cout << "REGION " << prop.region_id
<< " " << isolation_to_string(prop.isolated)
<< " " << sub.str()
<< std::endl;
}
for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
{
turn_type const& turn = m_turns[turn_index];
if (uu_or_ii(turn) && ! turn.is_clustered())
{
std::cout << (turn.both(operation_union) ? "UU" : "II")
<< " " << turn_index
<< " (" << geometry::get<0>(turn.point)
<< ", " << geometry::get<1>(turn.point) << ")"
<< " -> " << std::boolalpha
<< " [" << turn.operations[0].seg_id.source_index
<< "/" << turn.operations[1].seg_id.source_index << "] "
<< "(" << turn.operations[0].enriched.region_id
<< " " << turn.operations[0].enriched.isolated
<< ") / (" << turn.operations[1].enriched.region_id
<< " " << turn.operations[1].enriched.isolated << ")"
<< std::endl;
}
}
for (auto const& key_val : m_clusters)
{
cluster_info const& cinfo = key_val.second;
std::cout << "CL RESULT " << key_val.first
<< " -> " << cinfo.open_count << std::endl;
}
}
#endif
void iterate()
{
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
std::cout << "BEGIN SWITCH DETECTOR (region_ids and isolation)"
<< (Reverse1 ? " REVERSE_1" : "")
<< (Reverse2 ? " REVERSE_2" : "")
<< std::endl;
#endif
// Collect turns per ring
m_turns_per_ring.clear();
m_connected_regions.clear();
for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
{
turn_type const& turn = m_turns[turn_index];
if BOOST_GEOMETRY_CONSTEXPR (target_operation == operation_intersection)
{
if (turn.discarded)
{
// Discarded turn (union currently still needs it to determine regions)
continue;
}
}
for (auto const& op : turn.operations)
{
m_turns_per_ring[ring_id_by_seg_id(op.seg_id)].turn_indices.insert(turn_index);
}
}
// All rings having turns are in turns/ring map. Process them.
{
signed_size_type new_region_id = 1;
for (auto& key_val : m_turns_per_ring)
{
create_region(new_region_id, key_val.first, key_val.second);
}
assign_region_ids_to_enriched();
assign_connected_regions();
get_isolated_regions();
assign_isolation_to_enriched();
}
#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
std::cout << "END SWITCH DETECTOR" << std::endl;
debug_show_results();
#endif
}
private:
Geometry1 const& m_geometry1;
Geometry2 const& m_geometry2;
Turns& m_turns;
Clusters const& m_clusters;
merge_map m_turns_per_ring;
region_connection_map m_connected_regions;
Visitor& m_visitor;
};
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_SWITCH_DETECTOR_HPP

57
include/boost/geometry/algorithms/detail/overlay/traverse.hpp
View File

@ -17,9 +17,10 @@
#include <boost/range/size.hpp>
#include <boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp>
#include <boost/geometry/algorithms/detail/overlay/traversal_ring_creator.hpp>
#include <boost/geometry/algorithms/detail/overlay/traversal_switch_detector.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/detect_biconnected_components.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/fill_ring_turn_info_map.hpp>
#include <boost/geometry/algorithms/detail/overlay/graph/traverse_graph.hpp>
#include <boost/geometry/util/constexpr.hpp>
namespace boost { namespace geometry
@ -39,25 +40,10 @@ template
bool Reverse1, bool Reverse2,
typename Geometry1,
typename Geometry2,
overlay_type OverlayType,
typename Backtrack = backtrack_check_self_intersections<Geometry1, Geometry2>
overlay_type OverlayType
>
class traverse
{
template <typename Turns>
static void reset_visits(Turns& turns)
{
for (auto& turn : turns)
{
for (auto& op : turn.operations)
{
op.visited.reset();
}
}
}
public :
template
<
@ -76,34 +62,22 @@ public :
Clusters& clusters,
Visitor& visitor)
{
traversal_switch_detector
constexpr operation_type target_operation = operation_from_overlay<OverlayType>::value;
detect_biconnected_components<target_operation>(turns, clusters);
traverse_graph
<
Reverse1, Reverse2, OverlayType,
Geometry1, Geometry2,
Turns, Clusters,
Visitor
> switch_detector(geometry1, geometry2, turns, clusters,
visitor);
IntersectionStrategy
> traverser(geometry1, geometry2, turns, clusters,
intersection_strategy);
switch_detector.iterate();
reset_visits(turns);
traverser.iterate(rings);
traversal_ring_creator
<
Reverse1, Reverse2, OverlayType,
Geometry1, Geometry2,
Turns, TurnInfoMap, Clusters,
IntersectionStrategy,
Visitor,
Backtrack
> trav(geometry1, geometry2, turns, turn_info_map, clusters,
intersection_strategy, visitor);
std::size_t finalized_ring_size = boost::size(rings);
typename Backtrack::state_type state;
trav.iterate(rings, finalized_ring_size, state);
update_ring_turn_info_map(turn_info_map, turns);
}
};
@ -113,3 +87,4 @@ public :
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSE_HPP
// remove

14
include/boost/geometry/algorithms/detail/overlay/turn_info.hpp
View File

@ -53,17 +53,9 @@ struct turn_operation
{
using segment_ratio_type = SegmentRatio;
operation_type operation;
operation_type operation{operation_none};
segment_identifier seg_id;
segment_ratio_type fraction;
using comparable_distance_type = coordinate_type_t<Point>;
comparable_distance_type remaining_distance;
inline turn_operation()
: operation(operation_none)
, remaining_distance(0)
{}
};
@ -95,7 +87,8 @@ struct turn_info
bool touch_only; // True in case of method touch(interior) and lines do not cross
signed_size_type cluster_id; // For multiple turns on same location, > 0. Else -1. 0 is unused.
bool discarded;
bool has_colocated_both; // Colocated with a uu turn (for union) or ii (other)
bool is_traversable{true};
Container operations;
@ -104,7 +97,6 @@ struct turn_info
, touch_only(false)
, cluster_id(-1)
, discarded(false)
, has_colocated_both(false)
{}
inline bool both(operation_type type) const

55
include/boost/geometry/algorithms/detail/overlay/turn_operation_id.hpp Normal file
View File

@ -0,0 +1,55 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TURN_OPERATION_ID_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TURN_OPERATION_ID_HPP
#include <cstddef>
#include <ostream>
#include <tuple>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
struct turn_operation_id
{
std::size_t turn_index{0};
int operation_index{0};
bool operator<(turn_operation_id const& other) const
{
return std::tie(turn_index, operation_index) < std::tie(other.turn_index, other.operation_index);
}
bool operator==(turn_operation_id const& other) const
{
return std::tie(turn_index, operation_index) == std::tie(other.turn_index, other.operation_index);
}
bool operator!=(turn_operation_id const& other) const
{
return ! operator==(other);
}
friend std::ostream& operator<<(std::ostream& os, turn_operation_id const& toi)
{
os << toi.turn_index << "[" << toi.operation_index << "]";
return os;
}
};
}} // namespace detail::overlay
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TURN_OPERATION_ID_HPP

98
include/boost/geometry/algorithms/detail/overlay/visit_info.hpp
View File

@ -1,98 +0,0 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_VISIT_INFO_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_VISIT_INFO_HPP
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{
class visit_info
{
private :
static const int NONE = 0;
static const int STARTED = 1;
static const int VISITED = 2;
static const int FINISHED = 3;
static const int REJECTED = 4;
int m_visit_code;
bool m_rejected;
bool m_final;
public:
inline visit_info()
: m_visit_code(0)
, m_rejected(false)
, m_final(false)
{}
inline void set_visited() { m_visit_code = VISITED; }
inline void set_started() { m_visit_code = STARTED; }
inline void set_finished() { m_visit_code = FINISHED; }
inline void set_rejected()
{
m_visit_code = REJECTED;
m_rejected = true;
}
inline bool none() const { return m_visit_code == NONE; }
inline bool visited() const { return m_visit_code == VISITED; }
inline bool started() const { return m_visit_code == STARTED; }
inline bool finished() const { return m_visit_code == FINISHED; }
inline bool rejected() const { return m_rejected; }
inline bool finalized() const { return m_final; }
inline void clear()
{
if (! m_rejected && ! m_final)
{
m_visit_code = NONE;
}
}
inline void reset()
{
*this = visit_info();
}
inline void finalize()
{
if (visited() || started() || finished() )
{
m_final = true;
}
}
#ifdef BOOST_GEOMETRY_DEBUG_INTERSECTION
friend std::ostream& operator<<(std::ostream &os, visit_info const& v)
{
if (v.m_visit_code != 0)
{
os << " VIS: " << int(v.m_visit_code);
}
return os;
}
#endif
};
}} // namespace detail::overlay
#endif //DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_VISIT_INFO_HPP

71
include/boost/geometry/algorithms/detail/position_code.hpp Normal file
View File

@ -0,0 +1,71 @@
// Boost.Geometry
// Copyright (c) 2025 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_POSITION_CODE_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_POSITION_CODE_HPP
#include <boost/geometry/algorithms/detail/direction_code.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail
{
// Position coding of the point with respect to a segment.
// This is a combination of side and direction_code.
// It is counter clockwise from the segment.
// (because polygons are on the right side of a segment, and this way
// we can walk through the ranks ascending.
//
// 3
// |
// 4 * 2 *: p2
// |
// 1
// ^ ^: p1
template <typename Point, typename SideStrategy>
int get_position_code(Point const& p1, Point const& p2, Point const& point, SideStrategy const& side_strategy)
{
using cs_tag = typename SideStrategy::cs_tag;
auto const side = side_strategy.apply(p1, p2, point);
if (side == 1)
{
// left of [p1..p2]
return 4;
}
else if (side == -1)
{
// right of [p1..p2]
return 2;
}
// collinear with [p1..p2]
auto const dir_code = direction_code<cs_tag>(p1, p2, point);
if (dir_code == -1)
{
// collinear, on [p1..p2] or before p1
return 1;
}
else if (dir_code == 1)
{
// collinear with [p1..p2], but farther than p2
return 3;
}
// The segment is degenerate
return 0;
}
} // namespace detail
#endif //DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_POSITION_CODE_HPP

25
include/boost/geometry/core/exception.hpp
View File

@ -1,6 +1,6 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2007-2025 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
@ -20,6 +20,7 @@
#define BOOST_GEOMETRY_CORE_EXCEPTION_HPP
#include <exception>
#include <string>
namespace boost { namespace geometry
{
@ -102,6 +103,28 @@ public:
}
};
/*!
\brief Logic Exception
\ingroup core
\details Defines a type of object to be thrown as exception.
It reports errors that are a consequence of faulty logic within the program
such as violating logical preconditions or class invariants and may be preventable.
*/
class logic_exception : public geometry::exception
{
public:
inline logic_exception(char const* description)
: m_description(description) {}
char const* what() const noexcept override
{
return m_description.c_str();
}
private:
std::string m_description;
};
}} // namespace boost::geometry

3
include/boost/geometry/strategies/relate/cartesian.hpp
View File

@ -33,6 +33,9 @@
#include <boost/geometry/strategy/cartesian/side_by_triangle.hpp>
#include <boost/geometry/strategy/cartesian/area_box.hpp>
#include <boost/geometry/strategies/distance/detail.hpp>
#include <boost/geometry/strategies/distance/services.hpp>
#include <boost/geometry/util/type_traits.hpp>

24
test/algorithms/buffer/buffer_cases.hpp
View File

@ -22,7 +22,7 @@ static std::string const rt_w1
static std::string const rt_w2
= "MULTIPOLYGON(((6 3,6 4,7 4,6 3)),((6 3,5 2,5 3,6 3)))";
// Goes wrong either way
// Needs using collinear ahead properties for two u operations in a cluster, having the same target.
static std::string const rt_w3
= "MULTIPOLYGON(((8 3,8 4,9 4,9 3,8 3)),((7 5,7 6,8 6,7 5)),((5 5,4 4,4 5,5 5)),((5 5,6 5,5 4,5 5)),((0 7,0 8,1 8,0 7)),((2 2,2 3,3 3,2 2)),((2 8,3 8,3 7,3 6,2 6,2 8)))";
@ -38,11 +38,11 @@ static std::string const rt_w5
static std::string const rt_w6
= "MULTIPOLYGON(((7 0,7 1,8 0,7 0)),((8 6,8 7,9 7,9 6,8 6)),((2 8,3 9,3 8,2 8)),((4 3,4 4,5 4,4 3)),((6 5,6 6,7 6,6 5)),((1 7,2 7,1 6,0 6,1 7)),((1 5,0 4,0 5,1 5)),((1 5,2 6,2 5,1 5)),((0 4,1 4,0 3,0 4)),((2 1,1 0,0 0,0 1,2 1)),((7 4,6 3,6 4,7 4)),((7 4,7 5,8 5,7 4)),((6 3,7 3,6 2,6 3)))";
// Fixed by first handling non-clustered turns
// Originally fixed by first handling non-clustered turns. Now always fine.
static std::string const rt_w7
= "MULTIPOLYGON(((6 0,6 1,7 1,6 0)),((6 6,7 7,7 6,6 6)),((8 0,8 1,9 1,8 0)),((2 7,2 8,3 7,2 7)),((1 2,1 3,2 3,1 2)),((8 2,8 3,9 2,8 2)),((4 5,4 4,3 4,4 5)),((4 5,5 6,5 5,4 5)))";
// Fixed select_collinear_target_edge
// Fixed by select_collinear_target_edge
static std::string const rt_w8
= "MULTIPOLYGON(((0 4,0 5,1 5,0 4)),((1 3,1 4,2 4,1 3)),((2 8,2 9,3 8,2 8)),((6 3,6 4,7 3,6 3)),((7 1,7 2,8 2,8 1,7 1)),((0 2,0 3,1 2,0 2)),((0 2,1 1,0 1,0 2)),((3 2,3 1,2 1,3 2)),((3 2,2 2,3 3,3 2)),((9 6,9 5,8 5,9 6)),((9 6,8 6,8 7,9 7,9 6)),((5 2,5 1,4 1,4 2,5 2)),((5 2,5 3,6 2,5 2)),((5 6,4 6,4 7,5 6)),((5 6,6 5,5 5,5 6)),((5 6,6 7,6 6,5 6)))";
@ -82,6 +82,7 @@ static std::string const rt_w16
static std::string const rt_w17
= "MULTIPOLYGON(((3 1,4 2,4 1,3 1)),((5 3,6 4,6 3,5 3)),((5 0,5 1,6 1,6 0,5 0)),((8 5,9 6,9 5,8 5)),((8 5,7 4,7 5,8 5)))";
// Error in turn_in_piece, see readme
static std::string const rt_w18
= "MULTIPOLYGON(((4 4,4 5,5 4,4 4)),((5 6,6 7,6 6,5 6)),((5 1,4 1,4 2,5 3,5 1)),((7 6,7 7,8 7,7 6)),((0 6,1 6,1 5,1 4,0 4,0 6)),((1 8,2 7,1 7,1 8)),((1 8,2 9,2 8,1 8)),((1 6,1 7,2 6,1 6)),((7 3,7 2,6 2,7 3)),((7 3,7 4,8 4,8 3,7 3)),((3 2,3 1,2 1,3 2)),((3 2,2 2,2 3,3 3,3 2)),((5 8,5 7,4 7,4 8,5 8)),((5 8,6 9,6 8,5 8)))";
@ -121,7 +122,7 @@ static std::string const rt_w25
static std::string const rt_w26
= "MULTIPOLYGON(((6 6,6 7,7 6,6 6)),((0 0,0 1,1 1,1 0,0 0)),((3 6,2 5,2 7,2.5 6.5,3 7,4 6,5 5,3 5,3 6)),((3 2,2 2,2 3,1 3,3 5,3 2)),((3 1,4 0,3 0,3 1)),((3 1,2 0,2 1,3 1)),((3 7,2 7,2 8,3 7)),((1 8,0 8,0 9,1 9,1 8)),((1 8,2 7,1 7,1 8)),((2 5,1 5,1 6,2 6,1.5 5.5,2 5)),((5 0,5 1,6 1,6 0,5 0)),((1 3,1 2,0 2,1 3)),((4 6,4 7,5 7,5 6,4 6)),((1 6,0 6,0 7,1 6)),((1 5,1 4,0 4,0 5,1 5)),((6 1,6 2,7 2,7 1,6 1)),((6 2,6 3,7 3,6 2)),((7 1,8 1,8 0,7 0,7 1)))";
// Fixed by fixing by suspicious UX turn.
// Needs original arrival behaviour
static std::string const rt_w27
= "MULTIPOLYGON(((3 6,4 7,4 6,3 6)),((4 3,4 4,5 4,5 3,4 3)),((5 8,6 9,6 8,5 8)),((2 7,2 8,3 8,3 7,2 7)))";
@ -141,4 +142,19 @@ static std::string const rt_w30
static std::string const rt_w31
= "MULTIPOLYGON(((0 1,0 2,1 2,1 1,0 1)),((0 4,0 5,1 5,0 4)),((3 8,4 8,3 7,2 7,3 8)),((3 2,3 3,4 3,3 2)),((0 6,0 7,1 6,0 6)),((0 8,0 9,1 8,0 8)),((4 5,4 4,3 4,3 5,4 5)),((4 5,4 6,5 6,4 5)),((9 3,9 2,8 2,8 3,9 3)),((7 4,7 5,8 5,7 4)),((7 4,6 3,6 4,7 4)),((6 8,7 8,6.5 7.5,7 7,6 7,6 8)),((5 6,5 7,6 6,5 6)))";
static std::string const rt_w32
= "MULTIPOLYGON(((2 8,3 9,3 8,2 8)),((2 8,1 8,1 9,2 8)),((3 6,4 5,3 5,3 6)),((3 6,2 6,2 7,3 6)),((3 8,4 8,4 7,3 7,3 8)),((1 2,0 2,0 3,1 3,1 2)),((1 2,1 1,0 1,1 2)))";
// Reports invalid output for join round - but it is a false negative, because the output is valid.
static std::string const rt_w33
= "MULTIPOLYGON(((4 2,5 3,5 2,4 2)),((2 1,1 1,1 2,2 2,2 1)),((2 1,3 0,2 0,2 1)),((1 2,0 2,0 3,1 3,1 2)))";
// Reports invalid output for join round - but it is a false negative, because the output is valid.
static std::string const rt_w34
= "MULTIPOLYGON(((8 6,8 7,9 6,8 6)),((1 1,1 2,2 2,1 1)),((0 3,1 4,1 3,0 3)),((4 2,5 3,5 2,4 2)))";
// Same as for rt_w33 and rt_w34. The miter variant has a small interior and an inside point which is on the border of many offset rings.
static std::string const rt_w35
= "MULTIPOLYGON(((6 6,6 7,7 7,7 6,6 6)),((5 4,5 5,6 5,6 4,5 4)),((4 0,4 1,5 0,4 0)),((0 0,1 1,1 0,0 0)),((7 0,7 1,8 1,8 0,7 0)),((0 2,0 3,1 3,1 2,0 2)),((3 3,4 2,3 2,3 3)),((3 3,3 4,4 4,4 3,3 3)))";
#endif

2
test/algorithms/buffer/buffer_countries.cpp
View File

@ -175,7 +175,7 @@ void test_all()
test_one<mpt, pt>("nl100", nl, 0, -100);
test_one<mpt, pt>("no1", no, 1819566570720, 1);
test_one<mpt, pt>("no2", no, 1865041238129, 2, ut_settings::ignore_validity());
test_one<mpt, pt>("no2", no, 1865041238129, 2);
test_one<mpt, pt>("no5", no, 1973615533600, 5);
test_one<mpt, pt>("no10", no, 2102034240506, 10);
test_one<mpt, pt>("no20", no, 2292171257647, 20);

27
test/algorithms/buffer/buffer_linestring_geo.cpp
View File

@ -57,11 +57,13 @@ void test_linestring()
test_one_geo<linestring, polygon>("sharp_5_miter", sharp, strategy, side, circle, join_miter, end_round, 3181.0, 5.0, settings);
test_one_geo<linestring, polygon>("sharp_5_miter25", sharp, strategy, side, circle, join_miter25, end_round, 3121.0, 5.0, settings);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
if (! BOOST_GEOMETRY_CONDITION(thomas_skip))
{
// Misses an intersection point when using thomas
test_one_geo<linestring, polygon>("opposite", opposite, strategy, side, circle, join_round, end_round, 1658.0, 5.0, settings);
}
#endif
{
auto specific = settings;
@ -82,11 +84,11 @@ void test_linestring()
// Cases which are curved such that the min area is smaller than expected.
std::set<int> const curved_cases_min_area{86, 181};
// Cases which are curved such that the max area is larger than expected.
std::set<int> const curved_cases_max_area{5, 95, 119, 142, 192};
std::set<int> const curved_cases_max_area{5, 95, 119, 142};
// Cases which are rounded such that it results in a large area
std::set<int> const round_cases_max_area{196};
std::set<int> const round_cases_max_area{};
// Cases which are not yet valid or false negatives
std::set<int> const round_cases_invalid{143};
std::set<int> const round_cases_invalid{};
for (auto i = 0; i < n; i++)
{
@ -116,12 +118,23 @@ void test_linestring()
settings_rr.set_test_validity(round_cases_invalid.count(i) == 0);
if (i != 181)
#if ! defined(BOOST_GEOMETRY_TEST_FAILURES)
if (i == 143 || i == 196)
{
// 181 fails, it should generate a hole, but instead that is the outer ring now.
test_one_geo<linestring, polygon>("aimes_" + std::to_string(i) + "_rr", testcases_aimes[i],
strategy, side, circle, join_round, end_round, -1, 25.0, settings_rr);
continue;
}
if (i == 75)
{
// One regression
continue;
}
// Old message:
// 181 fails, it should generate a hole, but instead that is the outer ring now.
#endif
test_one_geo<linestring, polygon>("aimes_" + std::to_string(i) + "_rr", testcases_aimes[i],
strategy, side, circle, join_round, end_round, -1, 25.0, settings_rr);
test_one_geo<linestring, polygon>("aimes_" + std::to_string(i) + "_rf", testcases_aimes[i],
strategy, side, circle, join_round, end_flat, -1, 25.0, settings);
test_one_geo<linestring, polygon>("aimes_" + std::to_string(i) + "_mf", testcases_aimes[i],

2
test/algorithms/buffer/buffer_multi_linestring.cpp
View File

@ -195,6 +195,8 @@ void test_all()
test_one<multi_linestring_type, polygon>("mysql_23023665_1_20",
mysql_23023665_1, join_round32, end_flat, 1, 1, 350.1135, 2.0);
// A heavy buffer operation, most lines start at the same point, causing clusters of up to 121 turns,
// having mainly the same segments.
test_one<multi_linestring_type, polygon>("ticket_13444_1",
ticket_13444, join_round32, end_round32, 3, 0, 11799.2681, 1.0);
test_one<multi_linestring_type, polygon>("ticket_13444_3",

59
test/algorithms/buffer/buffer_multi_polygon.cpp
View File

@ -415,6 +415,8 @@ static std::string const mysql_report_2015_07_05_2
#define TEST_BUFFER(caseid, join, end, area, distance) (test_one<multi_polygon_type, polygon_type>) \
( #caseid "_buf", caseid, join, end, area, distance)
#define TEST_BUFFER_VALIDITY_FALSE_NEGATIVE(caseid, join, end, area, distance) (test_one<multi_polygon_type, polygon_type>) \
( #caseid "_buf", caseid, join, end, area, distance, ut_settings::ignore_validity())
template <bool Clockwise, typename P>
void test_all()
@ -603,49 +605,74 @@ void test_all()
test_one<multi_polygon_type, polygon_type>("rt_v4", rt_v4, join_round32, end_flat, 23.4146, 1.0);
TEST_BUFFER(rt_w1, join_miter, end_flat, 30.3995, 1.0);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
TEST_BUFFER(rt_w2, join_miter, end_flat, 13.65685, 1.0);
TEST_BUFFER(rt_w3, join_miter, end_flat, 19.39949, 1.0);
#endif
TEST_BUFFER(rt_w3, join_miter, end_flat, 53.1421, 1.0);
#if defined(BOOST_GEOMETRY_TEST_FAILURES) || defined(BOOST_GEOMETRY_CONCEPT_FIX_BLOCK_Q)
TEST_BUFFER(rt_w4, join_miter, end_flat, 57.37, 1.0);
#endif
TEST_BUFFER(rt_w5, join_miter, end_flat, 106.7279, 1.0);
TEST_BUFFER(rt_w6, join_miter, end_flat, 79.799, 1.0);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
TEST_BUFFER(rt_w7, join_miter, end_flat, 58.8701, 1.0);
#endif
TEST_BUFFER(rt_w8, join_miter, end_flat, 83.4852, 1.0);
TEST_BUFFER(rt_w9, join_miter, end_flat, 68.9852, 1.0);
TEST_BUFFER(rt_w10, join_miter, end_flat, 88.1985, 1.0);
TEST_BUFFER(rt_w11, join_miter, end_flat, 53.4853, 1.0);
TEST_BUFFER(rt_w12, join_miter, end_flat, 28.7353, 1.0);
TEST_BUFFER(rt_w13, join_miter, end_flat, 25.5711, 1.0);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
TEST_BUFFER(rt_w14, join_miter, end_flat, 58.05634, 1.0);
#endif
TEST_BUFFER(rt_w15, join_miter, end_flat, 80.1348, 1.0);
TEST_BUFFER(rt_w16, join_miter, end_flat, 31.6495, 1.0);
TEST_BUFFER(rt_w17, join_miter, end_flat, 33.74264, 1.0);
TEST_BUFFER(rt_w18, join_miter, end_flat, 82.4779, 1.0);
TEST_BUFFER(rt_w19, join_miter, end_flat, 53.7132, 1.0);
TEST_BUFFER(rt_w20, join_miter, end_flat, 63.0269, 1.0);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
TEST_BUFFER(rt_w18, join_miter, end_flat, 82.4779, 1.0);
#endif
#if defined(BOOST_GEOMETRY_TEST_FAILURES) || defined(BOOST_GEOMETRY_CONCEPT_FIX_ARRIVAL)
// See comments at issue issue_1262
TEST_BUFFER(rt_w19, join_miter, end_flat, 53.7132, 1.0);
#endif
TEST_BUFFER(rt_w20, join_miter, end_flat, 63.0269, 1.0);
TEST_BUFFER(rt_w21, join_miter, end_flat, 26.3137, 1.0);
#endif
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
TEST_BUFFER(rt_w22, join_miter, end_flat, 86.0416, 1.0);
#endif
TEST_BUFFER(rt_w23, join_miter, end_flat, 59.5711, 1.0);
#if defined(BOOST_GEOMETRY_TEST_FAILURES) || defined(BOOST_GEOMETRY_CONCEPT_FIX_BLOCK_Q)
TEST_BUFFER(rt_w24, join_miter, end_flat, 64.1985, 1.0);
#endif
TEST_BUFFER(rt_w25, join_miter, end_flat, 84.3848, 1.0);
TEST_BUFFER(rt_w26, join_miter, end_flat, 91.6569, 1.0);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
#if ! defined(BOOST_GEOMETRY_CONCEPT_FIX_ARRIVAL)
// These two cases FAIL if the concept fix is applied.
// See also comments at issue issue_1262
TEST_BUFFER(rt_w27, join_miter, end_flat, 31.6569, 1.0);
#endif
TEST_BUFFER(rt_w28, join_miter, end_flat, 100.0710, 1.0);
TEST_BUFFER(rt_w29, join_miter, end_flat, 25.1421, 1.0);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
#endif
TEST_BUFFER(rt_w28, join_miter, end_flat, 100.0710, 1.0);
TEST_BUFFER(rt_w30, join_miter, end_flat, 59.4485, 1.0);
TEST_BUFFER(rt_w31, join_miter, end_flat, 85.7916, 1.0);
#if defined(BOOST_GEOMETRY_TEST_FAILURES) || defined(BOOST_GEOMETRY_CONCEPT_FIX_START_TURNS)
TEST_BUFFER(rt_w32, join_miter, end_flat, 40.6569, 1.0);
#endif
TEST_BUFFER_VALIDITY_FALSE_NEGATIVE(rt_w33, join_round32, end_flat, 23.3895, 1.0);
TEST_BUFFER_VALIDITY_FALSE_NEGATIVE(rt_w34, join_round32, end_flat, 26.5830, 1.0);
TEST_BUFFER_VALIDITY_FALSE_NEGATIVE(rt_w35, join_round32, end_flat, 51.63174, 1.0);
TEST_BUFFER(rt_w35, join_miter, end_flat, 57.6569, 1.0);
test_one<multi_polygon_type, polygon_type>("nores_mt_1", nores_mt_1, join_round32, end_flat, 13.4113, 1.0);
test_one<multi_polygon_type, polygon_type>("nores_mt_2", nores_mt_2, join_round32, end_flat, 17.5265, 1.0);
test_one<multi_polygon_type, polygon_type>("nores_mt_3", nores_mt_3, join_round32, end_flat, 25.6091, 1.0);
@ -666,6 +693,8 @@ void test_all()
test_one<multi_polygon_type, polygon_type>("nores_wt_1", nores_wt_1, join_round32, end_flat, 80.1609, 1.0);
test_one<multi_polygon_type, polygon_type>("nores_wt_2", nores_wt_2, join_round32, end_flat, 22.1102, 1.0);
// Fails if BOOST_GEOMETRY_CONCEPT_FIX_BLOCK_Q_1 is set
test_one<multi_polygon_type, polygon_type>("nores_b8e6", nores_b8e6, join_round32, end_flat, 19.8528, 1.0);
test_one<multi_polygon_type, polygon_type>("nores_2881", nores_2881, join_round32, end_flat, 16.5510, 1.0);

12
test/algorithms/buffer/buffer_polygon.cpp
View File

@ -577,7 +577,7 @@ void test_all()
test_one<polygon_type, polygon_type>("ticket_10412", ticket_10412, join_miter, end_flat, 3109.6616, 1.5, settings);
test_one<polygon_type, polygon_type>("ticket_11580_100", ticket_11580, join_miter, end_flat, 52.0221000, 1.00, settings);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
// Larger distance, resulting in only one circle. Not solved yet in non-rescaled mode.
// Larger distance, resulting in only one circle. Not solved yet.
test_one<polygon_type, polygon_type>("ticket_11580_237", ticket_11580, join_miter, end_flat, 999.999, 2.37, settings);
#endif
@ -624,7 +624,17 @@ void test_all()
bg::strategy::buffer::join_round join_round4(4);
bg::strategy::buffer::end_round end_round4(4);
test_one<polygon_type, polygon_type>("issue_1262", issue_1262, join_round4, end_round4, 0.0, -1.8);
#if defined(BOOST_GEOMETRY_TEST_FAILURES) || defined(BOOST_GEOMETRY_CONCEPT_FIX_ARRIVAL)
// TRAVERSE_GRAPH New failure:
// It has a wrong segment id. That causes wrong ordering.
// This is caused by a wrong arrival, or a wrong fraction assigned
// due to arrival==1
// It cannot be fixed by the new graph traversal, because the input order is wrong.
// The old algorithm could somehow cope with it.
// It can be fixed by defining BOOST_GEOMETRY_CONCEPT_FIX_ARRIVAL
// (but that causes some other regressions: rt_w27, rt_w29)
test_one<polygon_type, polygon_type>("issue_1262_1", issue_1262, join_round4, end_round4, 8.9161, -1.0);
#endif
test_one<polygon_type, polygon_type>("issue_1262_2", issue_1262, join_round4, end_round4, 62.5276, -0.8);
test_one<polygon_type, polygon_type>("issue_1262_3", issue_1262, join_round4, end_round4, 193.47288, -0.4);
}

36
test/algorithms/buffer/buffer_variable_width.cpp
View File

@ -19,9 +19,6 @@
namespace bg = boost::geometry;
#if defined(TEST_WITH_SVG)
#include "test_buffer_svg.hpp"
#endif
// A point with extra info, such that
// - it can influence the buffer with dynamically (input)
@ -113,32 +110,13 @@ void test_buffer(std::string const& caseid, std::string const& wkt, std::vector<
throw std::runtime_error("There should be correct widths");
}
using point_type = specific_point;
using strategy_t = bg::strategies::buffer::services::default_strategy<
mls_t>::type;
strategy_t strategy;
#if defined(TEST_WITH_SVG)
bg::model::box<point_type> envelope;
bg::envelope(mls, envelope, strategy);
buffer_svg_mapper<point_type> buffer_mapper(caseid);
std::ostringstream filename;
filename << "/tmp/buffer_variable_width_" << caseid << ".svg";
std::ofstream svg(filename.str().c_str());
typedef bg::svg_mapper<point_type> mapper_type;
mapper_type mapper(svg, 1000, 800);
svg_visitor<mapper_type, bg::model::box<point_type>> visitor(mapper);
// Set the SVG boundingbox, with a margin. The margin is necessary because
// drawing is already started before the buffer is finished. It is not
// possible to "add" the buffer (unless we buffer twice).
buffer_mapper.prepare(mapper, visitor, envelope, 2.0);
#else
bg::detail::buffer::visit_pieces_default_policy visitor;
#endif
using point_type = specific_point;
using strategy_t = bg::strategies::buffer::services::default_strategy<mls_t>::type;
strategy_t strategy;
for (std::size_t i = 0; i < mls.size(); i++)
{
@ -165,10 +143,6 @@ void test_buffer(std::string const& caseid, std::string const& wkt, std::vector<
strategy,
visitor);
#if defined(TEST_WITH_SVG)
buffer_mapper.map_input_output(mapper, mls, result, false);
#endif
std::cout << caseid << " : " << boost::geometry::area(result) << std::endl;
BOOST_CHECK_CLOSE_FRACTION(boost::geometry::area(result), expected_area, 0.001);
}

BIN
test/algorithms/buffer/images/rt_w15.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 378 KiB

BIN
test/algorithms/buffer/images/rt_w18.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 197 KiB

BIN
test/algorithms/buffer/images/rt_w2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 88 KiB

BIN
test/algorithms/buffer/images/rt_w22.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 103 KiB

BIN
test/algorithms/buffer/images/rt_w24.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 297 KiB

BIN
test/algorithms/buffer/images/rt_w24_graph_right.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 172 KiB

BIN
test/algorithms/buffer/images/rt_w24_graph_wrong.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 189 KiB

BIN
test/algorithms/buffer/images/rt_w3.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 174 KiB

BIN
test/algorithms/buffer/images/rt_w7.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 98 KiB

69
test/algorithms/buffer/readme.md Normal file
View File

@ -0,0 +1,69 @@
# Buffer cases
## Recursive Polygons Buffer
### rt_w series
#### rt_w1
#### rt_w2
This case failed because of a generated `x` (block) in `get_turn_info.hpp`
It is fixed by removing them `ix` etc.
<img src="images/rt_w2.png" width="400"/>
#### rt_w3
This case failed because it selected the wrong `u` turn from a cluster (at turn `2` in the picture below, before the fix), having the same target (`8`).
It is fixed by calculating properties ahead also for these cases, with the same rank.
Therefore it was necessary to add the rank to enrichment_info.
<img src="images/rt_w3.png" width="400"/>
#### rt_w7
Suffered from a wrong block (at 12). Fixed by removing ix turns in buffer.
<img src="images/rt_w7.png" width="400"/>
#### rt_w15
Failed until late phase. Actual reason of fix unknown.
<img src="images/rt_w15.png" width="400"/>
#### rt_w18
This case fails because two colocated turns (87/91) on the border are considered as "within each other".
This should be detectable and filtered out (make them both on the border).
<img src="images/rt_w18.png" width="400"/>
#### rt_w22
Fails because two colocated turns (12/13) on the border are considered as "within each other".
<img src="images/rt_w22.png" width="400"/>
#### rt_w24
Failed because of a wrong block in `get_turn_info`. This time it does not make the turn `ix`,
but `ux` (instead of `uu` or `cc`).
Using the collinear properties ahead functionality fixes this case.
<img src="images/rt_w24.png" width="400"/>
Graph with a "concept fix"
<img src="images/rt_w24_graph_right.png" width="400"/>
Graph without the fix, and there is a line from `5` to the isolated area,
causing an invalid output.
<img src="images/rt_w24_graph_wrong.png" width="400"/>

2
test/algorithms/buffer/test_buffer_csv.hpp
View File

@ -77,7 +77,7 @@ private:
<< bg::method_char(turn.method) << ";"
<< bg::operation_char(turn.operations[0].operation) << "/" << bg::operation_char(turn.operations[1].operation) << ";"
<< turn.cluster_id << ";"
<< turn.is_turn_traversable << ";"
<< turn.is_traversable << ";"
<< turn.blocked() << ";"
<< std::endl;
}

4
test/algorithms/buffer/test_buffer_svg.hpp
View File

@ -164,7 +164,7 @@ private :
bool is_good = true;
std::string fill = "fill:rgb(0,255,0);";
if (! it->is_turn_traversable)
if (! it->is_traversable)
{
fill = "fill:rgb(255,0,0);";
is_good = false;
@ -205,7 +205,7 @@ private :
<< ":" << bg::operation_char(it->operations[0].operation)
<< "/" << bg::operation_char(it->operations[1].operation);
out << " "
<< (it->is_turn_traversable ? "" : "w")
<< (it->is_traversable ? "" : "w")
;
offsets[it->point] += 10;

2
test/algorithms/overlay/CMakeLists.txt
View File

@ -18,8 +18,6 @@ foreach(item IN ITEMS
get_turns_linear_areal
get_turns_linear_linear
overlay
sort_by_side_basic
sort_by_side
relative_order
select_rings
self_intersection_points

2
test/algorithms/overlay/Jamfile
View File

@ -31,8 +31,6 @@ test-suite boost-geometry-algorithms-overlay
[ run get_turns_linear_linear_geo.cpp : : : : algorithms_get_turns_linear_linear_geo ]
[ run get_turns_linear_linear_sph.cpp : : : : algorithms_get_turns_linear_linear_sph ]
[ run overlay.cpp : : : : algorithms_overlay ]
[ run sort_by_side_basic.cpp : : : : algorithms_sort_by_side_basic ]
[ run sort_by_side.cpp : : : : algorithms_sort_by_side ]
#[ run handle_touch.cpp : : : : algorithms_handle_touch ]
[ run relative_order.cpp : : : : algorithms_relative_order ]
[ run select_rings.cpp : : : : algorithms_select_rings ]

123
test/algorithms/overlay/debug_sort_by_side_svg.hpp
View File

@ -1,123 +0,0 @@
// Boost.Geometry
// Copyright (c) 2017 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_TEST_DEBUG_SORT_BY_SIDE_SVG_HPP
#define BOOST_GEOMETRY_TEST_DEBUG_SORT_BY_SIDE_SVG_HPP
#include <fstream>
#include <sstream>
#include <set>
#include <boost/geometry/io/svg/svg_mapper.hpp>
#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/sort_by_side.hpp>
namespace boost { namespace geometry { namespace debug
{
template <typename Sbs, typename Point, typename Geometry1, typename Geometry2>
inline void sorted_side_map(std::string const& case_id,
Sbs const& sbs, Point const& point,
Geometry1 const& geometry1,
Geometry2 const& geometry2,
int take_turn_index = -1, int take_operation_index = -1)
{
// Check number of sources (buffer has only one source)
std::set<signed_size_type> sources;
for (std::size_t i = 0; i < sbs.m_ranked_points.size(); i++)
{
const typename Sbs::rp& er = sbs.m_ranked_points[i];
sources.insert(er.seg_id.source_index);
}
std::size_t const source_count = sources.size();
std::ostringstream filename;
filename << "sort_by_side_" << case_id << ".svg";
std::ofstream svg(filename.str().c_str());
typedef geometry::svg_mapper<Point> mapper_type;
typedef geometry::model::referring_segment<Point const> seg;
mapper_type mapper(svg, 500, 500);
for (std::size_t i = 0; i < sbs.m_ranked_points.size(); i++)
{
const typename Sbs::rp& er = sbs.m_ranked_points[i];
mapper.add(er.point);
}
if (sources.count(0) > 0)
{
mapper.map(geometry1, "fill-opacity:0.5;fill:rgb(153,204,0);stroke:rgb(153,204,0);stroke-width:0");
}
if (sources.count(1) > 0)
{
mapper.map(geometry2, "fill-opacity:0.3;fill:rgb(51,51,153);stroke:rgb(51,51,153);stroke-width:0");
}
const std::string style = "fill:rgb(0,0,0);font-family:Arial;font-size:10px;";
for (std::size_t i = 0; i < sbs.m_ranked_points.size(); i++)
{
const typename Sbs::rp& er = sbs.m_ranked_points[i];
std::ostringstream out;
out << er.rank
<< " (" << i << ")"
<< " z=" << er.zone
<< " " << (er.direction == detail::overlay::sort_by_side::dir_to ? "t" : "f")
<< " " << er.turn_index
<< "[" << er.operation_index << "]";
if (er.direction == detail::overlay::sort_by_side::dir_to)
{
out << " L=" << er.count_left << " R=" << er.count_right;
}
else
{
out << " l=" << er.count_left << " r=" << er.count_right;
}
out << " " << operation_char(er.operation);
if (source_count > 1)
{
out << " s=" << er.seg_id.source_index;
}
bool left = (i / 2) % 2 == 1;
int x_offset = left ? -6 : 6;
int y_offset = i % 2 == 0 ? 0 : 10;
const std::string align = left ? "text-anchor:end;" : "";
std::string const source_style
= er.seg_id.source_index == 0
? "opacity:0.7;stroke:rgb(0,255,0);stroke-width:4;"
: "opacity:0.7;stroke:rgb(0,0,255);stroke-width:4;";
mapper.map(seg(point, er.point), source_style);
if (er.direction == detail::overlay::sort_by_side::dir_to)
{
if (er.turn_index == take_turn_index
&& er.operation_index == take_operation_index)
{
mapper.map(er.point, "opacity:0.7;fill:rgb(255,0,255);", 3);
}
else
{
mapper.map(er.point, "opacity:0.7;fill:rgb(0,0,0);", 3);
}
}
mapper.text(er.point, out.str(), style + align, x_offset, y_offset);
}
mapper.map(sbs.m_origin, "opacity:0.9;fill:rgb(255,0,0);", 5);
}
}}} // namespace boost::geometry::debug
#endif // BOOST_GEOMETRY_TEST_DEBUG_SORT_BY_SIDE_SVG_HPP

3
test/algorithms/overlay/get_distance_measure.cpp
View File

@ -15,9 +15,6 @@
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry/io/wkt/wkt.hpp>
// #define BOOST_GEOMETRY_TEST_WITH_COUT
// #define BOOST_GEOMETRY_TEST_FAILURES
template <typename Point>
void do_test(std::string const& case_id,
Point const& s1,

33
test/algorithms/overlay/multi_overlay_cases.hpp
View File

@ -854,6 +854,39 @@ static std::string case_149_multi[2] =
)""""
};
static std::string case_150_multi[2] =
{
// For uu turns, unclustered, no self-intersections
R""""(
MULTIPOLYGON(
((2 2,2 5,5 5,5 2,2 2))
)
)"""",
R""""(
MULTIPOLYGON(
((5 5,5 8,8 8,8 5,5 5)),
((1 1,1 3,3 3,3 1,1 1))
)
)""""
};
static std::string case_151_multi[2] =
{
// For uu turns, 4 meet at the center point
R""""(
MULTIPOLYGON(
((1 2,5 5,2 1,1 2)),
((9 8,5 5,8 9,9 8))
)
)"""",
R""""(
MULTIPOLYGON(
((2 9,5 5,1 8,2 9)),
((8 1,5 5,9 2,8 1))
)
)""""
};
static std::string case_recursive_boxes_1[2] =
{

259
test/algorithms/overlay/overlay.cpp
View File

@ -47,6 +47,46 @@ struct geojson_visitor : public boost::geometry::detail::overlay::overlay_null_v
: m_writer(writer)
{}
template <typename Turns, typename Cluster, typename Connections>
inline void visit_cluster_connections(bg::signed_size_type cluster_id,
Turns const& turns, Cluster const& cluster, Connections const& connections)
{
using point_type = typename Turns::value_type::point_type;
using ls_type = bg::model::linestring<point_type>;
auto id_as_string = [](auto const& id)
{
std::stringstream out;
out << id;
return out.str();
};
if (cluster.turn_indices.empty())
{
return;
}
auto const& turn_point = turns[*cluster.turn_indices.begin()].point;
for (auto const& item : connections)
{
auto const& key = item.key;
auto const& connection = item.properties;
ls_type const ls{turn_point, connection.point};
m_writer.feature(ls);
m_writer.add_property("type", "cluster");
m_writer.add_property("cluster_id", cluster_id);
m_writer.add_property("direction", std::string(key.connection ==
bg::detail::overlay::connection_type::incoming ? "in" : "out"));
m_writer.add_property("position_code", connection.position_code);
m_writer.add_property("rank", connection.rank);
m_writer.add_property("count_left", connection.zone_count_left);
m_writer.add_property("count_right", connection.zone_count_right);
m_writer.add_property("seg_id", id_as_string(key.seg_id));
m_writer.add_property("ring_id", id_as_string(bg::detail::overlay::ring_id_by_seg_id(key.seg_id)));
}
}
template <typename Turns>
void visit_turns(int phase, Turns const& turns)
{
@ -59,15 +99,19 @@ struct geojson_visitor : public boost::geometry::detail::overlay::overlay_null_v
{
auto index = enumerated.index;
auto const& turn = enumerated.value;
auto label_enriched = [&turn](int i)
auto const& op0 = turn.operations[0];
auto const& op1 = turn.operations[1];
auto label_component = [&]()
{
auto const& op = turn.operations[i].enriched;
std::ostringstream out;
out //<< " l:" << op.count_left << " r:" << op.count_right
//<< " rank:" << op.rank
// << " z:" << op.zone
<< " region:" << op.region_id
<< (op.isolated ? " ISOLATED" : "");
auto const& c0 = op0.enriched.component_id;
auto const& c1 = op1.enriched.component_id;
if (c0 < 0 && c1 < 0) out << "-";
else if (c0 == c1) out << c0;
else if (c0 < 0) out << c1;
else if (c1 < 0) out << c0;
else out << c0 << " | " << c1;
return out.str();
};
auto label_operation_ids = [&turn](int op_index)
@ -75,38 +119,47 @@ struct geojson_visitor : public boost::geometry::detail::overlay::overlay_null_v
std::ostringstream out;
out << bg::operation_char(turn.operations[op_index].operation)
<< ": " << turn.operations[op_index].seg_id
<< " " << turn.operations[op_index].enriched.next_ip_index
<< "|" << turn.operations[op_index].enriched.travels_to_ip_index;
<< " v:" << turn.operations[op_index].enriched.travels_to_vertex_index
<< "|t:" << turn.operations[op_index].enriched.travels_to_ip_index;
return out.str();
};
auto label_operations = [&turn]()
auto label_operations = [&]()
{
std::ostringstream out;
out << bg::operation_char(turn.operations[0].operation)
<< bg::operation_char(turn.operations[1].operation);
out << bg::operation_char(op0.operation)
<< bg::operation_char(op1.operation);
return out.str();
};
auto label_travel = [&turn]()
auto label_travel = [&]()
{
std::ostringstream out;
out << turn.operations[0].enriched.travels_to_ip_index
<< "|" << turn.operations[1].enriched.travels_to_ip_index;
out << op0.enriched.travels_to_ip_index
<< "|" << op1.enriched.travels_to_ip_index;
return out.str();
};
m_writer.feature(turn.point);
m_writer.add_property("index", index);
m_writer.add_property("method", bg::method_char(turn.method));
m_writer.add_property("operations", label_operations());
m_writer.add_property("travels_to", label_travel());
m_writer.add_property("cluster_id", turn.cluster_id);
m_writer.add_property("discarded", turn.discarded);
m_writer.add_property("has_colocated_both", turn.has_colocated_both);
m_writer.add_property("self_turn", bg::detail::overlay::is_self_turn<bg::overlay_union>(turn));
m_writer.add_property("component", label_component());
m_writer.add_property("operations", label_operations());
m_writer.add_property("operation_0", label_operation_ids(0));
m_writer.add_property("count_left_0", op0.enriched.count_left);
m_writer.add_property("count_right_0", op0.enriched.count_right);
m_writer.add_property("ahead_distance_0", op0.enriched.ahead_distance_of_side_change);
m_writer.add_property("ahead_side_0", op0.enriched.ahead_side);
m_writer.add_property("operation_1", label_operation_ids(1));
m_writer.add_property("enriched_0", label_enriched(0));
m_writer.add_property("enriched_1", label_enriched(1));
m_writer.add_property("count_left_1", op1.enriched.count_left);
m_writer.add_property("count_right_1", op1.enriched.count_right);
m_writer.add_property("ahead_distance_1", op1.enriched.ahead_distance_of_side_change);
m_writer.add_property("ahead_side_1", op1.enriched.ahead_side);
}
}
@ -115,13 +168,14 @@ struct geojson_visitor : public boost::geometry::detail::overlay::overlay_null_v
};
#endif
template <typename Geometry, bg::overlay_type OverlayType>
template <typename Geometry, bg::overlay_type OverlayType, bool SymDiff = false>
void test_overlay(std::string const& caseid,
std::string const& wkt1, std::string const& wkt2,
double expected_area,
std::size_t expected_clip_count,
std::size_t expected_hole_count)
{
std::cout << caseid << std::endl;
Geometry g1;
bg::read_wkt(wkt1, g1);
@ -131,6 +185,15 @@ void test_overlay(std::string const& caseid,
bg::correct(g1);
bg::correct(g2);
if (! bg::is_valid(g1))
{
std::cerr << "WARNING: Invalid input 1: " << caseid << std::endl;
}
if (! bg::is_valid(g2))
{
std::cerr << "WARNING: Invalid input 2: " << caseid << std::endl;
}
#if defined(TEST_WITH_GEOJSON)
std::ostringstream filename;
// For QGis, it is usually convenient to always write to the same geojson file.
@ -174,7 +237,14 @@ void test_overlay(std::string const& caseid,
#endif
Geometry result;
overlay::apply(g1, g2, std::back_inserter(result), strategy, visitor);
if (SymDiff)
{
bg::sym_difference(g1, g2, result);
}
else
{
overlay::apply(g1, g2, std::back_inserter(result), strategy, visitor);
std::string message;
bool const valid = check_validity<Geometry>::apply(result, caseid, g1, g2, message);
@ -227,6 +297,54 @@ void test_overlay(std::string const& caseid,
#define TEST_UNION_WITH(caseid, index1, index2, area, clips, holes) (test_overlay<multi_polygon, bg::overlay_union>) \
( #caseid "_union" #index1 "_" #index2, caseid[index1], caseid[index2], area, clips, holes)
// TEMP
#define TEST_DIFFERENCE_S(caseid, area, clips, holes) (test_overlay<multi_polygon, bg::overlay_difference, true>) \
( #caseid "_diff_s", caseid[0], caseid[1], area, clips, holes)
static std::string issue_893_multi[2] =
{
"MULTIPOLYGON(((-9133.3885344331684 3976.3162451998137, -6748.2449169873034 -5735.0734557728138, 12359.886942916415 -1042.0645095456412, 5126.3084924076147 2226.9708710750697, -1604.5619839035633 573.85084904357439, -9133.3885344331684 3976.3162451998137)))",
"MULTIPOLYGON(((-3228.4265340177531 1307.7159344890201, -4500.2645033380131 1882.4913860267370, -4294.7752070657516 1045.8178117890784, -3228.4265340177531 1307.7159344890201)))"
};
static std::string issue_1100_multi[2] =
{
"MULTIPOLYGON(((1.5300545419548890819e-16 2101,1 2101,1 2100,1.1102230246251565404e-16 2100,1.5300545419548890819e-16 2101)))",
"MULTIPOLYGON(((-0.19761611601674899941 2101,0 2100.6135231738085167,0 2100,-0.5 2100,-0.5 2101,-0.19761611601674899941 2101)))"
};
static std::string issue_1363_multi[2] =
{
"MULTIPOLYGON(((2.0611606968426476882 0.61095000000000010409,2.046160696842648008 0.62595000000000000639,2.0311606968426478836 0.6409499999999999087,1.9486606968426476438 0.73094999999999987761,1.9261606968426476794 0.76094999999999990425,1.9336606968426472974 0.78344999999999986873,2.0161606968426477593 0.85844999999999993534,2.0236606968426480435 0.8584499999999997133,2.0461606968426475639 0.90344999999999986429,2.0911606968426479369 0.88844999999999973994,2.098660696842647333 0.8734499999999996156,2.1136606968426479014 0.86594999999999977547,2.1286606968426480258 0.85094999999999976215,2.1436606968426472619 0.83594999999999985985,2.143660696842647706 0.62594999999999989537,2.0836606968426476527 0.62594999999999989537,2.0611606968426476882 0.61095000000000010409)))",
"MULTIPOLYGON(((2.0461606968426484521 0.90344999999999986429,2.001160696842647635 0.91095000000000003748,1.8511606968426477238 0.91094999999999992646,1.813660696842647635 0.91844999999999998863,1.813660696842647635 0.9409499999999999531,1.8211606968426479192 1.1059499999999999886,1.8286606968426479813 1.263449999999999962,1.9636606968426479902 1.263449999999999962,2.0461606968426484521 1.2559499999999998998,2.0536606968426478481 1.2409499999999999975,2.1286606968426480258 1.2409499999999999975,2.1286606968426480258 1.1059499999999999886,2.1211606968426477415 0.92594999999999982876,2.1136606968426479014 0.89594999999999980211,2.091160696842648381 0.88844999999999996199,2.0461606968426484521 0.90344999999999986429)))"
};
static std::string buffer_rt_g_multi[2] =
{
"MULTIPOLYGON(((2.0 8.0,2.0 9.0,2.0 10.0,3.0 10.0,4.0 10.0,6.4142135623730958 10.0,4.7071067811865479 8.2928932188134521,3.7071067811865475 7.2928932188134521,2.0 5.5857864376269051,2.0 8.0)))",
"MULTIPOLYGON(((0.0 6.0,0.0 7.0,0.0 8.0,1.0 8.0,2.0 8.0,4.4142135623730958 8.0,2.7071067811865475 6.2928932188134521,1.7071067811865475 5.2928932188134521,-0.0 3.5857864376269042,0.0 6.0)))"
};
static std::string ggl_list_20190307_matthieu_1_multi[2] =
{
"MULTIPOLYGON(((-1.00000010731 -0.713619134602,-1.00000012822 -0.493922219801,-0.598172925227 0.100631982002,-1.00000012886 -0.0624283708015,-1.00000011994 0.0862738908136,-0.440262107798 0.31341400405,-0.360828341246 0.292948255722,-0.357275641893 0.210997365241,-0.970143533681 -0.695818118925,-1.00000010731 -0.713619134602)))",
"MULTIPOLYGON(((-0.999999965066 -0.493921978401,-0.909999987372 -0.360755621066,-0.909999996424 -0.91000000872,0.91000000872 -0.909999996424,0.909999996424 0.91000000872,-0.909999996424 0.91000000872,-0.909999911756 -0.0259065349961,-0.999999867625 -0.0624282647935,-1 1,1 1,1 -1,-1 -1,-0.999999965066 -0.493921978401)))"
};
static std::string buffer_rt_a_multi[2] =
{
"MULTIPOLYGON(((1 7,1 8,1.0012 8.04907,1.00482 8.09802,1.01082 8.14673,1.01921 8.19509,1.02997 8.24298,1.04306 8.29028,1.05846 8.33689,1.07612 8.38268,1.09601 8.42756,1.11808 8.4714,1.14227 8.5141,1.16853 8.55557,1.19679 8.5957,1.22699 8.63439,1.25905 8.67156,1.29289 8.70711,1.32844 8.74095,1.36561 8.77301,1.4043 8.80321,1.44443 8.83147,1.4859 8.85773,1.5286 8.88192,1.57244 8.90399,1.61732 8.92388,1.66311 8.94154,1.70972 8.95694,1.75702 8.97003,1.80491 8.98079,1.85327 8.98918,1.90198 8.99518,1.95093 8.9988,2 9,3 9,3.04907 8.9988,3.09802 8.99518,3.14673 8.98918,3.19509 8.98079,3.24298 8.97003,3.29028 8.95694,3.33689 8.94154,3.38268 8.92388,3.42756 8.90399,3.4714 8.88192,3.5141 8.85773,3.55557 8.83147,3.5957 8.80321,3.63439 8.77301,3.67156 8.74095,3.70711 8.70711,3.74095 8.67156,3.77301 8.63439,3.80321 8.5957,3.83147 8.55557,3.85773 8.5141,3.88192 8.4714,3.90399 8.42756,3.92388 8.38268,3.94154 8.33689,3.95694 8.29028,3.97003 8.24298,3.98079 8.19509,3.98918 8.14673,3.99518 8.09802,3.9988 8.04907,4 8,4 7,3.9988 6.95093,3.99518 6.90198,3.98918 6.85327,3.98079 6.80491,3.97003 6.75702,3.95694 6.70972,3.94154 6.66311,3.92388 6.61732,3.90399 6.57244,3.88192 6.5286,3.85773 6.4859,3.83147 6.44443,3.80321 6.4043,3.77301 6.36561,3.74095 6.32844,3.70711 6.29289,3.67156 6.25905,3.63439 6.22699,3.5957 6.19679,3.55557 6.16853,3.5141 6.14227,3.4714 6.11808,3.42756 6.09601,3.38268 6.07612,3.33689 6.05846,3.29028 6.04306,3.24298 6.02997,3.19509 6.01921,3.14673 6.01082,3.09802 6.00482,3.04907 6.0012,3 6,2 6,1.95093 6.0012,1.90198 6.00482,1.85327 6.01082,1.80491 6.01921,1.75702 6.02997,1.70972 6.04306,1.66311 6.05846,1.61732 6.07612,1.57244 6.09601,1.5286 6.11808,1.4859 6.14227,1.44443 6.16853,1.4043 6.19679,1.36561 6.22699,1.32844 6.25905,1.29289 6.29289,1.25905 6.32844,1.22699 6.36561,1.19679 6.4043,1.16853 6.44443,1.14227 6.4859,1.11808 6.5286,1.09601 6.57244,1.07612 6.61732,1.05846 6.66311,1.04306 6.70972,1.02997 6.75702,1.01921 6.80491,1.01082 6.85327,1.00482 6.90198,1.0012 6.95093,1 7)))",
"MULTIPOLYGON(((3 6,4 6,4.04907 5.9988,4.09802 5.99518,4.14673 5.98918,4.19509 5.98079,4.24298 5.97003,4.29028 5.95694,4.33689 5.94154,4.38268 5.92388,4.42756 5.90399,4.4714 5.88192,4.5141 5.85773,4.55557 5.83147,4.5957 5.80321,4.63439 5.77301,4.67156 5.74095,4.70711 5.70711,4.74095 5.67156,4.77301 5.63439,4.80321 5.5957,4.83147 5.55557,4.85773 5.5141,4.88192 5.4714,4.90399 5.42756,4.92388 5.38268,4.94154 5.33689,4.95694 5.29028,4.97003 5.24298,4.98079 5.19509,4.98918 5.14673,4.99518 5.09802,4.9988 5.04907,5 5,5 4,4.9988 3.95093,4.99518 3.90198,4.98918 3.85327,4.98079 3.80491,4.97003 3.75702,4.95694 3.70972,4.94154 3.66311,4.92388 3.61732,4.90399 3.57244,4.88192 3.5286,4.85773 3.4859,4.83147 3.44443,4.80321 3.4043,4.77301 3.36561,4.74095 3.32844,4.70711 3.29289,4.67156 3.25905,4.63439 3.22699,4.5957 3.19679,4.55557 3.16853,4.5141 3.14227,4.4714 3.11808,4.42756 3.09601,4.38268 3.07612,4.33689 3.05846,4.29028 3.04306,4.24298 3.02997,4.19509 3.01921,4.14673 3.01082,4.09802 3.00482,4.04907 3.0012,4 3,3 3,3 3,2 3,1.95093 3.0012,1.90198 3.00482,1.85327 3.01082,1.80491 3.01921,1.75702 3.02997,1.70972 3.04306,1.66311 3.05846,1.61732 3.07612,1.57244 3.09601,1.5286 3.11808,1.4859 3.14227,1.44443 3.16853,1.4043 3.19679,1.36561 3.22699,1.32844 3.25905,1.29289 3.29289,1.25905 3.32844,1.22699 3.36561,1.19679 3.4043,1.16853 3.44443,1.14227 3.4859,1.11808 3.5286,1.09601 3.57244,1.07612 3.61732,1.05846 3.66311,1.04306 3.70972,1.02997 3.75702,1.01921 3.80491,1.01082 3.85327,1.00482 3.90198,1.0012 3.95093,1 4,1 5,1.0012 5.04907,1.00482 5.09802,1.01082 5.14673,1.01921 5.19509,1.02997 5.24298,1.04306 5.29028,1.05846 5.33689,1.07612 5.38268,1.09601 5.42756,1.11808 5.4714,1.14227 5.5141,1.16853 5.55557,1.19679 5.5957,1.22699 5.63439,1.25905 5.67156,1.29289 5.70711,1.32844 5.74095,1.36561 5.77301,1.4043 5.80321,1.44443 5.83147,1.4859 5.85773,1.5286 5.88192,1.57244 5.90399,1.61732 5.92388,1.66311 5.94154,1.70972 5.95694,1.75702 5.97003,1.80491 5.98079,1.85327 5.98918,1.90198 5.99518,1.95093 5.9988,2 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6,3 6)))"
};
// Two colocations of interior/exterior ring
static std::string case_80s_multi[2] = {
"MULTIPOLYGON(((0 5,5 10,10 5,5 0,0 5),(10 5,4 6,5 4,10 5)))",
"MULTIPOLYGON(((10 0,10 10,20 10,20 0,10 0),(10 5,15 3,18 8,10 5)))"
};
template <typename T, bool Clockwise>
void test_all()
{
@ -234,8 +352,98 @@ void test_all()
using polygon = bg::model::polygon<point_type, Clockwise>;
using multi_polygon = bg::model::multi_polygon<polygon>;
// TEST_DIFFERENCE_A(ggl_list_20190307_matthieu_1_multi, 0.18461532, 2, 0);
// TEST_DIFFERENCE_B(ggl_list_20190307_matthieu_1_multi, 0.617978, 2, 0);
// TEST_DIFFERENCE_S(ggl_list_20190307_matthieu_1_multi, 0.18461532 + 0.617978, 4, 0);
// TEST_INTERSECTION(case_recursive_boxes_54, 10.0, 3, 1); // works (using select_edge)
// TEST_INTERSECTION(case_recursive_boxes_95, 36.25, 30, 0);
// TEST_INTERSECTION(case_recursive_boxes_99, 99, 7, 0);
// TEST_INTERSECTION(case_bitset_3, 16.0, 1, 0);
// TEST_INTERSECTION(case_149_multi, 48.0, 2, 2); // instruction
//
// TEST_DIFFERENCE_B(issue_893_multi, 97213916.0, 1, 1); // needs is_traverse
TEST_UNION(case_134_multi, 66.0, 1, 2);
return;
TEST_UNION(case_76_multi, 8.0, 5, 0);
TEST_UNION(case_150_multi, 21.0, 2, 0); // uu
TEST_UNION(case_151_multi, 14.0, 4, 0); // 2 uu
TEST_UNION_WITH(buffer_rt_a_multi, 1, 0, 19.2806668, 1, 0);
TEST_UNION(case_80s_multi, 129.0, 2, 2);
TEST_INTERSECTION(case_108_multi, 7.5, 7, 0);
TEST_UNION(case_recursive_boxes_12, 6.0, 6, 0);
TEST_UNION(case_149_multi, 115.0, 2, 0); // instruction
TEST_UNION(ggl_list_20140212_sybren, 0.002471626, 2, 0);
TEST_UNION_WITH(issue_1100_multi, 1, 0, 1.46181, 1, 0); // fixed by ux/uu blocking
TEST_UNION(issue_1363_multi, 99.99, 2, 0);
TEST_UNION(case_recursive_boxes_32, 5.75, 2, 0);
TEST_INTERSECTION(case_148_multi, 4.0, 4, 1);
TEST_INTERSECTION_WITH(case_recursive_boxes_99, 2, 3, 8.0, 5, 1);
TEST_INTERSECTION(case_recursive_boxes_79, 9.0, 5, 1); // fixed (fixing self-turns in clusters)
TEST_INTERSECTION(case_recursive_boxes_98, 4, 7, 0); // fixed by skip_count
TEST_INTERSECTION(case_recursive_boxes_96, 37.25, 34, 0); // fixed by handling of cc / via target
TEST_INTERSECTION_WITH(case_recursive_boxes_91, 0, 1, 27.5, 29, 0); // requires specific selection of operation_continue
TEST_INTERSECTION(case_recursive_boxes_92, 30.5, 32, 0);
TEST_INTERSECTION(case_recursive_boxes_66, 16.0, 4, 1);
TEST_INTERSECTION(case_recursive_boxes_97, 30.25, 25, 0); // fixed by handling of cc / via target
TEST_INTERSECTION_WITH(case_recursive_boxes_92, 1, 0, 30.5, 32, 0);
TEST_INTERSECTION(case_recursive_boxes_83, 10.25, 5, 0); // Fixed (using count_right)
TEST_UNION(case_recursive_boxes_56, 7.75, 5, 1);
TEST_DIFFERENCE_S(case_multi_simplex, 5.58 + 2.58, 5 + 4, 0);
TEST_UNION(case_101_multi, 22.25, 1, 3); // Convenient start case for union with holes
TEST_UNION(buffer_rt_g_multi, 16.571, 1, 0); // FIXED by remaining + union
TEST_UNION(issue_1100_multi, 1.46181, 1, 0);
TEST_INTERSECTION_WITH(case_recursive_boxes_91, 6, 7, 8.75, 10, 0); // requires specific selection of operation_continue
TEST_INTERSECTION_WITH(case_recursive_boxes_91, 2, 3, 27.5, 29, 0);
TEST_INTERSECTION_WITH(case_recursive_boxes_91, 4, 5, 4.0, 5, 0);
TEST_UNION(case_multi_simplex, 14.58, 1, 0);
TEST_UNION(case_recursive_boxes_3, 56.5, 17, 6); // still complex
TEST_UNION(case_recursive_boxes_4, 96.75, 1, 2);
// Contains 4 clusters, one of which having 4 turns
TEST_UNION(case_recursive_boxes_7, 7.0, 2, 0);
TEST_UNION(case_recursive_boxes_13, 10.25, 3, 0);
TEST_DIFFERENCE_S(case_multi_simplex, 5.58 + 2.58, 5 + 4, 0);
TEST_DIFFERENCE_A(case_recursive_boxes_18, 1.0, 2, 0);
TEST_DIFFERENCE_B(case_recursive_boxes_18, 1.5, 1, 0);
TEST_INTERSECTION(case_101_multi, 4.75, 4, 0);
TEST_INTERSECTION(case_125_multi, 2.1, 3, 1); // Fixed with correct visit info
TEST_INTERSECTION(case_124_multi, 2.0625, 2, 1);
TEST_INTERSECTION(case_recursive_boxes_4, 67.0, 13, 8);
TEST_INTERSECTION(case_128_multi, 75.5, 2, 3); // FIXED
TEST_INTERSECTION(case_recursive_boxes_79, 9.0, 5, 1); // fixed (fixing self-turns in clusters)
TEST_INTERSECTION(case_recursive_boxes_77, 3.5, 5, 0); // fixed (using count_right)
TEST_INTERSECTION(case_recursive_boxes_54, 10.0, 3, 1); // works (using select_edge)
TEST_INTERSECTION(case_recursive_boxes_1, 47.0, 10, 0); // works (allow on same segment)
TEST_INTERSECTION(case_recursive_boxes_89, 1.5, 2, 0);
TEST_INTERSECTION(case_recursive_boxes_90, 1.0, 2, 0);
TEST_INTERSECTION(case_recursive_boxes_35, 20.0, 2, 6);
TEST_INTERSECTION(case_recursive_boxes_42, 95.0, 1, 4);
TEST_INTERSECTION(case_recursive_boxes_48, 1.0, 1, 0);
TEST_INTERSECTION(case_130_multi, 39.0, 2, 2);
TEST_INTERSECTION(case_64_multi, 1.0, 1, 0);
TEST_INTERSECTION(case_78_multi, 22.0, 1, 2);
TEST_INTERSECTION(case_72_multi, 2.85, 3, 0);
TEST_INTERSECTION_WITH(case_72_multi, 1, 2, 6.15, 3, 1);
TEST_INTERSECTION(case_multi_simplex, 6.42, 2, 0);
TEST_INTERSECTION(case_multi_diagonal, 650.0, 1, 0);
TEST_INTERSECTION(case_multi_2, 5.9, 3, 0);
TEST_INTERSECTION(case_multi_3, 20.0, 1, 0);
return;
TEST_DIFFERENCE_A(case_multi_simplex, 5.58, 5, 0);
TEST_DIFFERENCE_B(case_multi_simplex, 2.58, 4, 0);
@ -246,25 +454,18 @@ void test_all()
// Contains many clusters, needing to exclude u/u turns
TEST_UNION(case_recursive_boxes_3, 56.5, 17, 6);
// Contains 4 clusters, one of which having 4 turns
TEST_UNION(case_recursive_boxes_7, 7.0, 2, 0);
// Contains 5 clusters, needing immediate selection of next turn
TEST_UNION(case_89_multi, 6.0, 1, 0);
// Needs ux/next_turn_index==-1 to be filtered out
TEST_INTERSECTION(case_77_multi, 9.0, 5, 0);
TEST_UNION(case_101_multi, 22.25, 1, 3);
TEST_INTERSECTION(case_101_multi, 4.75, 4, 0);
TEST_INTERSECTION(case_recursive_boxes_11, 1.0, 2, 0);
TEST_INTERSECTION(case_recursive_boxes_30, 6.0, 4, 0);
TEST_UNION(case_recursive_boxes_4, 96.75, 1, 2);
TEST_INTERSECTION_WITH(case_58_multi, 2, 6, 13.25, 1, 1);
TEST_INTERSECTION_WITH(case_72_multi, 1, 2, 6.15, 3, 1);
TEST_UNION(case_recursive_boxes_12, 6.0, 6, 0);
TEST_UNION(case_recursive_boxes_13, 10.25, 3, 0);
TEST_INTERSECTION(issue_930, 8.3333333, 1, 0);
}
@ -281,7 +482,7 @@ void test_integer()
int test_main(int, char* [])
{
test_integer<int, true>();
// test_integer<int, true>();
test_all<double, true>();
return 0;
}

263
test/algorithms/overlay/sort_by_side.cpp
View File

@ -1,263 +0,0 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Unit Test
// Copyright (c) 2016 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
// This file was modified by Oracle on 2017-2024.
// Modifications copyright (c) 2017-2024, Oracle and/or its affiliates.
// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <geometry_test_common.hpp>
#include <boost/geometry/algorithms/correct.hpp>
#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay.hpp>
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry/io/wkt/read.hpp>
#include "multi_overlay_cases.hpp"
namespace
{
template <typename T>
std::string as_string(std::vector<T> const& v)
{
std::stringstream out;
bool first = true;
for (T const& value : v)
{
out << (first ? "[" : " , ") << value;
first = false;
}
out << (first ? "" : "]");
return out.str();
}
}
// Adapted copy of handle_colocations::gather_cluster_properties
template
<
bool Reverse1, bool Reverse2,
bg::overlay_type OverlayType,
typename Clusters,
typename Turns,
typename Geometry1,
typename Geometry2,
typename Strategy
>
std::vector<std::size_t> gather_cluster_properties(
Clusters& clusters, Turns& turns,
bg::detail::overlay::operation_type for_operation,
Geometry1 const& geometry1, Geometry2 const& geometry2,
Strategy const& strategy)
{
using namespace boost::geometry;
using namespace boost::geometry::detail::overlay;
std::vector<std::size_t> result;
typedef typename boost::range_value<Turns>::type turn_type;
typedef typename turn_type::point_type point_type;
typedef typename turn_type::turn_operation_type turn_operation_type;
// Define sorter, sorting counter-clockwise such that polygons are on the
// right side
typedef sort_by_side::side_sorter
<
Reverse1, Reverse2, OverlayType, point_type, Strategy, std::less<int>
> sbs_type;
for (typename Clusters::iterator mit = clusters.begin();
mit != clusters.end(); ++mit)
{
cluster_info& cinfo = mit->second;
std::set<signed_size_type> const& ids = cinfo.turn_indices;
if (ids.empty())
{
return result;
}
sbs_type sbs(strategy);
point_type turn_point; // should be all the same for all turns in cluster
bool first = true;
for (typename std::set<signed_size_type>::const_iterator sit = ids.begin();
sit != ids.end(); ++sit)
{
signed_size_type turn_index = *sit;
turn_type const& turn = turns[turn_index];
if (first)
{
turn_point = turn.point;
}
for (int i = 0; i < 2; i++)
{
turn_operation_type const& op = turn.operations[i];
sbs.add(turn, op, turn_index, i, geometry1, geometry2, first);
first = false;
}
}
sbs.apply(turn_point);
sbs.find_open();
sbs.assign_zones(for_operation);
cinfo.open_count = sbs.open_count(for_operation);
result.push_back(cinfo.open_count);
}
return result;
}
// Adapted copy of overlay::apply
template
<
bg::overlay_type OverlayType,
bool Reverse1, bool Reverse2, bool ReverseOut,
typename GeometryOut,
typename Geometry1, typename Geometry2,
typename Strategy
>
std::vector<std::size_t> apply_overlay(
Geometry1 const& geometry1, Geometry2 const& geometry2,
Strategy const& strategy)
{
using namespace boost::geometry;
typedef typename bg::point_type<GeometryOut>::type point_type;
typedef bg::detail::overlay::traversal_turn_info
<
point_type,
typename bg::segment_ratio_type<point_type>::type
> turn_info;
typedef std::deque<turn_info> turn_container_type;
// Define the clusters, mapping cluster_id -> turns
typedef std::map
<
signed_size_type,
bg::detail::overlay::cluster_info
> cluster_type;
turn_container_type turns;
detail::get_turns::no_interrupt_policy policy;
bg::get_turns
<
Reverse1, Reverse2,
detail::overlay::assign_null_policy
>(geometry1, geometry2, strategy, turns, policy);
cluster_type clusters;
// Handle colocations, gathering clusters and (below) their properties.
bg::detail::overlay::handle_colocations
<
Reverse1, Reverse2, OverlayType, Geometry1, Geometry2
>(turns, clusters);
bg::enrich_intersection_points<Reverse1, Reverse2, OverlayType>(turns,
clusters, geometry1, geometry2, strategy);
// Gather cluster properties, with test option
return ::gather_cluster_properties<Reverse1, Reverse2, OverlayType>(
clusters, turns, bg::detail::overlay::operation_from_overlay<OverlayType>::value,
geometry1, geometry2, strategy);
}
template <typename Geometry, bg::overlay_type OverlayType>
void test_sort_by_side(std::string const& case_id,
std::string const& wkt1, std::string const& wkt2,
std::vector<std::size_t> const& expected_open_count)
{
// std::cout << case_id << std::endl;
Geometry g1;
bg::read_wkt(wkt1, g1);
Geometry g2;
bg::read_wkt(wkt2, g2);
// Reverse if necessary
bg::correct(g1);
bg::correct(g2);
typedef typename boost::range_value<Geometry>::type geometry_out;
typedef typename bg::strategies::relate::services::default_strategy
<
Geometry, Geometry
>::type strategy_type;
strategy_type strategy;
std::vector<std::size_t> result = ::apply_overlay
<
OverlayType, false, false, false, geometry_out
>(g1, g2, strategy);
BOOST_CHECK_MESSAGE(result == expected_open_count,
" caseid=" << case_id
<< " open count: expected=" << as_string(expected_open_count)
<< " detected=" << as_string(result));
}
// Define two small macro's to avoid repetitions of testcases/names etc
#define TEST_INTER(caseid, ...) { (test_sort_by_side<multi_polygon, bg::overlay_intersection>) \
( #caseid "_inter", caseid[0], caseid[1], __VA_ARGS__); }
#define TEST_UNION(caseid, ...) { (test_sort_by_side<multi_polygon, bg::overlay_union>) \
( #caseid "_union", caseid[0], caseid[1], __VA_ARGS__); }
template <typename T>
void test_all()
{
typedef bg::model::point<T, 2, bg::cs::cartesian> point_type;
typedef bg::model::polygon<point_type> polygon;
typedef bg::model::multi_polygon<polygon> multi_polygon;
// Selection of test cases having only one cluster
TEST_INTER(case_64_multi, {1});
TEST_INTER(case_72_multi, {3});
TEST_INTER(case_107_multi, {2});
TEST_INTER(case_123_multi, {3});
TEST_INTER(case_124_multi, {3});
TEST_INTER(case_recursive_boxes_10, {2});
TEST_INTER(case_recursive_boxes_20, {2});
TEST_INTER(case_recursive_boxes_21, {1});
TEST_INTER(case_recursive_boxes_22, {0});
TEST_UNION(case_recursive_boxes_46, {2, 1, 2, 1, 1, 2, 1});
TEST_UNION(case_62_multi, {2});
TEST_UNION(case_63_multi, {2});
TEST_UNION(case_64_multi, {1});
TEST_UNION(case_107_multi, {1});
TEST_UNION(case_123_multi, {1});
TEST_UNION(case_124_multi, {1});
TEST_UNION(case_recursive_boxes_10, {1});
TEST_UNION(case_recursive_boxes_18, {3});
TEST_UNION(case_recursive_boxes_19, {3});
TEST_UNION(case_recursive_boxes_20, {2});
TEST_UNION(case_recursive_boxes_21, {1});
TEST_UNION(case_recursive_boxes_22, {1});
TEST_UNION(case_recursive_boxes_23, {3});
}
int test_main(int, char* [])
{
test_all<double>();
return 0;
}

331
test/algorithms/overlay/sort_by_side_basic.cpp
View File

@ -1,331 +0,0 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Unit Test
// Copyright (c) 2017 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
// This file was modified by Oracle on 2017-2024.
// Modifications copyright (c) 2017-2024, Oracle and/or its affiliates.
// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <geometry_test_common.hpp>
#include <boost/geometry/algorithms/correct.hpp>
#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/sort_by_side.hpp>
#include <boost/geometry/algorithms/equals.hpp>
#include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry/io/wkt/wkt.hpp>
#if defined(TEST_WITH_SVG)
#include "debug_sort_by_side_svg.hpp"
#endif
namespace
{
template <typename T>
std::string as_string(std::vector<T> const& v)
{
std::stringstream out;
bool first = true;
for (T const& value : v)
{
out << (first ? "[" : " , ") << value;
first = false;
}
out << (first ? "" : "]");
return out.str();
}
}
template
<
typename Geometry, typename Point,
typename Strategy
>
std::vector<std::size_t> apply_get_turns(std::string const& case_id,
Geometry const& geometry1, Geometry const& geometry2,
Point const& turn_point, Point const& origin_point,
Strategy const& strategy,
std::size_t expected_open_count,
std::size_t expected_max_rank,
std::vector<bg::signed_size_type> const& expected_right_count)
{
using namespace boost::geometry;
std::vector<std::size_t> result;
//todo: maybe should be enriched to count left/right - but can also be counted from ranks
typedef typename bg::point_type<Geometry>::type point_type;
typedef bg::detail::overlay::turn_info
<
point_type,
typename bg::segment_ratio_type<point_type>::type
> turn_info;
typedef std::deque<turn_info> turn_container_type;
turn_container_type turns;
detail::get_turns::no_interrupt_policy policy;
bg::get_turns
<
false, false,
detail::overlay::assign_null_policy
>(geometry1, geometry2, strategy, turns, policy);
// Define sorter, sorting counter-clockwise such that polygons are on the
// right side
using sbs_type = bg::detail::overlay::sort_by_side::side_sorter
<
false, false, overlay_union,
point_type, Strategy, std::less<int>
>;
sbs_type sbs(strategy);
std::cout << "Case: " << case_id << std::endl;
bool has_origin = false;
for (std::size_t turn_index = 0; turn_index < turns.size(); turn_index++)
{
turn_info const& turn = turns[turn_index];
if (bg::equals(turn.point, turn_point))
{
// std::cout << "Found turn: " << turn_index << std::endl;
for (int i = 0; i < 2; i++)
{
Point point1, point2, point3;
bg::copy_segment_points<false, false>(geometry1, geometry2,
turn.operations[i].seg_id, point1, point2, point3);
bool const is_origin = ! has_origin && bg::equals(point1, origin_point);
if (is_origin)
{
has_origin = true;
}
sbs.add(turn, turn.operations[i], turn_index, i,
geometry1, geometry2, is_origin);
}
}
}
BOOST_CHECK_MESSAGE(has_origin,
" caseid=" << case_id
<< " origin not found");
if (!has_origin)
{
for (std::size_t turn_index = 0; turn_index < turns.size(); turn_index++)
{
turn_info const& turn = turns[turn_index];
if (bg::equals(turn.point, turn_point))
{
for (int i = 0; i < 2; i++)
{
Point point1, point2, point3;
bg::copy_segment_points<false, false>(geometry1, geometry2,
turn.operations[i].seg_id, point1, point2, point3);
// std::cout << "Turn " << turn_index << " op " << i << " point1=" << bg::wkt(point1) << std::endl;
}
}
}
return result;
}
sbs.apply(turn_point);
sbs.find_open();
sbs.assign_zones(detail::overlay::operation_union);
std::size_t const open_count = sbs.open_count(detail::overlay::operation_union);
std::size_t const max_rank = sbs.m_ranked_points.back().rank;
std::vector<bg::signed_size_type> right_count(max_rank + 1, -1);
int previous_rank = -1;
int previous_to_rank = -1;
for (std::size_t i = 0; i < sbs.m_ranked_points.size(); i++)
{
typename sbs_type::rp const& ranked_point = sbs.m_ranked_points[i];
int const rank = static_cast<int>(ranked_point.rank);
bool const set_right = rank != previous_to_rank;
if (rank != previous_rank)
{
BOOST_CHECK_MESSAGE(rank == previous_rank + 1,
" caseid=" << case_id
<< " ranks: conflict in ranks=" << ranked_point.rank
<< " vs " << previous_rank + 1);
previous_rank = rank;
}
if (ranked_point.direction != bg::detail::overlay::sort_by_side::dir_to)
{
continue;
}
previous_to_rank = rank;
if (set_right)
{
right_count[rank] = ranked_point.count_right;
}
else
{
BOOST_CHECK_MESSAGE(right_count[rank] == int(ranked_point.count_right),
" caseid=" << case_id
<< " ranks: conflict in right_count=" << ranked_point.count_right
<< " vs " << right_count[rank]);
}
}
BOOST_CHECK_MESSAGE(open_count == expected_open_count,
" caseid=" << case_id
<< " open_count: expected=" << expected_open_count
<< " detected=" << open_count);
BOOST_CHECK_MESSAGE(max_rank == expected_max_rank,
" caseid=" << case_id
<< " max_rank: expected=" << expected_max_rank
<< " detected=" << max_rank);
BOOST_CHECK_MESSAGE(right_count == expected_right_count,
" caseid=" << case_id
<< " right count: expected=" << as_string(expected_right_count)
<< " detected=" << as_string(right_count));
#if defined(TEST_WITH_SVG)
debug::sorted_side_map(case_id, sbs, turn_point, geometry1, geometry2);
#endif
return result;
}
template <typename T>
void test_basic(std::string const& case_id,
std::string const& wkt1,
std::string const& wkt2,
std::string const& wkt_turn_point,
std::string const& wkt_origin_point,
std::size_t expected_open_count,
std::size_t expected_max_rank,
std::vector<bg::signed_size_type> const& expected_right_count)
{
typedef bg::model::point<T, 2, bg::cs::cartesian> point_type;
typedef bg::model::polygon<point_type> polygon;
typedef bg::model::multi_polygon<polygon> multi_polygon;
multi_polygon g1;
bg::read_wkt(wkt1, g1);
multi_polygon g2;
bg::read_wkt(wkt2, g2);
point_type turn_point, origin_point;
bg::read_wkt(wkt_turn_point, turn_point);
bg::read_wkt(wkt_origin_point, origin_point);
// Reverse if necessary
bg::correct(g1);
bg::correct(g2);
typedef typename bg::strategies::relate::services::default_strategy
<
multi_polygon, multi_polygon
>::type strategy_type;
strategy_type strategy;
apply_get_turns(case_id, g1, g2, turn_point, origin_point,
strategy,
expected_open_count, expected_max_rank, expected_right_count);
}
template <typename T>
void test_all()
{
test_basic<T>("simplex",
"MULTIPOLYGON(((0 2,1 2,1 1,0 1,0 2)))",
"MULTIPOLYGON(((1 0,1 1,2 1,2 0,1, 0)))",
"POINT(1 1)", "POINT(1 0)",
2, 3, {-1, 1, -1, 1});
test_basic<T>("dup1",
"MULTIPOLYGON(((0 2,1 2,1 1,0 1,0 2)))",
"MULTIPOLYGON(((1 0,1 1,2 1,2 0,1, 0)),((0 2,1 2,1 1,0 1,0 2)))",
"POINT(1 1)", "POINT(1 0)",
2, 3, {-1, 1, -1, 2});
test_basic<T>("dup2",
"MULTIPOLYGON(((0 2,1 2,1 1,0 1,0 2)),((1 0,1 1,2 1,2 0,1, 0)))",
"MULTIPOLYGON(((1 0,1 1,2 1,2 0,1, 0)))",
"POINT(1 1)", "POINT(1 0)",
2, 3, {-1, 2, -1, 1});
test_basic<T>("dup3",
"MULTIPOLYGON(((0 2,1 2,1 1,0 1,0 2)),((1 0,1 1,2 1,2 0,1, 0)))",
"MULTIPOLYGON(((1 0,1 1,2 1,2 0,1, 0)),((0 2,1 2,1 1,0 1,0 2)))",
"POINT(1 1)", "POINT(1 0)",
2, 3, {-1, 2, -1, 2});
test_basic<T>("threequart1",
"MULTIPOLYGON(((0 2,1 2,1 1,0 1,0 2)),((1 0,1 1,2 1,2 0,1, 0)))",
"MULTIPOLYGON(((1 2,2 2,2 1,1 1,1 2)))",
"POINT(1 1)", "POINT(1 0)",
1, 3, {-1, 1, 1, 1});
test_basic<T>("threequart2",
"MULTIPOLYGON(((0 2,1 2,1 1,0 1,0 2)),((1 0,1 1,2 1,2 0,1, 0)))",
"MULTIPOLYGON(((1 2,2 2,2 1,1 1,1 2)),((2 0,1 0,1 1,2 0)))",
"POINT(1 1)", "POINT(1 0)",
1, 4, {-1, 2, 1, 1, 1});
test_basic<T>("threequart3",
"MULTIPOLYGON(((0 2,1 2,1 1,0 1,0 2)),((1 0,1 1,2 1,2 0,1, 0)))",
"MULTIPOLYGON(((1 2,2 2,2 1,1 1,1 2)),((2 0,1 0,1 1,2 0)),((0 1,0 2,1 1,0 1)))",
"POINT(1 1)", "POINT(1 0)",
1, 5, {-1, 2, 1, 1, -1, 2});
test_basic<T>("full1",
"MULTIPOLYGON(((0 2,1 2,1 1,0 1,0 2)),((1 0,1 1,2 1,2 0,1, 0)))",
"MULTIPOLYGON(((1 2,2 2,2 1,1 1,1 2)),((0 0,0 1,1 1,1 0,0 0)))",
"POINT(1 1)", "POINT(1 0)",
0, 3, {1, 1, 1, 1});
test_basic<T>("hole1",
"MULTIPOLYGON(((0 0,0 3,2 3,2 2,3 2,3 0,0 0),(1 1,2 1,2 2,1 2,1 1)),((4 2,3 2,3 3,4 3,4 2)))",
"MULTIPOLYGON(((1 0,1 1,2 1,2 2,1 2,1 4,4 4,4 0,1, 0),(3 2,3 3,2 3,2 2,3 2)))",
"POINT(1 2)", "POINT(2 2)",
1, 2, {-1, 2, 1});
test_basic<T>("hole2",
"MULTIPOLYGON(((0 0,0 3,2 3,2 2,3 2,3 0,0 0),(1 1,2 1,2 2,1 2,1 1)),((4 2,3 2,3 3,4 3,4 2)))",
"MULTIPOLYGON(((1 0,1 1,2 1,2 2,1 2,1 4,4 4,4 0,1, 0),(3 2,3 3,2 3,2 2,3 2)))",
"POINT(2 2)", "POINT(2 1)",
2, 3, {-1, 2, -1, 2});
test_basic<T>("hole3",
"MULTIPOLYGON(((0 0,0 3,2 3,2 2,3 2,3 0,0 0),(1 1,2 1,2 2,1 2,1 1)),((4 2,3 2,3 3,4 3,4 2)))",
"MULTIPOLYGON(((1 0,1 1,2 1,2 2,1 2,1 4,4 4,4 0,1, 0),(3 2,3 3,2 3,2 2,3 2)))",
"POINT(3 2)", "POINT(2 2)",
1, 3, {-1, 2, -1, 2});
}
int test_main(int, char* [])
{
test_all<double>();
return 0;
}

1018
test/algorithms/overlay/traverse.cpp
View File

File diff suppressed because it is too large Load Diff

360
test/algorithms/overlay/traverse_ccw.cpp
View File

@ -1,360 +0,0 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Unit Test
// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
// This file was modified by Oracle on 2021-2024.
// Modifications copyright (c) 2021-2024, Oracle and/or its affiliates.
// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#define BOOST_GEOMETRY_DEFINE_STREAM_OPERATOR_SEGMENT_RATIO
#include <fstream>
#include <iostream>
#include <iomanip>
#include <geometry_test_common.hpp>
#include <boost/geometry/algorithms/correct.hpp>
#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>
#include <boost/geometry/io/wkt/wkt.hpp>
#if defined(TEST_WITH_SVG)
# include <boost/geometry/io/svg/svg_mapper.hpp>
#endif
#include <algorithms/overlay/overlay_cases.hpp>
template <typename Geometry>
using rev = bg::util::bool_constant<bg::point_order<Geometry>::value == bg::counterclockwise>;
template <typename Geometry1, typename Geometry2>
inline typename bg::coordinate_type<Geometry1>::type
intersect(Geometry1 const& g1, Geometry2 const& g2, std::string const& name,
bg::detail::overlay::operation_type op)
{
boost::ignore_unused(name);
typedef typename bg::strategy::side::services::default_strategy
<
typename bg::cs_tag<Geometry1>::type
>::type side_strategy_type;
typedef typename bg::point_type<Geometry1>::type point_type;
typedef bg::detail::overlay::traversal_turn_info
<
point_type,
typename bg::detail::segment_ratio_type<point_type>::type
> turn_info;
std::vector<turn_info> turns;
bg::detail::get_turns::no_interrupt_policy policy;
bg::get_turns
<
rev<Geometry1>::value,
rev<Geometry2>::value,
bg::detail::overlay::assign_null_policy
>(g1, g2, turns, policy);
bg::enrich_intersection_points
<
rev<Geometry1>::value, rev<Geometry2>::value,
bg::overlay_intersection
>(turns, bg::detail::overlay::operation_intersection,
g1, g2, side_strategy_type());
typedef bg::model::ring<typename bg::point_type<Geometry1>::type> ring_type;
typedef std::deque<ring_type> out_vector;
out_vector v;
bg::detail::overlay::traverse
<
rev<Geometry1>::value, rev<Geometry2>::value,
Geometry1, Geometry2
>::apply(g1, g2, op, turns, v);
typename bg::coordinate_type<Geometry1>::type result = 0.0;
for (ring_type& ring : v)
{
result += bg::area(ring);
}
#if defined(TEST_WITH_SVG)
{
std::ostringstream filename;
filename
<< name << "_"
<< (op == bg::detail::overlay::operation_intersection ? "i" : "u")
<< "_" << (rev<Geometry1>::value ? "ccw" : "cw")
<< "_" << (rev<Geometry2>::value ? "ccw" : "cw")
<< ".svg";
std::ofstream svg(filename.str().c_str());
bg::svg_mapper<typename bg::point_type<Geometry1>::type> mapper(svg, 500, 500);
mapper.add(g1);
mapper.add(g2);
// Input shapes in green/blue
mapper.map(g1, "fill-opacity:0.5;fill:rgb(153,204,0);"
"stroke:rgb(153,204,0);stroke-width:3");
mapper.map(g2, "fill-opacity:0.3;fill:rgb(51,51,153);"
"stroke:rgb(51,51,153);stroke-width:3");
// Traversal rings in magenta/light yellow fill
for (ring_type const& ring : v)
{
mapper.map(ring, "fill-opacity:0.3;stroke-opacity:0.4;fill:rgb(255,255,0);"
"stroke:rgb(255,0,255);stroke-width:8");
}
// turn points in orange, + enrichment/traversal info
// Simple map to avoid two texts at same place (note that can still overlap!)
std::map<std::pair<int, int>, int> offsets;
int index = 0;
int const lineheight = 10;
int const margin = 5;
for (turn_info const& turn : turns)
{
mapper.map(turn.point, "fill:rgb(255,128,0);"
"stroke:rgb(0,0,0);stroke-width:1", 3);
{
// Map characteristics
// Create a rounded off point
std::pair<int, int> p
= std::make_pair(
util::numeric_cast<int>(0.5 + 10 * bg::get<0>(turn.point)),
util::numeric_cast<int>(0.5 + 10 * bg::get<1>(turn.point))
);
std::string style = "fill:rgb(0,0,0);font-family:Arial;font-size:10px";
std::ostringstream out;
out << index
<< ": " << bg::method_char(turn.method)
<< std::endl
<< "op: " << bg::operation_char(turn.operations[0].operation)
<< " / " << bg::operation_char(turn.operations[1].operation)
<< (turn.is_discarded() ? " (discarded) " : turn.blocked() ? " (blocked)" : "")
<< std::endl;
if (turn.operations[0].enriched.next_ip_index != -1)
{
out << "ip: " << turn.operations[0].enriched.next_ip_index;
}
else
{
out << "vx: " << turn.operations[0].enriched.travels_to_vertex_index;
}
out << " ";
if (turn.operations[1].enriched.next_ip_index != -1)
{
out << "ip: " << turn.operations[1].enriched.next_ip_index;
}
else
{
out << "vx: " << turn.operations[1].enriched.travels_to_vertex_index;
}
out << std::endl;
out
<< std::setprecision(3)
<< "dist: " << turn.operations[0].fraction
<< " / " << turn.operations[1].fraction
<< std::endl;
offsets[p] += lineheight;
int offset = offsets[p];
offsets[p] += lineheight * 5;
mapper.text(turn.point, out.str(), style, margin, offset, lineheight);
}
index++;
}
}
#endif
return result;
}
template <typename Geometry1, typename Geometry2>
inline typename bg::coordinate_type<Geometry1>::type intersect(std::string const& wkt1, std::string const& wkt2, std::string const& name,
bg::detail::overlay::operation_type op)
{
Geometry1 geometry1;
Geometry2 geometry2;
bg::read_wkt(wkt1, geometry1);
bg::read_wkt(wkt2, geometry2);
// Reverse if necessary: adapt to cw/ccw
bg::correct(geometry1);
bg::correct(geometry2);
return intersect(geometry1, geometry2, name, op);
}
template <typename T>
inline void test_polygon(std::string const& wkt1, std::string const& wkt2, std::string const& name)
{
typedef bg::model::d2::point_xy<T> point;
typedef bg::model::polygon<point> clock;
typedef bg::model::polygon<point, false> counter;
namespace ov = bg::detail::overlay;
T area1 = intersect<clock, clock>(wkt1, wkt2, name, ov::operation_intersection);
T area2 = intersect<counter, counter>(wkt1, wkt2, name, ov::operation_intersection);
T area3 = intersect<clock, counter>(wkt1, wkt2, name, ov::operation_intersection);
T area4 = intersect<counter, clock>(wkt1, wkt2, name, ov::operation_intersection);
BOOST_CHECK_CLOSE(area1, area2, 0.001);
BOOST_CHECK_CLOSE(area3, area4, 0.001);
BOOST_CHECK_CLOSE(area1, area3, 0.001);
BOOST_CHECK_CLOSE(area2, area4, 0.001);
area1 = intersect<clock, clock>(wkt1, wkt2, name, ov::operation_union);
area2 = intersect<counter, counter>(wkt1, wkt2, name, ov::operation_union);
area3 = intersect<clock, counter>(wkt1, wkt2, name, ov::operation_union);
area4 = intersect<counter, clock>(wkt1, wkt2, name, ov::operation_union);
BOOST_CHECK_CLOSE(area1, area2, 0.001);
BOOST_CHECK_CLOSE(area3, area4, 0.001);
BOOST_CHECK_CLOSE(area1, area3, 0.001);
BOOST_CHECK_CLOSE(area2, area4, 0.001);
}
template <typename T>
inline void test_box_polygon(std::string const& wkt1, std::string const& wkt2, std::string const& name)
{
typedef bg::model::d2::point_xy<T> point;
typedef bg::model::box<point> box;
typedef bg::model::polygon<point> clock;
typedef bg::model::polygon<point, false> counter;
namespace ov = bg::detail::overlay;
T area1 = intersect<box, clock>(wkt1, wkt2, name + "_bp", ov::operation_intersection);
T area2 = intersect<box, counter>(wkt1, wkt2, name + "_bp", ov::operation_intersection);
T area3 = intersect<clock, box>(wkt2, wkt1, name + "_pb", ov::operation_intersection);
T area4 = intersect<counter, box>(wkt2, wkt1, name + "_pb", ov::operation_intersection);
BOOST_CHECK_CLOSE(area1, area2, 0.001);
BOOST_CHECK_CLOSE(area3, area4, 0.001);
BOOST_CHECK_CLOSE(area1, area3, 0.001);
BOOST_CHECK_CLOSE(area2, area4, 0.001);
area1 = intersect<box, clock>(wkt1, wkt2, name + "_bp", ov::operation_union);
area2 = intersect<box, counter>(wkt1, wkt2, name + "_bp", ov::operation_union);
area3 = intersect<clock, box>(wkt2, wkt1, name + "_pb", ov::operation_union);
area4 = intersect<counter, box>(wkt2, wkt1, name + "_pb", ov::operation_union);
BOOST_CHECK_CLOSE(area1, area2, 0.001);
BOOST_CHECK_CLOSE(area3, area4, 0.001);
BOOST_CHECK_CLOSE(area1, area3, 0.001);
BOOST_CHECK_CLOSE(area2, area4, 0.001);
}
int test_main(int, char* [])
{
//bool const ig = true;
test_polygon<double>(case_1[0], case_1[1], "c1");
test_polygon<double>(case_2[0], case_2[1], "c2");
test_polygon<double>(case_3[0], case_3[1], "c3");
test_polygon<double>(case_4[0], case_4[1], "c4");
test_polygon<double>(case_5[0], case_5[1], "c5");
test_polygon<double>(case_6[0], case_6[1], "c6");
test_polygon<double>(case_7[0], case_7[1], "c7");
test_polygon<double>(case_8[0], case_8[1], "c8");
test_polygon<double>(case_9[0], case_9[1], "c9" /*, ig */);
test_polygon<double>(case_10[0], case_10[1], "c10");
test_polygon<double>(case_11[0], case_11[1], "c11");
test_polygon<double>(case_12[0], case_12[1], "c12");
test_polygon<double>(case_13[0], case_13[1], "c13");
test_polygon<double>(case_14[0], case_14[1], "c14");
test_polygon<double>(case_15[0], case_15[1], "c15");
test_polygon<double>(case_16[0], case_16[1], "c16");
test_polygon<double>(case_17[0], case_17[1], "c17");
test_polygon<double>(case_18[0], case_18[1], "c18");
test_polygon<double>(case_19[0], case_19[1], "c19");
test_polygon<double>(case_20[0], case_20[1], "c20");
test_polygon<double>(case_21[0], case_21[1], "c21");
test_polygon<double>(case_22[0], case_22[1], "c22" /*, ig */);
test_polygon<double>(case_23[0], case_23[1], "c23");
test_polygon<double>(case_24[0], case_24[1], "c24");
test_polygon<double>(case_25[0], case_25[1], "c25" /*, ig */);
test_polygon<double>(case_26[0], case_26[1], "c26" /*, ig */);
test_polygon<double>(case_27[0], case_27[1], "c27");
test_polygon<double>(case_28[0], case_28[1], "c28");
test_polygon<double>(case_29[0], case_29[1], "c29");
test_polygon<double>(case_30[0], case_30[1], "c30");
test_polygon<double>(case_31[0], case_31[1], "c31" /*, ig */);
test_polygon<double>(case_32[0], case_32[1], "c32" /*, ig */);
test_polygon<double>(case_33[0], case_33[1], "c33" /*, ig */);
test_polygon<double>(case_34[0], case_34[1], "c34");
test_polygon<double>(case_35[0], case_35[1], "c35");
test_polygon<double>(case_36[0], case_36[1], "c36" /*, ig */);
test_polygon<double>(case_37[0], case_37[1], "c37" /*, ig */);
test_polygon<double>(case_38[0], case_38[1], "c38" /*, ig */);
test_polygon<double>(case_39[0], case_39[1], "c39");
test_polygon<double>(case_40[0], case_40[1], "c40" /*, ig */);
test_polygon<double>(case_41[0], case_41[1], "c41");
test_polygon<double>(case_42[0], case_42[1], "c42");
//test_polygon<double>(case_43[0], case_43[1], "c43", inv);
test_polygon<double>(case_44[0], case_44[1], "c44");
test_polygon<double>(case_45[0], case_45[1], "c45");
//test_polygon<double>(case_46[0], case_46[1], "c46", inv);
//test_polygon<double>(case_47[0], case_47[1], "c47" /*, ig */);
//test_polygon<double>(case_48[0], case_48[1], "c48");
test_polygon<double>(case_49[0], case_49[1], "c49");
test_polygon<double>(case_50[0], case_50[1], "c50");
test_polygon<double>(case_51[0], case_51[1], "c51");
test_polygon<double>(case_52[0], case_52[1], "c52" /*, ig */);
test_polygon<double>(case_53[0], case_53[1], "c53");
// Invalid ones / overlaying intersection points / self tangencies
//test_polygon<double>(case_54[0], case_54[1], "c54");
//test_polygon<double>(case_55[0], case_55[1], "c55");
//test_polygon<double>(case_56[0], case_56[1], "c56");
//test_polygon<double>(case_57[0], case_57[1], "c57" /*, ig */);
//test_polygon<double>(case_58[0], case_58[1], "c58");
//test_polygon<double>(case_59[0], case_59[1], "c59");
test_polygon<double>(pie_16_4_12[0], pie_16_4_12[1], "pie_16_4_12");
test_polygon<double>(pie_23_21_12_500[0], pie_23_21_12_500[1], "pie_23_21_12_500");
test_polygon<double>(pie_23_23_3_2000[0], pie_23_23_3_2000[1], "pie_23_23_3_2000");
test_polygon<double>(pie_23_16_16[0], pie_23_16_16[1], "pie_23_16_16");
test_polygon<double>(pie_16_2_15_0[0], pie_16_2_15_0[1], "pie_16_2_15_0");
test_polygon<double>(pie_4_13_15[0], pie_4_13_15[1], "pie_4_13_15");
test_polygon<double>(pie_20_20_7_100[0], pie_20_20_7_100[1], "pie_20_20_7_100");
test_polygon<double>(hv_1[0], hv_1[1], "hv1");
test_polygon<double>(hv_2[0], hv_2[1], "hv2");
test_polygon<double>(hv_3[0], hv_3[1], "hv3");
test_polygon<double>(hv_4[0], hv_4[1], "hv4");
test_polygon<double>(hv_5[0], hv_5[1], "hv5");
test_polygon<double>(hv_6[0], hv_6[1], "hv6");
test_polygon<double>(hv_7[0], hv_7[1], "hv7");
test_polygon<double>(dz_1[0], dz_1[1], "dz_1");
test_polygon<double>(dz_2[0], dz_2[1], "dz_2");
test_polygon<double>(dz_3[0], dz_3[1], "dz_3");
test_box_polygon<double>("POLYGON((1 1,4 4))", case_1[0], "bp1");
{
static std::string example_box = "POLYGON((1.5 1.5, 4.5 2.5))";
static std::string example_ring =
"POLYGON((2 1.3,2.4 1.7,2.8 1.8,3.4 1.2,3.7 1.6,3.4 2,4.1 3,5.3 2.6,5.4 1.2,4.9 0.8,2.9 0.7,2 1.3))";
test_box_polygon<double>(example_box, example_ring, "bp2");
}
return 0;
}

462
test/algorithms/overlay/traverse_multi.cpp
View File

@ -1,462 +0,0 @@
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Unit Test
// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//#define BOOST_GEOMETRY_DEBUG_ENRICH
//#define BOOST_GEOMETRY_DEBUG_RELATIVE_ORDER
// Include the single-geometry version
#define BOOST_GEOMETRY_TEST_MULTI
#include <algorithms/overlay/traverse.cpp>
#include <boost/geometry/core/closure.hpp>
#include <boost/geometry/core/geometry_id.hpp>
#include <boost/geometry/core/point_order.hpp>
#include <boost/geometry/core/ring_type.hpp>
#include <boost/geometry/algorithms/envelope.hpp>
#include <boost/geometry/algorithms/num_points.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
#include <boost/geometry/algorithms/detail/sections/range_by_section.hpp>
#include <boost/geometry/algorithms/detail/sections/sectionalize.hpp>
#include <boost/geometry/views/detail/range_type.hpp>
#include "multi_overlay_cases.hpp"
template <typename MultiPolygon, bool Reverse>
void test_geometries()
{
typedef test_traverse
<
MultiPolygon, MultiPolygon,
bg::overlay_intersection, Reverse, Reverse
> test_traverse_intersection;
typedef test_traverse
<
MultiPolygon, MultiPolygon,
bg::overlay_union, Reverse, Reverse
> test_traverse_union;
// Intersections:
test_traverse_intersection::apply
(
"simplex", 2, 6.42,
case_multi_simplex[0], case_multi_simplex[1]
);
test_traverse_intersection::apply
(
"case_58_multi_b4", 1, 12.666666667,
case_58_multi[4], case_58_multi[2]
);
#ifdef BOOST_GEOMETRY_TEST_FAILURES
test_traverse_intersection::apply
(
"case_58_multi_b5", 1, 1,
case_58_multi[5], case_58_multi[2]
);
#endif
test_traverse_intersection::apply
(
"case_58_multi_b6", 1, 13.25,
case_58_multi[6], case_58_multi[2]
);
test_traverse_intersection::apply
(
"case_65_multi", 1, 1,
case_65_multi[0], case_65_multi[1]
);
test_traverse_intersection::apply
(
"case_66_multi", 1, 1,
case_66_multi[0], case_66_multi[1]
);
test_traverse_intersection::apply
(
"case_67_multi", 1, 1,
case_67_multi[0], case_67_multi[1]
);
test_traverse_intersection::apply
(
"case_69_multi", 1, 1,
case_69_multi[0], case_69_multi[1]
);
test_traverse_intersection::apply
(
"case_71_multi", 2, 2,
case_71_multi[0], case_71_multi[1]
);
// #72, note that it intersects into 2 shapes,
// the third one is done by assemble (see intersection #72)
test_traverse_intersection::apply
(
"case_72_multi", 2, 1.35,
case_72_multi[0], case_72_multi[1]
);
test_traverse_intersection::apply
(
"case_73_multi", 2, 2,
case_73_multi[0], case_73_multi[1]
);
test_traverse_intersection::apply
(
"case_74_multi", 2, 3,
case_74_multi[0], case_74_multi[1]
);
test_traverse_intersection::apply
(
"case_75_multi", 1, 1,
case_75_multi[0], case_75_multi[1]
);
test_traverse_intersection::apply
(
"case_77_multi", 5, 9,
case_77_multi[0], case_77_multi[1]
);
test_traverse_intersection::apply
(
"case_78_multi", 2, 22, // Went from 3 to 2 by get_turns / partition
case_78_multi[0], case_78_multi[1]
);
test_traverse_intersection::apply
(
"case_80_multi", 1, 0.5,
case_80_multi[0], case_80_multi[1]
);
test_traverse_intersection::apply
(
"case_81_multi", 1, 0.25,
case_81_multi[0], case_81_multi[1]
);
test_traverse_intersection::apply
(
"case_83_multi", 3, 1.25,
case_83_multi[0], case_83_multi[1]
);
test_traverse_intersection::apply
(
"case_91_multi", 2, 1.0,
case_91_multi[0], case_91_multi[1]
);
test_traverse_intersection::apply
(
"case_92_multi", 3, 1.5,
case_92_multi[0], case_92_multi[1]
);
test_traverse_intersection::apply
(
"case_93_multi", 2, 1.25,
case_93_multi[0], case_93_multi[1]
);
test_traverse_intersection::apply
(
"case_96_multi", 1, 0.5,
case_96_multi[0], case_96_multi[1]
);
test_traverse_intersection::apply
(
"case_98_multi", 4, 3.0,
case_98_multi[0], case_98_multi[1]
);
test_traverse_intersection::apply
(
"case_99_multi", 3, 1.75,
case_99_multi[0], case_99_multi[1]
);
test_traverse_intersection::apply
(
"case_100_multi", 2, 1.5,
case_100_multi[0], case_100_multi[1]
);
test_traverse_intersection::apply
(
"case_108_multi", 7, 7.5,
case_108_multi[0], case_108_multi[1]
);
test_traverse_intersection::apply
(
"case_recursive_boxes_2", 1, 91,
case_recursive_boxes_2[0], case_recursive_boxes_2[1]
);
test_traverse_intersection::apply
(
"case_107_multi", 2, 1.5,
case_107_multi[0], case_107_multi[1]
);
test_traverse_intersection::apply
(
"case_recursive_boxes_3", 19, 12.5,
case_recursive_boxes_3[0], case_recursive_boxes_3[1]
);
// Unions
test_traverse_union::apply
(
"simplex", 1, 14.58,
case_multi_simplex[0], case_multi_simplex[1]
);
test_traverse_union::apply
(
"case_61_multi", 1, 4,
case_61_multi[0], case_61_multi[1]
);
test_traverse_union::apply
(
"case_62_multi", 1, 1 /*UU 2, 2 */,
case_62_multi[0], case_62_multi[1]
);
test_traverse_union::apply
(
"case_63_multi", 1, 1 /*UU 2, 2 */,
case_63_multi[0], case_63_multi[1]
);
test_traverse_union::apply
(
"case_64_multi", 1, 3,
case_64_multi[0], case_64_multi[1]
);
test_traverse_union::apply
(
"case_66_multi", 1, 4 /*UU 3, 7 */,
case_66_multi[0], case_66_multi[1]
);
test_traverse_union::apply
(
"case_68_multi", 1, 4 /*UU 2, 5 */,
case_68_multi[0], case_68_multi[1]
);
// 71: single-polygon generates 2 shapes, multi-polygon
// generates 1 shape, both are self-tangent and OK
test_traverse_union::apply
(
"case_71_multi", 1, 9,
case_71_multi[0], case_71_multi[1]
);
test_traverse_union::apply
(
"case_72_multi", 1, 10.65,
case_72_multi[0], case_72_multi[1]
);
test_traverse_union::apply
(
"case_73_multi", 1, 3,
case_73_multi[0], case_73_multi[1]
);
test_traverse_union::apply
(
"case_74_multi", 2, 17,
case_74_multi[0], case_74_multi[1]
);
test_traverse_union::apply
(
"case_75_multi", 1, 1 /*UU 5, 5 */,
case_75_multi[0], case_75_multi[1]
);
test_traverse_union::apply
(
"case_76_multi", 2, 5 /*UU 6, 6 */,
case_76_multi[0], case_76_multi[1]
);
test_traverse_union::apply
(
"case_80_multi", 1, 9.25,
case_80_multi[0], case_80_multi[1]
);
test_traverse_union::apply
(
"case_81_multi", 1, 3.25,
case_81_multi[0], case_81_multi[1]
);
test_traverse_union::apply
(
"case_82_multi", 3, 4,
case_82_multi[0], case_82_multi[1]
);
test_traverse_union::apply
(
"case_84_multi", 1, 4,
case_84_multi[0], case_84_multi[1]
);
test_traverse_union::apply
(
"case_85_multi", 1, 3.5,
case_85_multi[0], case_85_multi[1]
);
test_traverse_union::apply
(
"case_86_multi", 1, 4,
case_86_multi[0], case_86_multi[1]
);
test_traverse_union::apply
(
"case_87_multi", 1, 6,
case_87_multi[0], case_87_multi[1]
);
test_traverse_union::apply
(
"case_88_multi", 2, 4,
case_88_multi[0], case_88_multi[1]
);
test_traverse_union::apply
(
"case_89_multi", 1, 6,
case_89_multi[0], case_89_multi[1]
);
test_traverse_union::apply
(
"case_90_multi", 1, 7.5,
case_90_multi[0], case_90_multi[1]
);
test_traverse_union::apply
(
"case_92_multi", 2, 6.25,
case_92_multi[0], case_92_multi[1]
);
test_traverse_union::apply
(
"case_94_multi", 1, 10.0,
case_94_multi[0], case_94_multi[1]
);
test_traverse_union::apply
(
"case_95_multi", 2, 6.5,
case_95_multi[0], case_95_multi[1]
);
test_traverse_union::apply
(
"case_96_multi", 1, 3.5,
case_96_multi[0], case_96_multi[1]
);
test_traverse_union::apply
(
"case_97_multi", 1, 3.75,
case_97_multi[0], case_97_multi[1]
);
test_traverse_union::apply
(
"case_101_multi", 1, 22.25,
case_101_multi[0], case_101_multi[1]
);
test_traverse_union::apply
(
"case_102_multi", 3, 24.25,
case_102_multi[0], case_102_multi[1]
);
test_traverse_union::apply
(
"case_103_multi", 1, 25,
case_103_multi[0], case_103_multi[1]
);
test_traverse_union::apply
(
"case_104_multi", 1, 25,
case_104_multi[0], case_104_multi[1]
);
test_traverse_union::apply
(
"case_105_multi", 1, 25,
case_105_multi[0], case_105_multi[1]
);
test_traverse_union::apply
(
"case_106_multi", 1, 25,
case_106_multi[0], case_106_multi[1]
);
test_traverse_union::apply
(
"case_recursive_boxes_1", 2, 97,
case_recursive_boxes_1[0], case_recursive_boxes_1[1]
);
test_traverse_union::apply
(
"case_recursive_boxes_3", 7, 49.5,
case_recursive_boxes_3[0], case_recursive_boxes_3[1]
);
test_traverse_intersection::apply
(
"pie_21_7_21_0_3", 2, 818824.56678,
pie_21_7_21_0_3[0], pie_21_7_21_0_3[1]
);
test_traverse_intersection::apply
(
"pie_23_19_5_0_2", 2, 2948602.3911823,
pie_23_19_5_0_2[0], pie_23_19_5_0_2[1]
);
test_traverse_intersection::apply
(
"pie_7_14_5_0_7", 2, 490804.56678,
pie_7_14_5_0_7[0], pie_7_14_5_0_7[1]
);
test_traverse_intersection::apply
(
"pie_16_16_9_0_2", 2, 1146795,
pie_16_16_9_0_2[0], pie_16_16_9_0_2[1]
);
test_traverse_intersection::apply
(
"pie_7_2_1_0_15", 2, 490585.5,
pie_7_2_1_0_15[0], pie_7_2_1_0_15[1]
);
}
template <typename T>
void test_all()
{
typedef bg::model::point<T, 2, bg::cs::cartesian> point_type;
typedef bg::model::multi_polygon
<
bg::model::polygon<point_type>
> multi_polygon;
typedef bg::model::multi_polygon
<
bg::model::polygon<point_type, false>
> multi_polygon_ccw;
test_geometries<multi_polygon, false>();
test_geometries<multi_polygon_ccw, true>();
}
int test_main(int, char* [])
{
test_all<double>();
return 0;
}

2
test/algorithms/set_operations/difference/difference_multi.cpp
View File

@ -153,7 +153,7 @@ void test_areal()
TEST_DIFFERENCE_WITH(0, 1, issue_630_a, 0, expectation_limits(0.0), 1, (expectation_limits(2.023, 2.2004)), 1);
TEST_DIFFERENCE_WITH(0, 1, issue_630_b, 1, 0.0056089, 2, 1.498976, 3);
TEST_DIFFERENCE_WITH(0, 1, issue_630_c, 0, 0, 1, 1.493367, 1);
TEST_DIFFERENCE_WITH(0, 1, issue_643, 1, expectation_limits(76.5385), optional(), optional_sliver(1.0e-6), 2);
TEST_DIFFERENCE_WITH(0, 1, issue_643, 1, expectation_limits(76.5385), optional(), optional_sliver(1.0e-6), count_set(1, 2));
}
// Cases below go (or went) wrong in either a ( [0] - [1] ) or b ( [1] - [0] )

4
test/algorithms/set_operations/intersection/intersection_multi.cpp
View File

@ -166,7 +166,7 @@ void test_areal()
case_recursive_boxes_3[0], case_recursive_boxes_3[1],
19, 84, 12.5); // Area from SQL Server
TEST_INTERSECTION_IGNORE(case_recursive_boxes_4, 13, 158, 67.0);
TEST_INTERSECTION(case_recursive_boxes_4, 13, 158, 67.0);
// Fixed by replacing handle_tangencies in less_by_segment_ratio sort order
// Should contain 6 output polygons
@ -320,6 +320,8 @@ void test_areal()
TEST_INTERSECTION(case_recursive_boxes_86, 0, -1, 0.0);
TEST_INTERSECTION(case_recursive_boxes_87, 0, -1, 0.0);
TEST_INTERSECTION(case_recursive_boxes_88, 4, -1, 3.5);
TEST_INTERSECTION(case_recursive_boxes_89, 2, -1, 1.5);
TEST_INTERSECTION(case_recursive_boxes_90, 2, -1, 1.0);
TEST_INTERSECTION(case_precision_m1, 1, -1, 14.0);
TEST_INTERSECTION(case_precision_m2, 2, -1, 15.25);

14
test/algorithms/set_operations/set_ops_areal_areal.cpp
View File

@ -241,17 +241,19 @@ void test_all(std::string const& name, std::string const& wkt1, std::string cons
int test_main(int, char* [])
{
TEST_CASE_WITH(case_141_multi, 0, 1, ut_settings().ignore_reverse());
TEST_CASE(case_141_multi);
TEST_CASE(case_142_multi);
TEST_CASE(case_143_multi);
TEST_CASE(case_144_multi);
TEST_CASE(case_145_multi);
TEST_CASE_WITH(case_146_multi, 0, 1, ut_settings().ignore_validity_intersection());
TEST_CASE(case_146_multi);
TEST_CASE(case_147_multi);
TEST_CASE(case_148_multi);
TEST_CASE(case_149_multi);
TEST_CASE(case_150_multi);
TEST_CASE(case_151_multi);
TEST_CASE_WITH(issue_1221, 0, 1, ut_settings().ignore_validity_diff());
TEST_CASE(issue_1221);
TEST_CASE(issue_1222);
TEST_CASE_WITH(issue_1226, 0, 1, ut_settings().ignore_validity_diff());
@ -261,7 +263,7 @@ int test_main(int, char* [])
TEST_CASE_WITH(issue_1288, 0, 1, ut_settings().ignore_validity_diff());
TEST_CASE_WITH(issue_1288, 0, 2, ut_settings());
TEST_CASE(issue_1293);
TEST_CASE_WITH(issue_1295, 0, 1, ut_settings().ignore_validity_diff());
TEST_CASE(issue_1295);
TEST_CASE(issue_1299);
TEST_CASE(issue_1326);
@ -273,7 +275,7 @@ int test_main(int, char* [])
TEST_CASE_WITH(issue_1345_a, 1, 0, ut_settings());
TEST_CASE_WITH(issue_1345_b, 1, 0, ut_settings());
TEST_CASE_WITH(issue_1349, 0, 1, ut_settings().ignore_diff());
TEST_CASE(issue_1349);
TEST_CASE(issue_1349_inverse);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
@ -290,9 +292,7 @@ int test_main(int, char* [])
TEST_CASE(case_recursive_boxes_89);
TEST_CASE(case_recursive_boxes_90);
#if defined(BOOST_GEOMETRY_TEST_FAILURES)
TEST_CASE(case_recursive_boxes_91);
#endif
TEST_CASE(case_recursive_boxes_92);
TEST_CASE(case_recursive_boxes_93);
TEST_CASE(case_recursive_boxes_94);

2
test/algorithms/set_operations/union/union.cpp
View File

@ -471,12 +471,10 @@ void test_areal()
test_one<Polygon, Polygon, Polygon>("buffer_rt_a_rev", buffer_rt_a[1], buffer_rt_a[0],
1, 0, -1, 19.28, settings);
}
#if ! defined(BOOST_GEOMETRY_EXCLUDE)
test_one<Polygon, Polygon, Polygon>("buffer_rt_f", buffer_rt_f[0], buffer_rt_f[1],
1, 0, -1, 4.60853);
test_one<Polygon, Polygon, Polygon>("buffer_rt_f_rev", buffer_rt_f[1], buffer_rt_f[0],
1, 0, -1, 4.60853);
#endif
test_one<Polygon, Polygon, Polygon>("buffer_rt_g", buffer_rt_g[0], buffer_rt_g[1],
1, 0, -1, 16.571);
test_one<Polygon, Polygon, Polygon>("buffer_rt_g_rev", buffer_rt_g[1], buffer_rt_g[0],

11
test/algorithms/set_operations/union/union_multi.cpp
View File

@ -253,12 +253,11 @@ void test_areal()
case_recursive_boxes_14[0], case_recursive_boxes_14[1],
5, 0, -1, 4.5);
// 12, 13, 14 with invalid input. To make then valid it is necessary
// to break regions at self-intersection points (postponed)
TEST_UNION_IGNORE(case_recursive_boxes_12_invalid, 5, 0, -1, 6.0);
TEST_UNION_IGNORE(case_recursive_boxes_13_invalid, 2, 0, -1, 10.25);
TEST_UNION_IGNORE(case_recursive_boxes_14_invalid, 4, 0, -1, 4.5);
// 12, 13, 14 with invalid input. Since using biconnected components,
// the resulting union is valid and the number of output rings is correct.
TEST_UNION(case_recursive_boxes_12_invalid, 6, 0, -1, 6.0);
TEST_UNION(case_recursive_boxes_13_invalid, 3, 0, -1, 10.25);
TEST_UNION(case_recursive_boxes_14_invalid, 5, 0, -1, 4.5);
test_one<Polygon, MultiPolygon, MultiPolygon>("case_recursive_boxes_15",
case_recursive_boxes_15[0], case_recursive_boxes_15[1],

95
test/robustness/overlay/buffer/recursive_polygons_buffer.cpp
View File

@ -80,7 +80,7 @@ void create_svg(std::string const& filename
}
template <typename Geometry, typename Buffer>
bool verify_buffer(Geometry const& geometry, Buffer const& buffer, std::string& reason, bool check_validity)
bool verify_buffer(Geometry const& geometry, Buffer const& buffer, std::string& reason)
{
if (buffer.empty())
{
@ -101,66 +101,20 @@ bool verify_buffer(Geometry const& geometry, Buffer const& buffer, std::string&
bool all_within = true;
bg::for_each_point(geometry, [&all_within, &buffer](auto const& point)
{
if (! bg::within(point, buffer))
{
all_within = false;
if (! bg::within(point, buffer))
{
all_within = false;
}
}
});
);
if (! all_within)
{
reason = "Any input points are outside the buffer";
reason = "Not all points are within buffer";
return false;
}
return check_validity ? bg::is_valid(buffer, reason) : true;
}
template <typename Geometry, typename MultiPolygon, typename Settings>
bool verify(std::string const& caseid, Geometry const& geometry, MultiPolygon const& buffer, Settings const& settings)
{
std::string reason;
bool const result = verify_buffer(geometry, buffer, reason, settings.check_validity);
if (! result)
{
std::cout << caseid << " " << reason << std::endl;
}
bool svg = settings.svg;
bool wkt = settings.wkt;
if (! result)
{
// The result is wrong, override settings to create a SVG and WKT
svg = true;
wkt = true;
}
std::string filename;
{
// Generate a unique name
std::ostringstream out;
out << "rec_pol_buffer_" << geometry_to_crc(geometry)
<< "_" << string_from_type<typename bg::coordinate_type<MultiPolygon>::type>::name()
<< ".";
filename = out.str();
}
if (svg)
{
create_svg(filename + "svg", geometry, buffer);
}
if (wkt)
{
std::ofstream stream(filename + "wkt");
// Stream input WKT
stream << bg::wkt(geometry) << std::endl;
// If you need the output WKT, then stream bg::wkt(buffer)
}
return result;
return bg::is_valid(buffer, reason);
}
template <typename MultiPolygon, typename Generator, typename Settings>
@ -182,6 +136,7 @@ bool test_buffer(MultiPolygon& result, int& index,
}
else
{
// Recursive call
bg::correct(p);
bg::correct(q);
if (! test_buffer(p, index, generator, level - 1, settings)
@ -219,7 +174,7 @@ bool test_buffer(MultiPolygon& result, int& index,
bg::strategy::buffer::side_straight side_strategy;
bg::strategy::buffer::join_round join_round_strategy(settings.points_per_circle);
bg::strategy::buffer::join_miter join_miter_strategy;
try
{
switch(settings.join_code)
@ -245,7 +200,6 @@ bool test_buffer(MultiPolygon& result, int& index,
MultiPolygon empty;
std::cout << out.str() << std::endl;
std::cout << "Exception " << e.what() << std::endl;
verify(out.str(), mp, empty, settings);
return false;
}
@ -254,7 +208,34 @@ bool test_buffer(MultiPolygon& result, int& index,
std::cout << " [" << bg::area(mp) << " " << bg::area(buffered) << "]";
}
return verify(out.str(), mp, buffered, settings);
std::string verification_message;
if (verify_buffer(mp, buffered, verification_message))
{
if (settings.svg)
{
create_svg(out.str() + ".svg", mp, buffered);
}
return true;
}
std::string filename;
{
// Generate a unique name
std::ostringstream out;
out << "rec_pol_buffer_" << geometry_to_crc(mp)
<< "_" << string_from_type<typename bg::coordinate_type<MultiPolygon>::type>::name()
<< ".";
filename = out.str();
}
std::cout << "Failure" << " " << filename << " : " << verification_message << std::endl;
std::ofstream stream(filename + "wkt");
// Stream input WKT
stream << bg::wkt(mp) << std::endl;
// If you need the output WKT, then stream bg::wkt(buffer)
return false;
}