FM / overlay

/usr/include/boost/geometry/algorithms/detail/overlay/

/usr/include/boost/geometry/algorithms/detail/overlay

Name	Size	Mode	Actions
add_rings.hpp	5964	0644	edit dl rm
append_no_duplicates.hpp	2101	0644	edit dl rm
append_no_dups_or_spikes.hpp	7434	0644	edit dl rm
assign_parents.hpp	14577	0644	edit dl rm
backtrack_check_si.hpp	6371	0644	edit dl rm
check_enrich.hpp	5361	0644	edit dl rm
clip_linestring.hpp	8718	0644	edit dl rm
cluster_exits.hpp	7817	0644	edit dl rm
cluster_info.hpp	1010	0644	edit dl rm
convert_ring.hpp	3113	0644	edit dl rm
copy_segments.hpp	11481	0644	edit dl rm
copy_segment_point.hpp	11107	0644	edit dl rm
debug_turn_info.hpp	1947	0644	edit dl rm
do_reverse.hpp	1246	0644	edit dl rm
enrichment_info.hpp	2343	0644	edit dl rm
enrich_intersection_points.hpp	19008	0644	edit dl rm
follow.hpp	16907	0644	edit dl rm
follow_linear_linear.hpp	15711	0644	edit dl rm
get_distance_measure.hpp	5092	0644	edit dl rm
get_intersection_points.hpp	4265	0644	edit dl rm
get_relative_order.hpp	3260	0644	edit dl rm
get_ring.hpp	3700	0644	edit dl rm
get_turns.hpp	42078	0644	edit dl rm
get_turn_info.hpp	45746	0644	edit dl rm
get_turn_info_for_endpoint.hpp	25337	0644	edit dl rm
get_turn_info_helpers.hpp	19708	0644	edit dl rm
get_turn_info_la.hpp	34941	0644	edit dl rm
get_turn_info_ll.hpp	28380	0644	edit dl rm
handle_colocations.hpp	28604	0644	edit dl rm
handle_self_turns.hpp	9962	0644	edit dl rm
inconsistent_turns_exception.hpp	1043	0644	edit dl rm
intersection_box_box.hpp	2623	0644	edit dl rm
intersection_insert.hpp	47296	0644	edit dl rm
is_self_turn.hpp	1611	0644	edit dl rm
less_by_segment_ratio.hpp	6161	0644	edit dl rm
linear_linear.hpp	9562	0644	edit dl rm
needs_self_turns.hpp	1911	0644	edit dl rm
overlay.hpp	15706	0644	edit dl rm
overlay_type.hpp	1746	0644	edit dl rm
pointlike_areal.hpp	9593	0644	edit dl rm
pointlike_linear.hpp	11547	0644	edit dl rm
pointlike_pointlike.hpp	11878	0644	edit dl rm
range_in_geometry.hpp	5066	0644	edit dl rm
ring_properties.hpp	2135	0644	edit dl rm
segment_as_subrange.hpp	1488	0644	edit dl rm
segment_identifier.hpp	3555	0644	edit dl rm
select_rings.hpp	12362	0644	edit dl rm
self_turn_points.hpp	10814	0644	edit dl rm
sort_by_side.hpp	22216	0644	edit dl rm
stream_info.hpp	2383	0644	edit dl rm
traversal.hpp	34432	0644	edit dl rm
traversal_info.hpp	1469	0644	edit dl rm
traversal_ring_creator.hpp	15319	0644	edit dl rm
traversal_switch_detector.hpp	22642	0644	edit dl rm
traverse.hpp	3256	0644	edit dl rm
turn_info.hpp	4468	0644	edit dl rm
visit_info.hpp	2350	0644	edit dl rm

Edit: /usr/include/boost/geometry/algorithms/detail/overlay/pointlike_areal.hpp (9593B)

// Boost.Geometry (aka GGL, Generic Geometry Library)

// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle

// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html

#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_AREAL_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_AREAL_HPP

#include <vector>

#include <boost/range.hpp>

#include <boost/geometry/core/tags.hpp>

#include <boost/geometry/geometries/box.hpp>
#include <boost/geometry/geometries/point.hpp>

#include <boost/geometry/algorithms/disjoint.hpp>
#include <boost/geometry/algorithms/envelope.hpp>
#include <boost/geometry/algorithms/expand.hpp>
#include <boost/geometry/algorithms/not_implemented.hpp>

#include <boost/geometry/algorithms/detail/not.hpp>
#include <boost/geometry/algorithms/detail/partition.hpp>
#include <boost/geometry/algorithms/detail/disjoint/point_geometry.hpp>
#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>

#include <boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp>

namespace boost { namespace geometry
{

#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{

// difference/intersection of multipoint-multipolygon
template
<
    typename MultiPoint,
    typename MultiPolygon,
    typename PointOut,
    overlay_type OverlayType,
    typename Policy
>
class multipoint_multipolygon_point
{
private:
    template <typename ExpandPointStrategy>
    struct expand_box_point
    {
        template <typename Box, typename Point>
        static inline void apply(Box& total, Point const& point)
        {
            geometry::expand(total, point, ExpandPointStrategy());
        }
    };

template <typename ExpandBoxStrategy>
    struct expand_box_boxpair
    {
        template <typename Box1, typename Box2, typename SizeT>
        static inline void apply(Box1& total, std::pair<Box2, SizeT> const& box_pair)
        {
            geometry::expand(total, box_pair.first, ExpandBoxStrategy());
        }
    };

template <typename DisjointPointBoxStrategy>
    struct overlaps_box_point
    {
        template <typename Box, typename Point>
        static inline bool apply(Box const& box, Point const& point)
        {
            return ! geometry::disjoint(point, box, DisjointPointBoxStrategy());
        }
    };

template <typename DisjointBoxBoxStrategy>
    struct overlaps_box_boxpair
    {
        template <typename Box1, typename Box2, typename SizeT>
        static inline bool apply(Box1 const& box, std::pair<Box2, SizeT> const& box_pair)
        {
            return ! geometry::disjoint(box, box_pair.first, DisjointBoxBoxStrategy());
        }
    };

template <typename OutputIterator, typename Strategy>
    class item_visitor_type
    {
    public:
        item_visitor_type(MultiPolygon const& multipolygon,
                          OutputIterator& oit,
                          Strategy const& strategy)
            : m_multipolygon(multipolygon)
            , m_oit(oit)
            , m_strategy(strategy)
        {}

template <typename Point, typename Box, typename SizeT>
        inline bool apply(Point const& item1, std::pair<Box, SizeT> const& item2)
        {
            action_selector_pl
                <
                    PointOut, overlay_intersection
                >::apply(item1,
                         Policy::apply(item1,
                                       range::at(m_multipolygon,
                                                 item2.second),
                         m_strategy),
                         m_oit);

return true;
        }

private:
        MultiPolygon const& m_multipolygon;
        OutputIterator& m_oit;        
        Strategy const& m_strategy;
    };

template <typename Iterator, typename Box, typename SizeT, typename EnvelopeStrategy>
    static inline void fill_box_pairs(Iterator first, Iterator last,
                                      std::vector<std::pair<Box, SizeT> > & box_pairs,
                                      EnvelopeStrategy const& strategy)
    {
        SizeT index = 0;
        for (; first != last; ++first, ++index)
        {
            box_pairs.push_back(
                std::make_pair(geometry::return_envelope<Box>(*first, strategy),
                               index));
        }
    }

template <typename OutputIterator, typename Strategy>
    static inline OutputIterator get_common_points(MultiPoint const& multipoint,
                                                   MultiPolygon const& multipolygon,
                                                   OutputIterator oit,
                                                   Strategy const& strategy)
    {
        item_visitor_type<OutputIterator, Strategy> item_visitor(multipolygon, oit, strategy);

typedef geometry::model::point
            <
                typename geometry::coordinate_type<MultiPoint>::type,
                geometry::dimension<MultiPoint>::value,
                typename geometry::coordinate_system<MultiPoint>::type
            > point_type;
        typedef geometry::model::box<point_type> box_type;
        typedef std::pair<box_type, std::size_t> box_pair;
        std::vector<box_pair> box_pairs;
        box_pairs.reserve(boost::size(multipolygon));

fill_box_pairs(boost::begin(multipolygon),
                       boost::end(multipolygon),
                       box_pairs,
                       strategy.get_envelope_strategy());

typedef typename Strategy::envelope_strategy_type::box_expand_strategy_type expand_box_strategy_type;
        typedef typename Strategy::disjoint_box_box_strategy_type disjoint_box_box_strategy_type;
        typedef typename Strategy::disjoint_point_box_strategy_type disjoint_point_box_strategy_type;
        typedef typename Strategy::expand_point_strategy_type expand_point_strategy_type;

geometry::partition
            <
                box_type
            >::apply(multipoint, box_pairs, item_visitor,
                     expand_box_point<expand_point_strategy_type>(),
                     overlaps_box_point<disjoint_point_box_strategy_type>(),
                     expand_box_boxpair<expand_box_strategy_type>(),
                     overlaps_box_boxpair<disjoint_box_box_strategy_type>());

return oit;
    }

public:
    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
    static inline OutputIterator apply(MultiPoint const& multipoint,
                                       MultiPolygon const& multipolygon,
                                       RobustPolicy const& robust_policy,
                                       OutputIterator oit,
                                       Strategy const& strategy)
    {
        typedef std::vector
            <
                typename boost::range_value<MultiPoint>::type
            > point_vector_type;

point_vector_type common_points;

// compute the common points
        get_common_points(multipoint, multipolygon,
                          std::back_inserter(common_points),
                          strategy);

return multipoint_multipoint_point
            <
                MultiPoint, point_vector_type, PointOut, OverlayType
            >::apply(multipoint, common_points, robust_policy, oit, strategy);
    }
};

}} // namespace detail::overlay
#endif // DOXYGEN_NO_DISPATCH

#ifndef DOXYGEN_NO_DISPATCH
namespace detail_dispatch { namespace overlay
{

// dispatch struct for pointlike-areal difference/intersection computation
template
<
    typename PointLike,
    typename Areal,
    typename PointOut,
    overlay_type OverlayType,
    typename Tag1,
    typename Tag2
>
struct pointlike_areal_point
    : not_implemented<PointLike, Areal, PointOut>
{};

template
<
    typename Point,
    typename Areal,
    typename PointOut,
    overlay_type OverlayType,
    typename Tag2
>
struct pointlike_areal_point
    <
        Point, Areal, PointOut, OverlayType, point_tag, Tag2
    > : detail::overlay::point_single_point
        <
            Point, Areal, PointOut, OverlayType,
            detail::not_<detail::disjoint::reverse_covered_by>
        >
{};

// TODO: Consider implementing Areal-specific version
//   calculating envelope first in order to reject Points without
//   calling disjoint for Rings and Polygons
template
<
    typename MultiPoint,
    typename Areal,
    typename PointOut,
    overlay_type OverlayType,
    typename Tag2
>
struct pointlike_areal_point
    <
        MultiPoint, Areal, PointOut, OverlayType, multi_point_tag, Tag2
    > : detail::overlay::multipoint_single_point
        <
            MultiPoint, Areal, PointOut, OverlayType,
            detail::not_<detail::disjoint::reverse_covered_by>
        >
{};

template
<
    typename MultiPoint,
    typename MultiPolygon,
    typename PointOut,
    overlay_type OverlayType
>
struct pointlike_areal_point
    <
        MultiPoint, MultiPolygon, PointOut, OverlayType, multi_point_tag, multi_polygon_tag
    > : detail::overlay::multipoint_multipolygon_point
        <
            MultiPoint, MultiPolygon, PointOut, OverlayType,
            detail::not_<detail::disjoint::reverse_covered_by>
        >
{};

}} // namespace detail_dispatch::overlay
#endif // DOXYGEN_NO_DISPATCH

}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_AREAL_HPP

// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2020, Oracle and/or its affiliates. // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle // Licensed under the Boost Software License version 1.0. // http://www.boost.org/users/license.html #ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_AREAL_HPP #define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_AREAL_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace geometry { #ifndef DOXYGEN_NO_DETAIL namespace detail { namespace overlay { // difference/intersection of multipoint-multipolygon template < typename MultiPoint, typename MultiPolygon, typename PointOut, overlay_type OverlayType, typename Policy > class multipoint_multipolygon_point { private: template struct expand_box_point { template static inline void apply(Box& total, Point const& point) { geometry::expand(total, point, ExpandPointStrategy()); } }; template struct expand_box_boxpair { template static inline void apply(Box1& total, std::pair const& box_pair) { geometry::expand(total, box_pair.first, ExpandBoxStrategy()); } }; template struct overlaps_box_point { template static inline bool apply(Box const& box, Point const& point) { return ! geometry::disjoint(point, box, DisjointPointBoxStrategy()); } }; template struct overlaps_box_boxpair { template static inline bool apply(Box1 const& box, std::pair const& box_pair) { return ! geometry::disjoint(box, box_pair.first, DisjointBoxBoxStrategy()); } }; template class item_visitor_type { public: item_visitor_type(MultiPolygon const& multipolygon, OutputIterator& oit, Strategy const& strategy) : m_multipolygon(multipolygon) , m_oit(oit) , m_strategy(strategy) {} template inline bool apply(Point const& item1, std::pair const& item2) { action_selector_pl < PointOut, overlay_intersection >::apply(item1, Policy::apply(item1, range::at(m_multipolygon, item2.second), m_strategy), m_oit); return true; } private: MultiPolygon const& m_multipolygon; OutputIterator& m_oit; Strategy const& m_strategy; }; template static inline void fill_box_pairs(Iterator first, Iterator last, std::vector > & box_pairs, EnvelopeStrategy const& strategy) { SizeT index = 0; for (; first != last; ++first, ++index) { box_pairs.push_back( std::make_pair(geometry::return_envelope(*first, strategy), index)); } } template static inline OutputIterator get_common_points(MultiPoint const& multipoint, MultiPolygon const& multipolygon, OutputIterator oit, Strategy const& strategy) { item_visitor_type item_visitor(multipolygon, oit, strategy); typedef geometry::model::point < typename geometry::coordinate_type::type, geometry::dimension::value, typename geometry::coordinate_system::type > point_type; typedef geometry::model::box box_type; typedef std::pair box_pair; std::vector box_pairs; box_pairs.reserve(boost::size(multipolygon)); fill_box_pairs(boost::begin(multipolygon), boost::end(multipolygon), box_pairs, strategy.get_envelope_strategy()); typedef typename Strategy::envelope_strategy_type::box_expand_strategy_type expand_box_strategy_type; typedef typename Strategy::disjoint_box_box_strategy_type disjoint_box_box_strategy_type; typedef typename Strategy::disjoint_point_box_strategy_type disjoint_point_box_strategy_type; typedef typename Strategy::expand_point_strategy_type expand_point_strategy_type; geometry::partition < box_type >::apply(multipoint, box_pairs, item_visitor, expand_box_point(), overlaps_box_point(), expand_box_boxpair(), overlaps_box_boxpair()); return oit; } public: template static inline OutputIterator apply(MultiPoint const& multipoint, MultiPolygon const& multipolygon, RobustPolicy const& robust_policy, OutputIterator oit, Strategy const& strategy) { typedef std::vector < typename boost::range_value::type > point_vector_type; point_vector_type common_points; // compute the common points get_common_points(multipoint, multipolygon, std::back_inserter(common_points), strategy); return multipoint_multipoint_point < MultiPoint, point_vector_type, PointOut, OverlayType >::apply(multipoint, common_points, robust_policy, oit, strategy); } }; }} // namespace detail::overlay #endif // DOXYGEN_NO_DISPATCH #ifndef DOXYGEN_NO_DISPATCH namespace detail_dispatch { namespace overlay { // dispatch struct for pointlike-areal difference/intersection computation template < typename PointLike, typename Areal, typename PointOut, overlay_type OverlayType, typename Tag1, typename Tag2 > struct pointlike_areal_point : not_implemented {}; template < typename Point, typename Areal, typename PointOut, overlay_type OverlayType, typename Tag2 > struct pointlike_areal_point < Point, Areal, PointOut, OverlayType, point_tag, Tag2 > : detail::overlay::point_single_point < Point, Areal, PointOut, OverlayType, detail::not_ > {}; // TODO: Consider implementing Areal-specific version // calculating envelope first in order to reject Points without // calling disjoint for Rings and Polygons template < typename MultiPoint, typename Areal, typename PointOut, overlay_type OverlayType, typename Tag2 > struct pointlike_areal_point < MultiPoint, Areal, PointOut, OverlayType, multi_point_tag, Tag2 > : detail::overlay::multipoint_single_point < MultiPoint, Areal, PointOut, OverlayType, detail::not_ > {}; template < typename MultiPoint, typename MultiPolygon, typename PointOut, overlay_type OverlayType > struct pointlike_areal_point < MultiPoint, MultiPolygon, PointOut, OverlayType, multi_point_tag, multi_polygon_tag > : detail::overlay::multipoint_multipolygon_point < MultiPoint, MultiPolygon, PointOut, OverlayType, detail::not_ > {}; }} // namespace detail_dispatch::overlay #endif // DOXYGEN_NO_DISPATCH }} // namespace boost::geometry #endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_AREAL_HPP