FM / detail

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

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

Name	Size	Mode	Actions
buffer/	-	0755	rm
centroid/	-	0755	rm
closest_feature/	-	0755	rm
comparable_distance/	-	0755	rm
covered_by/	-	0755	rm
disjoint/	-	0755	rm
distance/	-	0755	rm
envelope/	-	0755	rm
equals/	-	0755	rm
expand/	-	0755	rm
intersection/	-	0755	rm
intersects/	-	0755	rm
is_simple/	-	0755	rm
is_valid/	-	0755	rm
make/	-	0755	rm
overlaps/	-	0755	rm
overlay/	-	0755	rm
relate/	-	0755	rm
relation/	-	0755	rm
sections/	-	0755	rm
touches/	-	0755	rm
turns/	-	0755	rm
within/	-	0755	rm
assign_box_corners.hpp	3338	0644	edit dl rm
assign_indexed_point.hpp	2656	0644	edit dl rm
assign_values.hpp	8957	0644	edit dl rm
as_range.hpp	2688	0644	edit dl rm
azimuth.hpp	4802	0644	edit dl rm
calculate_null.hpp	1144	0644	edit dl rm
calculate_point_order.hpp	11145	0644	edit dl rm
calculate_sum.hpp	2047	0644	edit dl rm
check_iterator_range.hpp	2012	0644	edit dl rm
convert_indexed_to_indexed.hpp	2296	0644	edit dl rm
convert_point_to_point.hpp	2259	0644	edit dl rm
counting.hpp	2746	0644	edit dl rm
course.hpp	1180	0644	edit dl rm
direction_code.hpp	9205	0644	edit dl rm
expand_by_epsilon.hpp	3880	0644	edit dl rm
extreme_points.hpp	19767	0644	edit dl rm
for_each_range.hpp	4962	0644	edit dl rm
get_max_size.hpp	2054	0644	edit dl rm
has_self_intersections.hpp	5389	0644	edit dl rm
interior_iterator.hpp	1768	0644	edit dl rm
max_interval_gap.hpp	8430	0644	edit dl rm
multi_modify.hpp	1883	0644	edit dl rm
multi_modify_with_predicate.hpp	1442	0644	edit dl rm
multi_sum.hpp	1490	0644	edit dl rm
normalize.hpp	1296	0644	edit dl rm
not.hpp	2032	0644	edit dl rm
num_distinct_consecutive_points.hpp	2449	0644	edit dl rm
partition.hpp	29824	0644	edit dl rm
point_is_spike_or_equal.hpp	5455	0644	edit dl rm
point_on_border.hpp	5254	0644	edit dl rm
recalculate.hpp	6905	0644	edit dl rm
ring_identifier.hpp	2285	0644	edit dl rm
signed_size_type.hpp	770	0644	edit dl rm
single_geometry.hpp	2840	0644	edit dl rm
sub_range.hpp	4097	0644	edit dl rm
sweep.hpp	2086	0644	edit dl rm
throw_on_empty_input.hpp	2073	0644	edit dl rm
tupled_output.hpp	19235	0644	edit dl rm

Edit: /usr/include/boost/geometry/algorithms/detail/point_is_spike_or_equal.hpp (5455B)

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

// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.

// This file was modified by Oracle on 2015, 2017, 2019.
// Modifications copyright (c) 2015-2019 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

// 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_POINT_IS_EQUAL_OR_SPIKE_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_POINT_IS_EQUAL_OR_SPIKE_HPP

#include <boost/geometry/algorithms/detail/direction_code.hpp>
#include <boost/geometry/algorithms/detail/recalculate.hpp>
#include <boost/geometry/core/cs.hpp>
#include <boost/geometry/policies/robustness/robust_point_type.hpp>
#include <boost/geometry/strategies/side.hpp>
#include <boost/geometry/util/condition.hpp>
#include <boost/geometry/util/math.hpp>

namespace boost { namespace geometry
{

#ifndef DOXYGEN_NO_DETAIL
namespace detail
{

// Checks if a point ("last_point") causes a spike w.r.t.
// the specified two other points (segment_a, segment_b)
//
//  x-------x------x
//  a       lp     b
//
// Above, lp generates a spike w.r.t. segment(a,b)
// So specify last point first, then (a,b)
// The segment's orientation does matter: if lp is to the right of b
// no spike is reported
template
<
    typename Point1, typename Point2, typename Point3,
    typename SideStrategy
>
inline bool point_is_spike_or_equal(Point1 const& last_point, // prev | back
                                    Point2 const& segment_a,  // next | back - 2
                                    Point3 const& segment_b,  // curr | back - 1 | spike's vertex
                                    SideStrategy const& strategy)
{
    typedef typename SideStrategy::cs_tag cs_tag;

int const side = strategy.apply(segment_a, segment_b, last_point);
    if (side == 0)
    {
        // Last point is collinear w.r.t previous segment.
        return direction_code<cs_tag>(segment_a, segment_b, last_point) < 1;
    }
    return false;
}

template
<
    typename Point1,
    typename Point2,
    typename Point3,
    typename SideStrategy,
    typename RobustPolicy
>
inline bool point_is_spike_or_equal(Point1 const& last_point,
            Point2 const& segment_a,
            Point3 const& segment_b,
            SideStrategy const& strategy,
            RobustPolicy const& robust_policy)
{
    if (point_is_spike_or_equal(last_point, segment_a, segment_b, strategy))
    {
        return true;
    }

if (BOOST_GEOMETRY_CONDITION(! RobustPolicy::enabled))
    {
        return false;
    }

// Try using specified robust policy
    typedef typename geometry::robust_point_type
    <
        Point1,
        RobustPolicy
    >::type robust_point_type;

robust_point_type last_point_rob, segment_a_rob, segment_b_rob;
    geometry::recalculate(last_point_rob, last_point, robust_policy);
    geometry::recalculate(segment_a_rob, segment_a, robust_policy);
    geometry::recalculate(segment_b_rob, segment_b, robust_policy);

return point_is_spike_or_equal
        (
            last_point_rob,
            segment_a_rob,
            segment_b_rob,
            strategy
        );
}

template
<
    typename Point1,
    typename Point2,
    typename Point3,
    typename SideStrategy,
    typename RobustPolicy
>
inline bool point_is_collinear(Point1 const& last_point,
            Point2 const& segment_a,
            Point3 const& segment_b,
            SideStrategy const& strategy,
            RobustPolicy const& robust_policy)
{
    int const side = strategy.apply(segment_a, segment_b, last_point);
    if (side == 0)
    {
        return true;
    }

// This part (or whole method, because it is then trivial)
    // will be removed after rescaling
    if (BOOST_GEOMETRY_CONDITION(! RobustPolicy::enabled))
    {
        return false;
    }

// Redo, using specified robust policy
    typedef typename geometry::robust_point_type
    <
        Point1,
        RobustPolicy
    >::type robust_point_type;

int const side_rob = strategy.apply(segment_a_rob, segment_b_rob, last_point_rob);
    return side_rob == 0;
}

//! Version with intuitive order (A, B, C). The original order was
//! unclear (C, A, B). It was used in a different way in has_spikes.
//! On longer term the C,A,B version can be deprecated
template
<
    typename Point1,
    typename Point2,
    typename Point3,
    typename SideStrategy
>
inline bool is_spike_or_equal(Point1 const& a,
            Point2 const& b,
            Point3 const& c,
            SideStrategy const& strategy)
{
    return point_is_spike_or_equal(c, a, b, strategy);
}

} // namespace detail
#endif

}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_POINT_IS_EQUAL_OR_SPIKE_HPP

cmd: