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_linear.hpp (11547B)

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

// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
// 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_LINEAR_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_LINEAR_HPP

#include <iterator>
#include <vector>

#include <boost/range.hpp>

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

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

#include <boost/geometry/iterators/segment_iterator.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_pointlike.hpp>

namespace boost { namespace geometry
{

#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{

// difference/intersection of point-linear
template
<
    typename Point,
    typename Geometry,
    typename PointOut,
    overlay_type OverlayType,
    typename Policy
>
struct point_single_point
{
    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
    static inline OutputIterator apply(Point const& point,
                                       Geometry const& geometry,
                                       RobustPolicy const&,
                                       OutputIterator oit,
                                       Strategy const& strategy)
    {
        action_selector_pl
            <
                PointOut, OverlayType
            >::apply(point, Policy::apply(point, geometry, strategy), oit);
        return oit;
    }
};

// difference/intersection of multipoint-segment
template
<
    typename MultiPoint,
    typename Geometry,
    typename PointOut,
    overlay_type OverlayType,
    typename Policy
>
struct multipoint_single_point
{
    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
    static inline OutputIterator apply(MultiPoint const& multipoint,
                                       Geometry const& geometry,
                                       RobustPolicy const&,
                                       OutputIterator oit,
                                       Strategy const& strategy)
    {
        for (typename boost::range_iterator<MultiPoint const>::type
                 it = boost::begin(multipoint);
             it != boost::end(multipoint);
             ++it)
        {
            action_selector_pl
                <
                    PointOut, OverlayType
                >::apply(*it, Policy::apply(*it, geometry, strategy), oit);
        }

return oit;
    }
};

// difference/intersection of multipoint-linear
template
<
    typename MultiPoint,
    typename Linear,
    typename PointOut,
    overlay_type OverlayType,
    typename Policy
>
class multipoint_linear_point
{
private:
    // structs for partition -- start
    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 EnvelopeStrategy>
    struct expand_box_segment
    {
        explicit expand_box_segment(EnvelopeStrategy const& strategy)
            : m_strategy(strategy)
        {}

template <typename Box, typename Segment>
        inline void apply(Box& total, Segment const& segment) const
        {
            geometry::expand(total,
                             geometry::return_envelope<Box>(segment, m_strategy),
                             m_strategy.get_box_expand_strategy());
        }

EnvelopeStrategy const& m_strategy;
    };

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 DisjointStrategy>
    struct overlaps_box_segment
    {
        explicit overlaps_box_segment(DisjointStrategy const& strategy)
            : m_strategy(strategy)
        {}

template <typename Box, typename Segment>
        inline bool apply(Box const& box, Segment const& segment) const
        {
            return ! geometry::disjoint(segment, box, m_strategy);
        }

DisjointStrategy const& m_strategy;
    };

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

template <typename Item1, typename Item2>
        inline bool apply(Item1 const& item1, Item2 const& item2)
        {
            action_selector_pl
                <
                    PointOut, overlay_intersection
                >::apply(item1, Policy::apply(item1, item2, m_strategy), m_oit);

return true;
        }

private:
        OutputIterator& m_oit;
        Strategy const& m_strategy;
    };
    // structs for partition -- end

class segment_range
    {
    public:
        typedef geometry::segment_iterator<Linear const> const_iterator;
        typedef const_iterator iterator;

segment_range(Linear const& linear)
            : m_linear(linear)
        {}

const_iterator begin() const
        {
            return geometry::segments_begin(m_linear);
        }

const_iterator end() const
        {
            return geometry::segments_end(m_linear);
        }

private:
        Linear const& m_linear;
    };

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

typedef typename Strategy::envelope_strategy_type envelope_strategy_type;
        typedef typename Strategy::disjoint_strategy_type disjoint_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;

// TODO: disjoint Segment/Box may be called in partition multiple times
        // possibly for non-cartesian segments which could be slow. We should consider
        // passing a range of bounding boxes of segments after calculating them once.
        // Alternatively instead of a range of segments a range of Segment/Envelope pairs
        // should be passed, where envelope would be lazily calculated when needed the first time
        geometry::partition
            <
                geometry::model::box
                    <
                        typename boost::range_value<MultiPoint>::type
                    >
            >::apply(multipoint, segment_range(linear), item_visitor,
                     expand_box_point<expand_point_strategy_type>(),
                     overlaps_box_point<disjoint_point_box_strategy_type>(),
                     expand_box_segment<envelope_strategy_type>(strategy.get_envelope_strategy()),
                     overlaps_box_segment<disjoint_strategy_type>(strategy.get_disjoint_strategy()));

return oit;
    }

public:
    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
    static inline OutputIterator apply(MultiPoint const& multipoint,
                                       Linear const& linear,
                                       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, linear,
                          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_DETAIL

#ifndef DOXYGEN_NO_DISPATCH
namespace detail_dispatch { namespace overlay
{

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

template
<
    typename Point,
    typename Linear,
    typename PointOut,
    overlay_type OverlayType
>
struct pointlike_linear_point
    <
        Point, Linear, PointOut, OverlayType, point_tag, linear_tag
    > : detail::overlay::point_single_point
        <
            Point, Linear, PointOut, OverlayType,
            detail::not_<detail::disjoint::reverse_covered_by>
        >
{};

template
<
    typename Point,
    typename Segment,
    typename PointOut,
    overlay_type OverlayType
>
struct pointlike_linear_point
    <
        Point, Segment, PointOut, OverlayType, point_tag, segment_tag
    > : detail::overlay::point_single_point
        <
            Point, Segment, PointOut, OverlayType,
            detail::not_<detail::disjoint::reverse_covered_by>
        >
{};

template
<
    typename MultiPoint,
    typename Linear,
    typename PointOut,
    overlay_type OverlayType
>
struct pointlike_linear_point
    <
        MultiPoint, Linear, PointOut, OverlayType, multi_point_tag, linear_tag
    > : detail::overlay::multipoint_linear_point
        <
            MultiPoint, Linear, PointOut, OverlayType,
            detail::not_<detail::disjoint::reverse_covered_by>
        >
{};

template
<
    typename MultiPoint,
    typename Segment,
    typename PointOut,
    overlay_type OverlayType
>
struct pointlike_linear_point
    <
        MultiPoint, Segment, PointOut, OverlayType, multi_point_tag, segment_tag
    > : detail::overlay::multipoint_single_point
        <
            MultiPoint, Segment, 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_LINEAR_HPP

// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland. // Copyright (c) 2015-2020, Oracle and/or its affiliates. // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle // 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_LINEAR_HPP #define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_LINEAR_HPP #include #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 point-linear template < typename Point, typename Geometry, typename PointOut, overlay_type OverlayType, typename Policy > struct point_single_point { template static inline OutputIterator apply(Point const& point, Geometry const& geometry, RobustPolicy const&, OutputIterator oit, Strategy const& strategy) { action_selector_pl < PointOut, OverlayType >::apply(point, Policy::apply(point, geometry, strategy), oit); return oit; } }; // difference/intersection of multipoint-segment template < typename MultiPoint, typename Geometry, typename PointOut, overlay_type OverlayType, typename Policy > struct multipoint_single_point { template static inline OutputIterator apply(MultiPoint const& multipoint, Geometry const& geometry, RobustPolicy const&, OutputIterator oit, Strategy const& strategy) { for (typename boost::range_iterator::type it = boost::begin(multipoint); it != boost::end(multipoint); ++it) { action_selector_pl < PointOut, OverlayType >::apply(*it, Policy::apply(*it, geometry, strategy), oit); } return oit; } }; // difference/intersection of multipoint-linear template < typename MultiPoint, typename Linear, typename PointOut, overlay_type OverlayType, typename Policy > class multipoint_linear_point { private: // structs for partition -- start template struct expand_box_point { template static inline void apply(Box& total, Point const& point) { geometry::expand(total, point, ExpandPointStrategy()); } }; template struct expand_box_segment { explicit expand_box_segment(EnvelopeStrategy const& strategy) : m_strategy(strategy) {} template inline void apply(Box& total, Segment const& segment) const { geometry::expand(total, geometry::return_envelope(segment, m_strategy), m_strategy.get_box_expand_strategy()); } EnvelopeStrategy const& m_strategy; }; 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_segment { explicit overlaps_box_segment(DisjointStrategy const& strategy) : m_strategy(strategy) {} template inline bool apply(Box const& box, Segment const& segment) const { return ! geometry::disjoint(segment, box, m_strategy); } DisjointStrategy const& m_strategy; }; template class item_visitor_type { public: item_visitor_type(OutputIterator& oit, Strategy const& strategy) : m_oit(oit) , m_strategy(strategy) {} template inline bool apply(Item1 const& item1, Item2 const& item2) { action_selector_pl < PointOut, overlay_intersection >::apply(item1, Policy::apply(item1, item2, m_strategy), m_oit); return true; } private: OutputIterator& m_oit; Strategy const& m_strategy; }; // structs for partition -- end class segment_range { public: typedef geometry::segment_iterator const_iterator; typedef const_iterator iterator; segment_range(Linear const& linear) : m_linear(linear) {} const_iterator begin() const { return geometry::segments_begin(m_linear); } const_iterator end() const { return geometry::segments_end(m_linear); } private: Linear const& m_linear; }; template static inline OutputIterator get_common_points(MultiPoint const& multipoint, Linear const& linear, OutputIterator oit, Strategy const& strategy) { item_visitor_type item_visitor(oit, strategy); typedef typename Strategy::envelope_strategy_type envelope_strategy_type; typedef typename Strategy::disjoint_strategy_type disjoint_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; // TODO: disjoint Segment/Box may be called in partition multiple times // possibly for non-cartesian segments which could be slow. We should consider // passing a range of bounding boxes of segments after calculating them once. // Alternatively instead of a range of segments a range of Segment/Envelope pairs // should be passed, where envelope would be lazily calculated when needed the first time geometry::partition < geometry::model::box < typename boost::range_value::type > >::apply(multipoint, segment_range(linear), item_visitor, expand_box_point(), overlaps_box_point(), expand_box_segment(strategy.get_envelope_strategy()), overlaps_box_segment(strategy.get_disjoint_strategy())); return oit; } public: template static inline OutputIterator apply(MultiPoint const& multipoint, Linear const& linear, 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, linear, 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_DETAIL #ifndef DOXYGEN_NO_DISPATCH namespace detail_dispatch { namespace overlay { // dispatch struct for pointlike-linear difference/intersection computation template < typename PointLike, typename Linear, typename PointOut, overlay_type OverlayType, typename Tag1, typename Tag2 > struct pointlike_linear_point : not_implemented {}; template < typename Point, typename Linear, typename PointOut, overlay_type OverlayType > struct pointlike_linear_point < Point, Linear, PointOut, OverlayType, point_tag, linear_tag > : detail::overlay::point_single_point < Point, Linear, PointOut, OverlayType, detail::not_ > {}; template < typename Point, typename Segment, typename PointOut, overlay_type OverlayType > struct pointlike_linear_point < Point, Segment, PointOut, OverlayType, point_tag, segment_tag > : detail::overlay::point_single_point < Point, Segment, PointOut, OverlayType, detail::not_ > {}; template < typename MultiPoint, typename Linear, typename PointOut, overlay_type OverlayType > struct pointlike_linear_point < MultiPoint, Linear, PointOut, OverlayType, multi_point_tag, linear_tag > : detail::overlay::multipoint_linear_point < MultiPoint, Linear, PointOut, OverlayType, detail::not_ > {}; template < typename MultiPoint, typename Segment, typename PointOut, overlay_type OverlayType > struct pointlike_linear_point < MultiPoint, Segment, PointOut, OverlayType, multi_point_tag, segment_tag > : detail::overlay::multipoint_single_point < MultiPoint, Segment, PointOut, OverlayType, detail::not_ > {}; }} // namespace detail_dispatch::overlay #endif // DOXYGEN_NO_DISPATCH }} // namespace boost::geometry #endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_LINEAR_HPP