update boost
This commit is contained in:
@@ -76,6 +76,11 @@ public :
|
||||
return m_left < 0 && m_right < 0;
|
||||
}
|
||||
|
||||
inline bool empty(buffer_side_selector side) const
|
||||
{
|
||||
return side == buffer_side_left ? m_left == 0 : m_right == 0;
|
||||
}
|
||||
|
||||
//! Returns the max distance distance up to the buffer will reach
|
||||
template <typename JoinStrategy, typename EndStrategy>
|
||||
inline NumericType max_distance(JoinStrategy const& join_strategy,
|
||||
|
||||
@@ -74,6 +74,11 @@ public :
|
||||
return m_distance < 0;
|
||||
}
|
||||
|
||||
inline bool empty(buffer_side_selector ) const
|
||||
{
|
||||
return m_distance == 0;
|
||||
}
|
||||
|
||||
//! Returns the max distance distance up to the buffer will reach
|
||||
template <typename JoinStrategy, typename EndStrategy>
|
||||
inline NumericType max_distance(JoinStrategy const& join_strategy,
|
||||
|
||||
@@ -1,386 +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 2014, 2018.
|
||||
// Modifications copyright (c) 2014, 2018 Oracle and/or its affiliates.
|
||||
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
|
||||
// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
|
||||
// (geolib/GGL), copyright (c) 1995-2010 Geodan, 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_STRATEGIES_AGNOSTIC_CONVEX_GRAHAM_ANDREW_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_CONVEX_GRAHAM_ANDREW_HPP
|
||||
|
||||
|
||||
#include <cstddef>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/range/begin.hpp>
|
||||
#include <boost/range/end.hpp>
|
||||
|
||||
#include <boost/geometry/algorithms/detail/for_each_range.hpp>
|
||||
#include <boost/geometry/core/assert.hpp>
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/core/point_type.hpp>
|
||||
#include <boost/geometry/policies/compare.hpp>
|
||||
#include <boost/geometry/strategies/convex_hull.hpp>
|
||||
#include <boost/geometry/strategies/side.hpp>
|
||||
#include <boost/geometry/views/detail/range_type.hpp>
|
||||
#include <boost/geometry/views/reversible_view.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace convex_hull
|
||||
{
|
||||
|
||||
#ifndef DOXYGEN_NO_DETAIL
|
||||
namespace detail
|
||||
{
|
||||
|
||||
|
||||
template
|
||||
<
|
||||
typename InputRange,
|
||||
typename RangeIterator,
|
||||
typename StrategyLess,
|
||||
typename StrategyGreater
|
||||
>
|
||||
struct get_extremes
|
||||
{
|
||||
typedef typename point_type<InputRange>::type point_type;
|
||||
|
||||
point_type left, right;
|
||||
|
||||
bool first;
|
||||
|
||||
StrategyLess less;
|
||||
StrategyGreater greater;
|
||||
|
||||
inline get_extremes()
|
||||
: first(true)
|
||||
{}
|
||||
|
||||
inline void apply(InputRange const& range)
|
||||
{
|
||||
if (boost::size(range) == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// First iterate through this range
|
||||
// (this two-stage approach avoids many point copies,
|
||||
// because iterators are kept in memory. Because iterators are
|
||||
// not persistent (in MSVC) this approach is not applicable
|
||||
// for more ranges together)
|
||||
|
||||
RangeIterator left_it = boost::begin(range);
|
||||
RangeIterator right_it = boost::begin(range);
|
||||
|
||||
for (RangeIterator it = boost::begin(range) + 1;
|
||||
it != boost::end(range);
|
||||
++it)
|
||||
{
|
||||
if (less(*it, *left_it))
|
||||
{
|
||||
left_it = it;
|
||||
}
|
||||
|
||||
if (greater(*it, *right_it))
|
||||
{
|
||||
right_it = it;
|
||||
}
|
||||
}
|
||||
|
||||
// Then compare with earlier
|
||||
if (first)
|
||||
{
|
||||
// First time, assign left/right
|
||||
left = *left_it;
|
||||
right = *right_it;
|
||||
first = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Next time, check if this range was left/right from
|
||||
// the extremes already collected
|
||||
if (less(*left_it, left))
|
||||
{
|
||||
left = *left_it;
|
||||
}
|
||||
|
||||
if (greater(*right_it, right))
|
||||
{
|
||||
right = *right_it;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template
|
||||
<
|
||||
typename InputRange,
|
||||
typename RangeIterator,
|
||||
typename Container,
|
||||
typename SideStrategy
|
||||
>
|
||||
struct assign_range
|
||||
{
|
||||
Container lower_points, upper_points;
|
||||
|
||||
typedef typename point_type<InputRange>::type point_type;
|
||||
|
||||
point_type const& most_left;
|
||||
point_type const& most_right;
|
||||
|
||||
inline assign_range(point_type const& left, point_type const& right)
|
||||
: most_left(left)
|
||||
, most_right(right)
|
||||
{}
|
||||
|
||||
inline void apply(InputRange const& range)
|
||||
{
|
||||
typedef SideStrategy side;
|
||||
|
||||
// Put points in one of the two output sequences
|
||||
for (RangeIterator it = boost::begin(range);
|
||||
it != boost::end(range);
|
||||
++it)
|
||||
{
|
||||
// check if it is lying most_left or most_right from the line
|
||||
|
||||
int dir = side::apply(most_left, most_right, *it);
|
||||
switch(dir)
|
||||
{
|
||||
case 1 : // left side
|
||||
upper_points.push_back(*it);
|
||||
break;
|
||||
case -1 : // right side
|
||||
lower_points.push_back(*it);
|
||||
break;
|
||||
|
||||
// 0: on line most_left-most_right,
|
||||
// or most_left, or most_right,
|
||||
// -> all never part of hull
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Range>
|
||||
static inline void sort(Range& range)
|
||||
{
|
||||
typedef typename boost::range_value<Range>::type point_type;
|
||||
typedef geometry::less<point_type> comparator;
|
||||
|
||||
std::sort(boost::begin(range), boost::end(range), comparator());
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
#endif // DOXYGEN_NO_DETAIL
|
||||
|
||||
|
||||
/*!
|
||||
\brief Graham scan strategy to calculate convex hull
|
||||
\ingroup strategies
|
||||
*/
|
||||
template <typename InputGeometry, typename OutputPoint>
|
||||
class graham_andrew
|
||||
{
|
||||
public :
|
||||
typedef OutputPoint point_type;
|
||||
typedef InputGeometry geometry_type;
|
||||
|
||||
private:
|
||||
|
||||
typedef typename cs_tag<point_type>::type cs_tag;
|
||||
|
||||
typedef typename std::vector<point_type> container_type;
|
||||
typedef typename std::vector<point_type>::const_iterator iterator;
|
||||
typedef typename std::vector<point_type>::const_reverse_iterator rev_iterator;
|
||||
|
||||
|
||||
class partitions
|
||||
{
|
||||
friend class graham_andrew;
|
||||
|
||||
container_type m_lower_hull;
|
||||
container_type m_upper_hull;
|
||||
container_type m_copied_input;
|
||||
};
|
||||
|
||||
|
||||
public:
|
||||
typedef partitions state_type;
|
||||
|
||||
|
||||
inline void apply(InputGeometry const& geometry, partitions& state) const
|
||||
{
|
||||
// First pass.
|
||||
// Get min/max (in most cases left / right) points
|
||||
// This makes use of the geometry::less/greater predicates
|
||||
|
||||
// For the left boundary it is important that multiple points
|
||||
// are sorted from bottom to top. Therefore the less predicate
|
||||
// does not take the x-only template parameter (this fixes ticket #6019.
|
||||
// For the right boundary it is not necessary (though also not harmful),
|
||||
// because points are sorted from bottom to top in a later stage.
|
||||
// For symmetry and to get often more balanced lower/upper halves
|
||||
// we keep it.
|
||||
|
||||
typedef typename geometry::detail::range_type<InputGeometry>::type range_type;
|
||||
|
||||
typedef typename boost::range_iterator
|
||||
<
|
||||
range_type const
|
||||
>::type range_iterator;
|
||||
|
||||
detail::get_extremes
|
||||
<
|
||||
range_type,
|
||||
range_iterator,
|
||||
geometry::less<point_type>,
|
||||
geometry::greater<point_type>
|
||||
> extremes;
|
||||
geometry::detail::for_each_range(geometry, extremes);
|
||||
|
||||
// Bounding left/right points
|
||||
// Second pass, now that extremes are found, assign all points
|
||||
// in either lower, either upper
|
||||
detail::assign_range
|
||||
<
|
||||
range_type,
|
||||
range_iterator,
|
||||
container_type,
|
||||
typename strategy::side::services::default_strategy<cs_tag>::type
|
||||
> assigner(extremes.left, extremes.right);
|
||||
|
||||
geometry::detail::for_each_range(geometry, assigner);
|
||||
|
||||
|
||||
// Sort both collections, first on x(, then on y)
|
||||
detail::sort(assigner.lower_points);
|
||||
detail::sort(assigner.upper_points);
|
||||
|
||||
//std::cout << boost::size(assigner.lower_points) << std::endl;
|
||||
//std::cout << boost::size(assigner.upper_points) << std::endl;
|
||||
|
||||
// And decide which point should be in the final hull
|
||||
build_half_hull<-1>(assigner.lower_points, state.m_lower_hull,
|
||||
extremes.left, extremes.right);
|
||||
build_half_hull<1>(assigner.upper_points, state.m_upper_hull,
|
||||
extremes.left, extremes.right);
|
||||
}
|
||||
|
||||
|
||||
template <typename OutputIterator>
|
||||
inline void result(partitions const& state,
|
||||
OutputIterator out,
|
||||
bool clockwise,
|
||||
bool closed) const
|
||||
{
|
||||
if (clockwise)
|
||||
{
|
||||
output_ranges(state.m_upper_hull, state.m_lower_hull, out, closed);
|
||||
}
|
||||
else
|
||||
{
|
||||
output_ranges(state.m_lower_hull, state.m_upper_hull, out, closed);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
template <int Factor>
|
||||
static inline void build_half_hull(container_type const& input,
|
||||
container_type& output,
|
||||
point_type const& left, point_type const& right)
|
||||
{
|
||||
output.push_back(left);
|
||||
for(iterator it = input.begin(); it != input.end(); ++it)
|
||||
{
|
||||
add_to_hull<Factor>(*it, output);
|
||||
}
|
||||
add_to_hull<Factor>(right, output);
|
||||
}
|
||||
|
||||
|
||||
template <int Factor>
|
||||
static inline void add_to_hull(point_type const& p, container_type& output)
|
||||
{
|
||||
typedef typename strategy::side::services::default_strategy<cs_tag>::type side;
|
||||
|
||||
output.push_back(p);
|
||||
std::size_t output_size = output.size();
|
||||
while (output_size >= 3)
|
||||
{
|
||||
rev_iterator rit = output.rbegin();
|
||||
point_type const last = *rit++;
|
||||
point_type const& last2 = *rit++;
|
||||
|
||||
if (Factor * side::apply(*rit, last, last2) <= 0)
|
||||
{
|
||||
// Remove last two points from stack, and add last again
|
||||
// This is much faster then erasing the one but last.
|
||||
output.pop_back();
|
||||
output.pop_back();
|
||||
output.push_back(last);
|
||||
output_size--;
|
||||
}
|
||||
else
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <typename OutputIterator>
|
||||
static inline void output_ranges(container_type const& first, container_type const& second,
|
||||
OutputIterator out, bool closed)
|
||||
{
|
||||
std::copy(boost::begin(first), boost::end(first), out);
|
||||
|
||||
BOOST_GEOMETRY_ASSERT(closed ? !boost::empty(second) : boost::size(second) > 1);
|
||||
std::copy(++boost::rbegin(second), // skip the first Point
|
||||
closed ? boost::rend(second) : --boost::rend(second), // skip the last Point if open
|
||||
out);
|
||||
|
||||
typedef typename boost::range_size<container_type>::type size_type;
|
||||
size_type const count = boost::size(first) + boost::size(second) - 1;
|
||||
// count describes a closed case but comparison with min size of closed
|
||||
// gives the result compatible also with open
|
||||
// here core_detail::closure::minimum_ring_size<closed> could be used
|
||||
if (count < 4)
|
||||
{
|
||||
// there should be only one missing
|
||||
*out++ = *boost::begin(first);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace strategy::convex_hull
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
|
||||
template <typename InputGeometry, typename OutputPoint>
|
||||
struct strategy_convex_hull<InputGeometry, OutputPoint, cartesian_tag>
|
||||
{
|
||||
typedef strategy::convex_hull::graham_andrew<InputGeometry, OutputPoint> type;
|
||||
};
|
||||
#endif
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_CONVEX_GRAHAM_ANDREW_HPP
|
||||
@@ -3,9 +3,10 @@
|
||||
// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
|
||||
// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
|
||||
// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
|
||||
// Copyright (c) 2023 Adam Wulkiewicz, Lodz, Poland.
|
||||
|
||||
// This file was modified by Oracle on 2018.
|
||||
// Modifications copyright (c) 2018 Oracle and/or its affiliates.
|
||||
// This file was modified by Oracle on 2018-2020.
|
||||
// Modifications copyright (c) 2018-2020 Oracle and/or its affiliates.
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
|
||||
// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
|
||||
@@ -18,13 +19,17 @@
|
||||
#ifndef BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <array>
|
||||
|
||||
#include <boost/core/ignore_unused.hpp>
|
||||
|
||||
#include <boost/geometry/algorithms/assign.hpp>
|
||||
#include <boost/geometry/core/access.hpp>
|
||||
#include <boost/geometry/core/coordinate_dimension.hpp>
|
||||
#include <boost/geometry/algorithms/assign.hpp>
|
||||
#include <boost/geometry/strategies/covered_by.hpp>
|
||||
#include <boost/geometry/strategies/geographic/side.hpp>
|
||||
#include <boost/geometry/strategies/side.hpp>
|
||||
#include <boost/geometry/strategies/spherical/ssf.hpp>
|
||||
#include <boost/geometry/strategies/within.hpp>
|
||||
|
||||
|
||||
@@ -34,6 +39,10 @@ namespace boost { namespace geometry { namespace strategy
|
||||
namespace within
|
||||
{
|
||||
|
||||
#ifndef DOXYGEN_NO_DETAIL
|
||||
namespace detail
|
||||
{
|
||||
|
||||
struct decide_within
|
||||
{
|
||||
static inline bool apply(int side, bool& result)
|
||||
@@ -65,45 +74,186 @@ struct decide_covered_by
|
||||
// This strategy is not suitable for boxes in non-cartesian CSes having edges
|
||||
// longer than 180deg because e.g. the SSF formula picks the side of the closer
|
||||
// longitude, so for long edges the side is the opposite.
|
||||
template <typename Decide = decide_within>
|
||||
struct point_in_box_by_side
|
||||
// Actually it is not suitable for shorter edges either because the edges of
|
||||
// boxes are defined by meridians and parallels, not great circles or geodesics.
|
||||
template <typename Decide, typename Point, typename Box, typename Strategy>
|
||||
inline bool point_in_box_by_side(Point const& point, Box const& box,
|
||||
Strategy const& strategy)
|
||||
{
|
||||
boost::ignore_unused(strategy);
|
||||
|
||||
// Create (counterclockwise) array of points, the fifth one closes it
|
||||
// Every point should be on the LEFT side (=1), or ON the border (=0),
|
||||
// So >= 1 or >= 0
|
||||
std::array<typename point_type<Box>::type, 5> bp;
|
||||
geometry::detail::assign_box_corners_oriented<true>(box, bp);
|
||||
bp[4] = bp[0];
|
||||
|
||||
bool result = true;
|
||||
for (int i = 1; i < 5; i++)
|
||||
{
|
||||
int const side = strategy.apply(point, bp[i - 1], bp[i]);
|
||||
if (! Decide::apply(side, result))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
} // namespace detail
|
||||
#endif // DOXYGEN_NO_DETAIL
|
||||
|
||||
|
||||
// There should probably be another category of geometry different than box,
|
||||
// e.g. rectangle or convex_ring. This strategy should probably be an
|
||||
// algorithm calling side strategy.
|
||||
|
||||
template <typename CalculationType = void>
|
||||
struct cartesian_point_box_by_side
|
||||
{
|
||||
template <typename Point, typename Box>
|
||||
static inline bool apply(Point const& point, Box const& box)
|
||||
{
|
||||
typedef typename strategy::side::services::default_strategy
|
||||
using side_strategy_type
|
||||
= typename strategy::side::services::default_strategy
|
||||
<cartesian_tag, CalculationType>::type;
|
||||
|
||||
return within::detail::point_in_box_by_side
|
||||
<
|
||||
typename cs_tag<Box>::type
|
||||
>::type side_strategy_type;
|
||||
|
||||
// Create (counterclockwise) array of points, the fifth one closes it
|
||||
// Every point should be on the LEFT side (=1), or ON the border (=0),
|
||||
// So >= 1 or >= 0
|
||||
boost::array<typename point_type<Box>::type, 5> bp;
|
||||
geometry::detail::assign_box_corners_oriented<true>(box, bp);
|
||||
bp[4] = bp[0];
|
||||
|
||||
bool result = true;
|
||||
side_strategy_type strategy;
|
||||
boost::ignore_unused(strategy);
|
||||
|
||||
for (int i = 1; i < 5; i++)
|
||||
{
|
||||
int const side = strategy.apply(point, bp[i - 1], bp[i]);
|
||||
if (! Decide::apply(side, result))
|
||||
{
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
within::detail::decide_within
|
||||
>(point, box, side_strategy_type());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename CalculationType = void>
|
||||
struct spherical_point_box_by_side
|
||||
{
|
||||
template <typename Point, typename Box>
|
||||
static inline bool apply(Point const& point, Box const& box)
|
||||
{
|
||||
return within::detail::point_in_box_by_side
|
||||
<
|
||||
within::detail::decide_within
|
||||
>(point, box,
|
||||
strategy::side::spherical_side_formula<CalculationType>());
|
||||
}
|
||||
};
|
||||
|
||||
template
|
||||
<
|
||||
typename FormulaPolicy = strategy::andoyer,
|
||||
typename Spheroid = srs::spheroid<double>,
|
||||
typename CalculationType = void
|
||||
>
|
||||
struct geographic_point_box_by_side
|
||||
{
|
||||
geographic_point_box_by_side() = default;
|
||||
|
||||
explicit geographic_point_box_by_side(Spheroid const& spheroid)
|
||||
: m_side(spheroid)
|
||||
{}
|
||||
|
||||
template <typename Point, typename Box>
|
||||
bool apply(Point const& point, Box const& box) const
|
||||
{
|
||||
return within::detail::point_in_box_by_side
|
||||
<
|
||||
within::detail::decide_within
|
||||
>(point, box, m_side);
|
||||
}
|
||||
|
||||
Spheroid const& model() const
|
||||
{
|
||||
return m_side.model();
|
||||
}
|
||||
|
||||
private:
|
||||
strategy::side::geographic
|
||||
<
|
||||
FormulaPolicy, Spheroid, CalculationType
|
||||
> m_side;
|
||||
};
|
||||
|
||||
|
||||
} // namespace within
|
||||
|
||||
|
||||
namespace covered_by
|
||||
{
|
||||
|
||||
|
||||
template <typename CalculationType = void>
|
||||
struct cartesian_point_box_by_side
|
||||
{
|
||||
template <typename Point, typename Box>
|
||||
static bool apply(Point const& point, Box const& box)
|
||||
{
|
||||
using side_strategy_type
|
||||
= typename strategy::side::services::default_strategy
|
||||
<cartesian_tag, CalculationType>::type;
|
||||
return within::detail::point_in_box_by_side
|
||||
<
|
||||
within::detail::decide_covered_by
|
||||
>(point, box, side_strategy_type());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename CalculationType = void>
|
||||
struct spherical_point_box_by_side
|
||||
{
|
||||
template <typename Point, typename Box>
|
||||
static bool apply(Point const& point, Box const& box)
|
||||
{
|
||||
return within::detail::point_in_box_by_side
|
||||
<
|
||||
within::detail::decide_covered_by
|
||||
>(point, box,
|
||||
strategy::side::spherical_side_formula<CalculationType>());
|
||||
}
|
||||
};
|
||||
|
||||
template
|
||||
<
|
||||
typename FormulaPolicy = strategy::andoyer,
|
||||
typename Spheroid = srs::spheroid<double>,
|
||||
typename CalculationType = void
|
||||
>
|
||||
struct geographic_point_box_by_side
|
||||
{
|
||||
geographic_point_box_by_side() = default;
|
||||
|
||||
explicit geographic_point_box_by_side(Spheroid const& spheroid)
|
||||
: m_side(spheroid)
|
||||
{}
|
||||
|
||||
template <typename Point, typename Box>
|
||||
bool apply(Point const& point, Box const& box) const
|
||||
{
|
||||
return within::detail::point_in_box_by_side
|
||||
<
|
||||
within::detail::decide_covered_by
|
||||
>(point, box, m_side);
|
||||
}
|
||||
|
||||
Spheroid const& model() const
|
||||
{
|
||||
return m_side.model();
|
||||
}
|
||||
|
||||
private:
|
||||
strategy::side::geographic
|
||||
<
|
||||
FormulaPolicy, Spheroid, CalculationType
|
||||
> m_side;
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
}}} // namespace boost::geometry::strategy
|
||||
|
||||
|
||||
|
||||
@@ -3,8 +3,8 @@
|
||||
// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
|
||||
// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
|
||||
|
||||
// This file was modified by Oracle on 2013, 2014, 2016, 2017.
|
||||
// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
|
||||
// This file was modified by Oracle on 2013-2020.
|
||||
// Modifications copyright (c) 2013-2020 Oracle and/or its affiliates.
|
||||
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
|
||||
|
||||
// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
|
||||
@@ -18,9 +18,8 @@
|
||||
#define BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_WINDING_HPP
|
||||
|
||||
|
||||
#include <boost/mpl/assert.hpp>
|
||||
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/core/static_assert.hpp>
|
||||
#include <boost/geometry/core/tag_cast.hpp>
|
||||
#include <boost/geometry/core/tags.hpp>
|
||||
|
||||
@@ -54,30 +53,35 @@ template
|
||||
>
|
||||
struct winding_base_type
|
||||
{
|
||||
BOOST_MPL_ASSERT_MSG(false,
|
||||
NOT_IMPLEMENTED_FOR_THIS_COORDINATE_SYSTEM,
|
||||
(CSTag));
|
||||
BOOST_GEOMETRY_STATIC_ASSERT_FALSE(
|
||||
"Not implemented for this coordinate system.",
|
||||
Point, PointOfSegment, CSTag);
|
||||
};
|
||||
|
||||
template <typename Point, typename PointOfSegment, typename CalculationType>
|
||||
struct winding_base_type<Point, PointOfSegment, CalculationType, cartesian_tag>
|
||||
{
|
||||
typedef within::cartesian_winding<Point, PointOfSegment, CalculationType> type;
|
||||
};
|
||||
|
||||
template <typename Point, typename PointOfSegment, typename CalculationType>
|
||||
struct winding_base_type<Point, PointOfSegment, CalculationType, spherical_tag>
|
||||
{
|
||||
typedef within::detail::spherical_winding_base
|
||||
using type = within::detail::cartesian_winding_base
|
||||
<
|
||||
Point,
|
||||
PointOfSegment,
|
||||
typename strategy::side::services::default_strategy
|
||||
<
|
||||
typename cs_tag<Point>::type
|
||||
>::type,
|
||||
CalculationType
|
||||
> type;
|
||||
>;
|
||||
};
|
||||
|
||||
template <typename Point, typename PointOfSegment, typename CalculationType>
|
||||
struct winding_base_type<Point, PointOfSegment, CalculationType, spherical_tag>
|
||||
{
|
||||
using type = within::detail::spherical_winding_base
|
||||
<
|
||||
typename strategy::side::services::default_strategy
|
||||
<
|
||||
typename cs_tag<Point>::type
|
||||
>::type,
|
||||
CalculationType
|
||||
>;
|
||||
};
|
||||
|
||||
|
||||
|
||||
@@ -3,10 +3,10 @@
|
||||
// Copyright (c) 1995, 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
|
||||
// Copyright (c) 1995 Maarten Hilferink, Amsterdam, the Netherlands
|
||||
|
||||
// This file was modified by Oracle on 2015.
|
||||
// Modifications copyright (c) 2015, Oracle and/or its affiliates.
|
||||
|
||||
// This file was modified by Oracle on 2015-2021.
|
||||
// Modifications copyright (c) 2015-2021, 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
|
||||
|
||||
// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
|
||||
// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
|
||||
@@ -19,23 +19,9 @@
|
||||
#define BOOST_GEOMETRY_STRATEGY_AGNOSTIC_SIMPLIFY_DOUGLAS_PEUCKER_HPP
|
||||
|
||||
|
||||
#include <cstddef>
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
|
||||
#include <iostream>
|
||||
#endif
|
||||
#include <vector>
|
||||
|
||||
#include <boost/range.hpp>
|
||||
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/strategies/distance.hpp>
|
||||
|
||||
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
|
||||
#include <boost/geometry/io/dsv/write.hpp>
|
||||
#endif
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
@@ -43,202 +29,7 @@ namespace strategy { namespace simplify
|
||||
{
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_DETAIL
|
||||
namespace detail
|
||||
{
|
||||
|
||||
/*!
|
||||
\brief Small wrapper around a point, with an extra member "included"
|
||||
\details
|
||||
It has a const-reference to the original point (so no copy here)
|
||||
\tparam the enclosed point type
|
||||
*/
|
||||
template<typename Point>
|
||||
struct douglas_peucker_point
|
||||
{
|
||||
Point const& p;
|
||||
bool included;
|
||||
|
||||
inline douglas_peucker_point(Point const& ap)
|
||||
: p(ap)
|
||||
, included(false)
|
||||
{}
|
||||
|
||||
// Necessary for proper compilation
|
||||
inline douglas_peucker_point<Point> operator=(douglas_peucker_point<Point> const& )
|
||||
{
|
||||
return douglas_peucker_point<Point>(*this);
|
||||
}
|
||||
};
|
||||
|
||||
template
|
||||
<
|
||||
typename Point,
|
||||
typename PointDistanceStrategy,
|
||||
typename LessCompare
|
||||
= std::less
|
||||
<
|
||||
typename strategy::distance::services::return_type
|
||||
<
|
||||
PointDistanceStrategy,
|
||||
Point, Point
|
||||
>::type
|
||||
>
|
||||
>
|
||||
class douglas_peucker
|
||||
: LessCompare // for empty base optimization
|
||||
{
|
||||
public :
|
||||
|
||||
// See also ticket 5954 https://svn.boost.org/trac/boost/ticket/5954
|
||||
// Comparable is currently not possible here because it has to be compared to the squared of max_distance, and more.
|
||||
// For now we have to take the real distance.
|
||||
typedef PointDistanceStrategy distance_strategy_type;
|
||||
// typedef typename strategy::distance::services::comparable_type<PointDistanceStrategy>::type distance_strategy_type;
|
||||
|
||||
typedef typename strategy::distance::services::return_type
|
||||
<
|
||||
distance_strategy_type,
|
||||
Point, Point
|
||||
>::type distance_type;
|
||||
|
||||
douglas_peucker()
|
||||
{}
|
||||
|
||||
douglas_peucker(LessCompare const& less_compare)
|
||||
: LessCompare(less_compare)
|
||||
{}
|
||||
|
||||
private :
|
||||
typedef detail::douglas_peucker_point<Point> dp_point_type;
|
||||
typedef typename std::vector<dp_point_type>::iterator iterator_type;
|
||||
|
||||
|
||||
LessCompare const& less() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline void consider(iterator_type begin,
|
||||
iterator_type end,
|
||||
distance_type const& max_dist,
|
||||
int& n,
|
||||
distance_strategy_type const& ps_distance_strategy) const
|
||||
{
|
||||
std::size_t size = end - begin;
|
||||
|
||||
// size must be at least 3
|
||||
// because we want to consider a candidate point in between
|
||||
if (size <= 2)
|
||||
{
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
|
||||
if (begin != end)
|
||||
{
|
||||
std::cout << "ignore between " << dsv(begin->p)
|
||||
<< " and " << dsv((end - 1)->p)
|
||||
<< " size=" << size << std::endl;
|
||||
}
|
||||
std::cout << "return because size=" << size << std::endl;
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
||||
iterator_type last = end - 1;
|
||||
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
|
||||
std::cout << "find between " << dsv(begin->p)
|
||||
<< " and " << dsv(last->p)
|
||||
<< " size=" << size << std::endl;
|
||||
#endif
|
||||
|
||||
|
||||
// Find most far point, compare to the current segment
|
||||
//geometry::segment<Point const> s(begin->p, last->p);
|
||||
distance_type md(-1.0); // any value < 0
|
||||
iterator_type candidate;
|
||||
for(iterator_type it = begin + 1; it != last; ++it)
|
||||
{
|
||||
distance_type dist = ps_distance_strategy.apply(it->p, begin->p, last->p);
|
||||
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
|
||||
std::cout << "consider " << dsv(it->p)
|
||||
<< " at " << double(dist)
|
||||
<< ((dist > max_dist) ? " maybe" : " no")
|
||||
<< std::endl;
|
||||
|
||||
#endif
|
||||
if ( less()(md, dist) )
|
||||
{
|
||||
md = dist;
|
||||
candidate = it;
|
||||
}
|
||||
}
|
||||
|
||||
// If a point is found, set the include flag
|
||||
// and handle segments in between recursively
|
||||
if ( less()(max_dist, md) )
|
||||
{
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
|
||||
std::cout << "use " << dsv(candidate->p) << std::endl;
|
||||
#endif
|
||||
|
||||
candidate->included = true;
|
||||
n++;
|
||||
|
||||
consider(begin, candidate + 1, max_dist, n, ps_distance_strategy);
|
||||
consider(candidate, end, max_dist, n, ps_distance_strategy);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public :
|
||||
|
||||
template <typename Range, typename OutputIterator>
|
||||
inline OutputIterator apply(Range const& range,
|
||||
OutputIterator out,
|
||||
distance_type max_distance) const
|
||||
{
|
||||
#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
|
||||
std::cout << "max distance: " << max_distance
|
||||
<< std::endl << std::endl;
|
||||
#endif
|
||||
distance_strategy_type strategy;
|
||||
|
||||
// Copy coordinates, a vector of references to all points
|
||||
std::vector<dp_point_type> ref_candidates(boost::begin(range),
|
||||
boost::end(range));
|
||||
|
||||
// Include first and last point of line,
|
||||
// they are always part of the line
|
||||
int n = 2;
|
||||
ref_candidates.front().included = true;
|
||||
ref_candidates.back().included = true;
|
||||
|
||||
// Get points, recursively, including them if they are further away
|
||||
// than the specified distance
|
||||
consider(boost::begin(ref_candidates), boost::end(ref_candidates), max_distance, n, strategy);
|
||||
|
||||
// Copy included elements to the output
|
||||
for(typename std::vector<dp_point_type>::const_iterator it
|
||||
= boost::begin(ref_candidates);
|
||||
it != boost::end(ref_candidates);
|
||||
++it)
|
||||
{
|
||||
if (it->included)
|
||||
{
|
||||
// copy-coordinates does not work because OutputIterator
|
||||
// does not model Point (??)
|
||||
//geometry::convert(it->p, *out);
|
||||
*out = it->p;
|
||||
out++;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
};
|
||||
}
|
||||
#endif // DOXYGEN_NO_DETAIL
|
||||
// NOTE: Left here for backward compatibility.
|
||||
|
||||
|
||||
/*!
|
||||
@@ -270,52 +61,24 @@ public :
|
||||
|
||||
typedef PointDistanceStrategy distance_strategy_type;
|
||||
|
||||
typedef typename detail::douglas_peucker
|
||||
<
|
||||
Point,
|
||||
PointDistanceStrategy
|
||||
>::distance_type distance_type;
|
||||
typedef typename strategy::distance::services::return_type
|
||||
<
|
||||
distance_strategy_type,
|
||||
Point, Point
|
||||
>::type distance_type;
|
||||
|
||||
template <typename Range, typename OutputIterator>
|
||||
static inline OutputIterator apply(Range const& range,
|
||||
static inline OutputIterator apply(Range const& ,
|
||||
OutputIterator out,
|
||||
distance_type const& max_distance)
|
||||
distance_type const& )
|
||||
{
|
||||
namespace services = strategy::distance::services;
|
||||
|
||||
typedef typename services::comparable_type
|
||||
<
|
||||
PointDistanceStrategy
|
||||
>::type comparable_distance_strategy_type;
|
||||
|
||||
return detail::douglas_peucker
|
||||
<
|
||||
Point, comparable_distance_strategy_type
|
||||
>().apply(range, out,
|
||||
services::result_from_distance
|
||||
<
|
||||
comparable_distance_strategy_type, Point, Point
|
||||
>::apply(comparable_distance_strategy_type(),
|
||||
max_distance)
|
||||
);
|
||||
return out;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
}} // namespace strategy::simplify
|
||||
|
||||
|
||||
namespace traits {
|
||||
|
||||
template <typename P>
|
||||
struct point_type<geometry::strategy::simplify::detail::douglas_peucker_point<P> >
|
||||
{
|
||||
typedef P type;
|
||||
};
|
||||
|
||||
} // namespace traits
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGY_AGNOSTIC_SIMPLIFY_DOUGLAS_PEUCKER_HPP
|
||||
|
||||
Reference in New Issue
Block a user