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/turn_info.hpp (4468B)

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

// 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_INFO_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TURN_INFO_HPP

#include <boost/array.hpp>

#include <boost/geometry/core/coordinate_type.hpp>
#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
#include <boost/geometry/policies/robustness/segment_ratio.hpp>

namespace boost { namespace geometry
{

#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace overlay
{

enum method_type
{
    method_none,
    method_disjoint,
    method_crosses,
    method_touch,
    method_touch_interior,
    method_collinear,
    method_equal,
    method_error
};

/*!
    \brief Turn operation: operation
    \details Information necessary for traversal phase (a phase
        of the overlay process). The information is gathered during the
        get_turns (segment intersection) phase.
        The class is to be included in the turn_info class, either direct
        or a derived or similar class with more (e.g. enrichment) information.
 */
template <typename Point, typename SegmentRatio>
struct turn_operation
{
    typedef SegmentRatio segment_ratio_type;

operation_type operation;
    segment_identifier seg_id;
    SegmentRatio fraction;

typedef typename coordinate_type<Point>::type comparable_distance_type;
    comparable_distance_type remaining_distance;

inline turn_operation()
        : operation(operation_none)
        , remaining_distance(0)
    {}
};

/*!
    \brief Turn information: intersection point, method, and turn information
    \details Information necessary for traversal phase (a phase
        of the overlay process). The information is gathered during the
        get_turns (segment intersection) phase.
    \tparam Point point type of intersection point
    \tparam Operation gives classes opportunity to add additional info
    \tparam Container gives classes opportunity to define how operations are stored
 */
template
<
    typename Point,
    typename SegmentRatio = geometry::segment_ratio<typename coordinate_type<Point>::type>,
    typename Operation = turn_operation<Point, SegmentRatio>,
    typename Container = boost::array<Operation, 2>
>
struct turn_info
{
    typedef Point point_type;
    typedef SegmentRatio segment_ratio_type;
    typedef Operation turn_operation_type;
    typedef Container container_type;

Point point;
    method_type method;
    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)

Container operations;

inline turn_info()
        : method(method_none)
        , touch_only(false)
        , cluster_id(-1)
        , discarded(false)
        , has_colocated_both(false)
    {}

inline bool both(operation_type type) const
    {
        return has12(type, type);
    }

inline bool has(operation_type type) const
    {
        return this->operations[0].operation == type
            || this->operations[1].operation == type;
    }

inline bool combination(operation_type type1, operation_type type2) const
    {
        return has12(type1, type2) || has12(type2, type1);
    }

inline bool blocked() const
    {
        return both(operation_blocked);
    }
    inline bool opposite() const
    {
        return both(operation_opposite);
    }
    inline bool any_blocked() const
    {
        return has(operation_blocked);
    }
    inline bool is_clustered() const
    {
        return cluster_id > 0;
    }

private :
    inline bool has12(operation_type type1, operation_type type2) const
    {
        return this->operations[0].operation == type1
            && this->operations[1].operation == type2
            ;
    }

};

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

}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TURN_INFO_HPP

cmd: