/usr/include/boost/geometry/algorithms
Edit: /usr/include/boost/geometry/algorithms/correct.hpp (9956B)
// 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.
// Copyright (c) 2014-2017 Adam Wulkiewicz, Lodz, Poland.
// This file was modified by Oracle on 2017.
// Modifications copyright (c) 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_ALGORITHMS_CORRECT_HPP
#define BOOST_GEOMETRY_ALGORITHMS_CORRECT_HPP
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost { namespace geometry
{
// Silence warning C4127: conditional expression is constant
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4127)
#endif
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace correct
{
template
struct correct_nop
{
template
static inline void apply(Geometry& , Strategy const& )
{}
};
template
struct correct_box_loop
{
typedef typename coordinate_type::type coordinate_type;
static inline void apply(Box& box)
{
if (get(box) > get(box))
{
// Swap the coordinates
coordinate_type max_value = get(box);
coordinate_type min_value = get(box);
set(box, min_value);
set(box, max_value);
}
correct_box_loop
<
Box, Dimension + 1, DimensionCount
>::apply(box);
}
};
template
struct correct_box_loop
{
static inline void apply(Box& )
{}
};
// Correct a box: make min/max correct
template
struct correct_box
{
template
static inline void apply(Box& box, Strategy const& )
{
// Currently only for Cartesian coordinates
// (or spherical without crossing dateline)
// Future version: adapt using strategies
correct_box_loop
<
Box, 0, dimension::type::value
>::apply(box);
}
};
// Close a ring, if not closed
template class Predicate>
struct correct_ring
{
typedef typename point_type::type point_type;
typedef typename coordinate_type::type coordinate_type;
typedef detail::area::ring_area
<
order_as_direction::value>::value,
geometry::closure::value
> ring_area_type;
template
static inline void apply(Ring& r, Strategy const& strategy)
{
// Correct closure if necessary
detail::correct_closure::close_or_open_ring::apply(r);
// Check area
typedef typename area_result::type area_result_type;
Predicate predicate;
area_result_type const zero = 0;
if (predicate(ring_area_type::apply(r, strategy), zero))
{
std::reverse(boost::begin(r), boost::end(r));
}
}
};
// Correct a polygon: normalizes all rings, sets outer ring clockwise, sets all
// inner rings counter clockwise (or vice versa depending on orientation)
template
struct correct_polygon
{
typedef typename ring_type::type ring_type;
template
static inline void apply(Polygon& poly, Strategy const& strategy)
{
correct_ring
<
ring_type,
std::less
>::apply(exterior_ring(poly), strategy);
typename interior_return_type::type
rings = interior_rings(poly);
for (typename detail::interior_iterator::type
it = boost::begin(rings); it != boost::end(rings); ++it)
{
correct_ring
<
ring_type,
std::greater
>::apply(*it, strategy);
}
}
};
}} // namespace detail::correct
#endif // DOXYGEN_NO_DETAIL
#ifndef DOXYGEN_NO_DISPATCH
namespace dispatch
{
template ::type>
struct correct: not_implemented
{};
template
struct correct
: detail::correct::correct_nop
{};
template
struct correct
: detail::correct::correct_nop
{};
template
struct correct
: detail::correct::correct_nop
{};
template
struct correct
: detail::correct::correct_box
{};
template
struct correct
: detail::correct::correct_ring
<
Ring,
std::less
>
{};
template
struct correct
: detail::correct::correct_polygon
{};
template
struct correct
: detail::correct::correct_nop
{};
template
struct correct
: detail::correct::correct_nop
{};
template
struct correct
: detail::multi_modify
<
Geometry,
detail::correct::correct_polygon
<
typename boost::range_value::type
>
>
{};
} // namespace dispatch
#endif // DOXYGEN_NO_DISPATCH
namespace resolve_variant {
template
struct correct
{
template
static inline void apply(Geometry& geometry, Strategy const& strategy)
{
concepts::check();
dispatch::correct::apply(geometry, strategy);
}
};
template
struct correct >
{
template
struct visitor: boost::static_visitor
{
Strategy const& m_strategy;
visitor(Strategy const& strategy): m_strategy(strategy) {}
template
void operator()(Geometry& geometry) const
{
correct::apply(geometry, m_strategy);
}
};
template
static inline void
apply(boost::variant& geometry, Strategy const& strategy)
{
boost::apply_visitor(visitor(strategy), geometry);
}
};
} // namespace resolve_variant
/*!
\brief Corrects a geometry
\details Corrects a geometry: all rings which are wrongly oriented with respect
to their expected orientation are reversed. To all rings which do not have a
closing point and are typed as they should have one, the first point is
appended. Also boxes can be corrected.
\ingroup correct
\tparam Geometry \tparam_geometry
\param geometry \param_geometry which will be corrected if necessary
\qbk{[include reference/algorithms/correct.qbk]}
*/
template
inline void correct(Geometry& geometry)
{
typedef typename point_type::type point_type;
typedef typename strategy::area::services::default_strategy
<
typename cs_tag::type
>::type strategy_type;
resolve_variant::correct::apply(geometry, strategy_type());
}
/*!
\brief Corrects a geometry
\details Corrects a geometry: all rings which are wrongly oriented with respect
to their expected orientation are reversed. To all rings which do not have a
closing point and are typed as they should have one, the first point is
appended. Also boxes can be corrected.
\ingroup correct
\tparam Geometry \tparam_geometry
\tparam Strategy \tparam_strategy{Area}
\param geometry \param_geometry which will be corrected if necessary
\param strategy \param_strategy{area}
\qbk{distinguish,with strategy}
\qbk{[include reference/algorithms/correct.qbk]}
*/
template
inline void correct(Geometry& geometry, Strategy const& strategy)
{
resolve_variant::correct::apply(geometry, strategy);
}
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_CORRECT_HPP