add boost on mac
This commit is contained in:
Bassem Girgis
@@ -0,0 +1,114 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2012-2014 Barend Gehrels, 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_BUFFER_DISTANCE_ASYMMETRIC_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_ASYMMETRIC_HPP
|
||||
|
||||
#include <boost/core/ignore_unused.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/buffer.hpp>
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace buffer
|
||||
{
|
||||
|
||||
|
||||
/*!
|
||||
\brief Let the buffer for linestrings be asymmetric
|
||||
\ingroup strategies
|
||||
\tparam NumericType \tparam_numeric
|
||||
\details This strategy can be used as DistanceStrategy for the buffer algorithm.
|
||||
It can be applied for (multi)linestrings. It uses a (potentially) different
|
||||
distances for left and for right. This means the (multi)linestrings are
|
||||
interpreted having a direction.
|
||||
|
||||
\qbk{
|
||||
[heading Example]
|
||||
[buffer_distance_asymmetric]
|
||||
[heading Output]
|
||||
[$img/strategies/buffer_distance_asymmetric.png]
|
||||
[heading See also]
|
||||
\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
|
||||
\* [link geometry.reference.strategies.strategy_buffer_distance_symmetric distance_symmetric]
|
||||
}
|
||||
*/
|
||||
template<typename NumericType>
|
||||
class distance_asymmetric
|
||||
{
|
||||
public :
|
||||
//! \brief Constructs the strategy, two distances must be specified
|
||||
//! \param left The distance (or radius) of the buffer on the left side
|
||||
//! \param right The distance on the right side
|
||||
distance_asymmetric(NumericType const& left,
|
||||
NumericType const& right)
|
||||
: m_left(left)
|
||||
, m_right(right)
|
||||
{}
|
||||
|
||||
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
||||
//! Returns the distance-value for the specified side
|
||||
template <typename Point>
|
||||
inline NumericType apply(Point const& , Point const& ,
|
||||
buffer_side_selector side) const
|
||||
{
|
||||
NumericType result = side == buffer_side_left ? m_left : m_right;
|
||||
return negative() ? math::abs(result) : result;
|
||||
}
|
||||
|
||||
//! Used internally, returns -1 for deflate, 1 for inflate
|
||||
inline int factor() const
|
||||
{
|
||||
return negative() ? -1 : 1;
|
||||
}
|
||||
|
||||
//! Returns true if both distances are negative
|
||||
inline bool negative() const
|
||||
{
|
||||
return 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,
|
||||
EndStrategy const& end_strategy) const
|
||||
{
|
||||
boost::ignore_unused(join_strategy, end_strategy);
|
||||
|
||||
NumericType const left = geometry::math::abs(m_left);
|
||||
NumericType const right = geometry::math::abs(m_right);
|
||||
NumericType const dist = (std::max)(left, right);
|
||||
return (std::max)(join_strategy.max_distance(dist),
|
||||
end_strategy.max_distance(dist));
|
||||
}
|
||||
|
||||
//! Returns the distance at which the input is simplified before the buffer process
|
||||
inline NumericType simplify_distance() const
|
||||
{
|
||||
NumericType const left = geometry::math::abs(m_left);
|
||||
NumericType const right = geometry::math::abs(m_right);
|
||||
return (std::min)(left, right) / 1000.0;
|
||||
}
|
||||
|
||||
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
||||
|
||||
private :
|
||||
NumericType m_left;
|
||||
NumericType m_right;
|
||||
};
|
||||
|
||||
|
||||
}} // namespace strategy::buffer
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_ASYMMETRIC_HPP
|
||||
@@ -0,0 +1,107 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2012-2014 Barend Gehrels, 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_BUFFER_DISTANCE_SYMMETRIC_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_SYMMETRIC_HPP
|
||||
|
||||
|
||||
#include <boost/core/ignore_unused.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/buffer.hpp>
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace buffer
|
||||
{
|
||||
|
||||
|
||||
/*!
|
||||
\brief Let the buffer algorithm create buffers with same distances
|
||||
\ingroup strategies
|
||||
\tparam NumericType \tparam_numeric
|
||||
\details This strategy can be used as DistanceStrategy for the buffer algorithm.
|
||||
It can be applied for all geometries. It uses one distance for left and
|
||||
for right.
|
||||
If the distance is negative and used with a (multi)polygon or ring, the
|
||||
geometry will shrink (deflate) instead of expand (inflate).
|
||||
|
||||
\qbk{
|
||||
[heading Example]
|
||||
[buffer_distance_symmetric]
|
||||
[heading Output]
|
||||
[$img/strategies/buffer_distance_symmetric.png]
|
||||
[heading See also]
|
||||
\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
|
||||
\* [link geometry.reference.strategies.strategy_buffer_distance_asymmetric distance_asymmetric]
|
||||
}
|
||||
*/
|
||||
template<typename NumericType>
|
||||
class distance_symmetric
|
||||
{
|
||||
public :
|
||||
//! \brief Constructs the strategy, a distance must be specified
|
||||
//! \param distance The distance (or radius) of the buffer
|
||||
explicit inline distance_symmetric(NumericType const& distance)
|
||||
: m_distance(distance)
|
||||
{}
|
||||
|
||||
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
||||
//! Returns the distance-value
|
||||
template <typename Point>
|
||||
inline NumericType apply(Point const& , Point const& ,
|
||||
buffer_side_selector ) const
|
||||
{
|
||||
return negative() ? geometry::math::abs(m_distance) : m_distance;
|
||||
}
|
||||
|
||||
//! Used internally, returns -1 for deflate, 1 for inflate
|
||||
inline int factor() const
|
||||
{
|
||||
return negative() ? -1 : 1;
|
||||
}
|
||||
|
||||
//! Returns true if distance is negative (aka deflate)
|
||||
inline bool negative() 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,
|
||||
EndStrategy const& end_strategy) const
|
||||
{
|
||||
boost::ignore_unused(join_strategy, end_strategy);
|
||||
|
||||
NumericType const dist = geometry::math::abs(m_distance);
|
||||
return (std::max)(join_strategy.max_distance(dist),
|
||||
end_strategy.max_distance(dist));
|
||||
}
|
||||
|
||||
|
||||
//! Returns the distance at which the input is simplified before the buffer process
|
||||
inline NumericType simplify_distance() const
|
||||
{
|
||||
return geometry::math::abs(m_distance) / 1000.0;
|
||||
}
|
||||
#endif // DOXYGEN_SHOULD_SKIP_THIS
|
||||
|
||||
private :
|
||||
NumericType m_distance;
|
||||
};
|
||||
|
||||
|
||||
}} // namespace strategy::buffer
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_SYMMETRIC_HPP
|
||||
@@ -0,0 +1,386 @@
|
||||
// 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
|
||||
@@ -0,0 +1,110 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// 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.
|
||||
|
||||
// This file was modified by Oracle on 2018.
|
||||
// Modifications copyright (c) 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_POINT_IN_BOX_BY_SIDE_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP
|
||||
|
||||
#include <boost/array.hpp>
|
||||
#include <boost/core/ignore_unused.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/side.hpp>
|
||||
#include <boost/geometry/strategies/within.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry { namespace strategy
|
||||
{
|
||||
|
||||
namespace within
|
||||
{
|
||||
|
||||
struct decide_within
|
||||
{
|
||||
static inline bool apply(int side, bool& result)
|
||||
{
|
||||
if (side != 1)
|
||||
{
|
||||
result = false;
|
||||
return false;
|
||||
}
|
||||
return true; // continue
|
||||
}
|
||||
};
|
||||
|
||||
struct decide_covered_by
|
||||
{
|
||||
static inline bool apply(int side, bool& result)
|
||||
{
|
||||
if (side != 1)
|
||||
{
|
||||
result = side >= 0;
|
||||
return false;
|
||||
}
|
||||
return true; // continue
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// WARNING
|
||||
// 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
|
||||
{
|
||||
template <typename Point, typename Box>
|
||||
static inline bool apply(Point const& point, Box const& box)
|
||||
{
|
||||
typedef typename strategy::side::services::default_strategy
|
||||
<
|
||||
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;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
} // namespace within
|
||||
|
||||
|
||||
}}} // namespace boost::geometry::strategy
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP
|
||||
@@ -0,0 +1,60 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2014-2018 Oracle and/or its affiliates.
|
||||
|
||||
// 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_STRATEGY_AGNOSTIC_POINT_IN_POINT_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POINT_HPP
|
||||
|
||||
|
||||
#include <boost/geometry/core/cs.hpp>
|
||||
#include <boost/geometry/core/tags.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/cartesian/point_in_point.hpp>
|
||||
#include <boost/geometry/strategies/spherical/point_in_point.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace within
|
||||
{
|
||||
|
||||
template
|
||||
<
|
||||
typename Point1, typename Point2,
|
||||
typename CSTag = typename cs_tag<Point1>::type
|
||||
>
|
||||
struct point_in_point
|
||||
: strategy::within::cartesian_point_point
|
||||
{};
|
||||
|
||||
template <typename Point1, typename Point2>
|
||||
struct point_in_point<Point1, Point2, spherical_equatorial_tag>
|
||||
: strategy::within::spherical_point_point
|
||||
{};
|
||||
|
||||
template <typename Point1, typename Point2>
|
||||
struct point_in_point<Point1, Point2, spherical_polar_tag>
|
||||
: strategy::within::spherical_point_point
|
||||
{};
|
||||
|
||||
template <typename Point1, typename Point2>
|
||||
struct point_in_point<Point1, Point2, geographic_tag>
|
||||
: strategy::within::spherical_point_point
|
||||
{};
|
||||
|
||||
|
||||
}} // namespace strategy::within
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POINT_HPP
|
||||
@@ -0,0 +1,206 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// Copyright (c) 2011-2012 Barend Gehrels, Amsterdam, the Netherlands.
|
||||
|
||||
// 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_STRATEGY_AGNOSTIC_POINT_IN_POLY_ORIENTED_WINDING_HPP
|
||||
#define BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_ORIENTED_WINDING_HPP
|
||||
|
||||
|
||||
#include <boost/geometry/core/point_order.hpp>
|
||||
#include <boost/geometry/util/math.hpp>
|
||||
#include <boost/geometry/util/select_calculation_type.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/side.hpp>
|
||||
#include <boost/geometry/strategies/within.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace within
|
||||
{
|
||||
|
||||
/*!
|
||||
\brief Within detection using winding rule, but checking if enclosing ring is
|
||||
counter clockwise and, if so, reverses the result
|
||||
\ingroup strategies
|
||||
\tparam Point \tparam_point
|
||||
\tparam Reverse True if parameter should be reversed
|
||||
\tparam PointOfSegment \tparam_segment_point
|
||||
\tparam CalculationType \tparam_calculation
|
||||
\author Barend Gehrels
|
||||
\note Only dependant on "side", -> agnostic, suitable for spherical/latlong
|
||||
|
||||
\qbk{
|
||||
[heading See also]
|
||||
[link geometry.reference.algorithms.within.within_3_with_strategy within (with strategy)]
|
||||
}
|
||||
*/
|
||||
template
|
||||
<
|
||||
bool Reverse,
|
||||
typename Point,
|
||||
typename PointOfSegment = Point,
|
||||
typename CalculationType = void
|
||||
>
|
||||
class oriented_winding
|
||||
{
|
||||
typedef typename select_calculation_type
|
||||
<
|
||||
Point,
|
||||
PointOfSegment,
|
||||
CalculationType
|
||||
>::type calculation_type;
|
||||
|
||||
|
||||
typedef typename strategy::side::services::default_strategy
|
||||
<
|
||||
typename cs_tag<Point>::type
|
||||
>::type strategy_side_type;
|
||||
|
||||
|
||||
/*! subclass to keep state */
|
||||
class counter
|
||||
{
|
||||
int m_count;
|
||||
bool m_touches;
|
||||
calculation_type m_sum_area;
|
||||
|
||||
inline int code() const
|
||||
{
|
||||
return m_touches ? 0 : m_count == 0 ? -1 : 1;
|
||||
}
|
||||
inline int clockwise_oriented_code() const
|
||||
{
|
||||
return (m_sum_area > 0) ? code() : -code();
|
||||
}
|
||||
inline int oriented_code() const
|
||||
{
|
||||
return Reverse
|
||||
? -clockwise_oriented_code()
|
||||
: clockwise_oriented_code();
|
||||
}
|
||||
|
||||
public :
|
||||
friend class oriented_winding;
|
||||
|
||||
inline counter()
|
||||
: m_count(0)
|
||||
, m_touches(false)
|
||||
, m_sum_area(0)
|
||||
{}
|
||||
|
||||
inline void add_to_area(calculation_type triangle)
|
||||
{
|
||||
m_sum_area += triangle;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
template <size_t D>
|
||||
static inline int check_touch(Point const& point,
|
||||
PointOfSegment const& seg1, PointOfSegment const& seg2,
|
||||
counter& state)
|
||||
{
|
||||
calculation_type const p = get<D>(point);
|
||||
calculation_type const s1 = get<D>(seg1);
|
||||
calculation_type const s2 = get<D>(seg2);
|
||||
if ((s1 <= p && s2 >= p) || (s2 <= p && s1 >= p))
|
||||
{
|
||||
state.m_touches = true;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
template <size_t D>
|
||||
static inline int check_segment(Point const& point,
|
||||
PointOfSegment const& seg1, PointOfSegment const& seg2,
|
||||
counter& state)
|
||||
{
|
||||
calculation_type const p = get<D>(point);
|
||||
calculation_type const s1 = get<D>(seg1);
|
||||
calculation_type const s2 = get<D>(seg2);
|
||||
|
||||
|
||||
// Check if one of segment endpoints is at same level of point
|
||||
bool eq1 = math::equals(s1, p);
|
||||
bool eq2 = math::equals(s2, p);
|
||||
|
||||
if (eq1 && eq2)
|
||||
{
|
||||
// Both equal p -> segment is horizontal (or vertical for D=0)
|
||||
// The only thing which has to be done is check if point is ON segment
|
||||
return check_touch<1 - D>(point, seg1, seg2, state);
|
||||
}
|
||||
|
||||
return
|
||||
eq1 ? (s2 > p ? 1 : -1) // Point on level s1, UP/DOWN depending on s2
|
||||
: eq2 ? (s1 > p ? -1 : 1) // idem
|
||||
: s1 < p && s2 > p ? 2 // Point between s1 -> s2 --> UP
|
||||
: s2 < p && s1 > p ? -2 // Point between s2 -> s1 --> DOWN
|
||||
: 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
public :
|
||||
|
||||
// Typedefs and static methods to fulfill the concept
|
||||
typedef Point point_type;
|
||||
typedef PointOfSegment segment_point_type;
|
||||
typedef counter state_type;
|
||||
|
||||
static inline bool apply(Point const& point,
|
||||
PointOfSegment const& s1, PointOfSegment const& s2,
|
||||
counter& state)
|
||||
{
|
||||
state.add_to_area(get<0>(s2) * get<1>(s1) - get<0>(s1) * get<1>(s2));
|
||||
|
||||
int count = check_segment<1>(point, s1, s2, state);
|
||||
if (count != 0)
|
||||
{
|
||||
int side = strategy_side_type::apply(s1, s2, point);
|
||||
if (side == 0)
|
||||
{
|
||||
// Point is lying on segment
|
||||
state.m_touches = true;
|
||||
state.m_count = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Side is NEG for right, POS for left.
|
||||
// The count is -2 for down, 2 for up (or -1/1)
|
||||
// Side positive thus means UP and LEFTSIDE or DOWN and RIGHTSIDE
|
||||
// See accompagnying figure (TODO)
|
||||
if (side * count > 0)
|
||||
{
|
||||
state.m_count += count;
|
||||
}
|
||||
}
|
||||
return ! state.m_touches;
|
||||
}
|
||||
|
||||
static inline int result(counter const& state)
|
||||
{
|
||||
return state.oriented_code();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
}} // namespace strategy::within
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_ORIENTED_WINDING_HPP
|
||||
@@ -0,0 +1,134 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// 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.
|
||||
// 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_STRATEGY_AGNOSTIC_POINT_IN_POLY_WINDING_HPP
|
||||
#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/tag_cast.hpp>
|
||||
#include <boost/geometry/core/tags.hpp>
|
||||
|
||||
#include <boost/geometry/strategies/cartesian/point_in_poly_winding.hpp>
|
||||
#include <boost/geometry/strategies/side.hpp>
|
||||
#include <boost/geometry/strategies/spherical/point_in_poly_winding.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace geometry
|
||||
{
|
||||
|
||||
namespace strategy { namespace within
|
||||
{
|
||||
|
||||
|
||||
#ifndef DOXYGEN_NO_DETAIL
|
||||
namespace detail
|
||||
{
|
||||
|
||||
|
||||
template
|
||||
<
|
||||
typename Point,
|
||||
typename PointOfSegment,
|
||||
typename CalculationType,
|
||||
typename CSTag = typename tag_cast
|
||||
<
|
||||
typename cs_tag<Point>::type,
|
||||
spherical_tag
|
||||
>::type
|
||||
>
|
||||
struct winding_base_type
|
||||
{
|
||||
BOOST_MPL_ASSERT_MSG(false,
|
||||
NOT_IMPLEMENTED_FOR_THIS_COORDINATE_SYSTEM,
|
||||
(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
|
||||
<
|
||||
Point,
|
||||
PointOfSegment,
|
||||
typename strategy::side::services::default_strategy
|
||||
<
|
||||
typename cs_tag<Point>::type
|
||||
>::type,
|
||||
CalculationType
|
||||
> type;
|
||||
};
|
||||
|
||||
|
||||
} // namespace detail
|
||||
#endif // DOXYGEN_NO_DETAIL
|
||||
|
||||
|
||||
/*!
|
||||
\brief Within detection using winding rule. Side strategy used internally is
|
||||
choosen based on Point's coordinate system.
|
||||
\ingroup strategies
|
||||
\tparam Point \tparam_point
|
||||
\tparam PointOfSegment \tparam_segment_point
|
||||
\tparam CalculationType \tparam_calculation
|
||||
|
||||
\qbk{
|
||||
[heading See also]
|
||||
[link geometry.reference.algorithms.within.within_3_with_strategy within (with strategy)]
|
||||
}
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename Point,
|
||||
typename PointOfSegment = Point,
|
||||
typename CalculationType = void
|
||||
>
|
||||
class winding
|
||||
: public within::detail::winding_base_type
|
||||
<
|
||||
Point, PointOfSegment, CalculationType
|
||||
>::type
|
||||
{
|
||||
typedef typename within::detail::winding_base_type
|
||||
<
|
||||
Point, PointOfSegment, CalculationType
|
||||
>::type base_t;
|
||||
|
||||
public:
|
||||
winding() {}
|
||||
|
||||
template <typename Model>
|
||||
explicit winding(Model const& model)
|
||||
: base_t(model)
|
||||
{}
|
||||
};
|
||||
|
||||
|
||||
}} // namespace strategy::within
|
||||
|
||||
|
||||
}} // namespace boost::geometry
|
||||
|
||||
|
||||
#endif // BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_WINDING_HPP
|
||||
@@ -0,0 +1,321 @@
|
||||
// Boost.Geometry (aka GGL, Generic Geometry Library)
|
||||
|
||||
// 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.
|
||||
|
||||
// Contributed and/or modified by Menelaos Karavelas, 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_STRATEGY_AGNOSTIC_SIMPLIFY_DOUGLAS_PEUCKER_HPP
|
||||
#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
|
||||
{
|
||||
|
||||
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
|
||||
|
||||
|
||||
/*!
|
||||
\brief Implements the simplify algorithm.
|
||||
\ingroup strategies
|
||||
\details The douglas_peucker strategy simplifies a linestring, ring or
|
||||
vector of points using the well-known Douglas-Peucker algorithm.
|
||||
\tparam Point the point type
|
||||
\tparam PointDistanceStrategy point-segment distance strategy to be used
|
||||
\note This strategy uses itself a point-segment-distance strategy which
|
||||
can be specified
|
||||
\author Barend and Maarten, 1995/1996
|
||||
\author Barend, revised for Generic Geometry Library, 2008
|
||||
*/
|
||||
|
||||
/*
|
||||
For the algorithm, see for example:
|
||||
- http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
|
||||
- http://www2.dcs.hull.ac.uk/CISRG/projects/Royal-Inst/demos/dp.html
|
||||
*/
|
||||
template
|
||||
<
|
||||
typename Point,
|
||||
typename PointDistanceStrategy
|
||||
>
|
||||
class douglas_peucker
|
||||
{
|
||||
public :
|
||||
|
||||
typedef PointDistanceStrategy distance_strategy_type;
|
||||
|
||||
typedef typename detail::douglas_peucker
|
||||
<
|
||||
Point,
|
||||
PointDistanceStrategy
|
||||
>::distance_type distance_type;
|
||||
|
||||
template <typename Range, typename OutputIterator>
|
||||
static inline OutputIterator apply(Range const& range,
|
||||
OutputIterator out,
|
||||
distance_type const& max_distance)
|
||||
{
|
||||
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)
|
||||
);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
}} // 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