/usr/include/boost/geometry/algorithms
Edit: /usr/include/boost/geometry/algorithms/convert.hpp (17327B)
// 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 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_CONVERT_HPP
#define BOOST_GEOMETRY_ALGORITHMS_CONVERT_HPP
#include
#include
#include
#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
// Silence warning C4512: assignment operator could not be generated
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4127 4512)
#endif
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace conversion
{
template
<
typename Point,
typename Box,
std::size_t Index,
std::size_t Dimension,
std::size_t DimensionCount
>
struct point_to_box
{
static inline void apply(Point const& point, Box& box)
{
typedef typename coordinate_type::type coordinate_type;
set(box,
boost::numeric_cast(get(point)));
point_to_box
<
Point, Box,
Index, Dimension + 1, DimensionCount
>::apply(point, box);
}
};
template
<
typename Point,
typename Box,
std::size_t Index,
std::size_t DimensionCount
>
struct point_to_box
{
static inline void apply(Point const& , Box& )
{}
};
template
struct box_to_range
{
static inline void apply(Box const& box, Range& range)
{
traits::resize::apply(range, Close ? 5 : 4);
assign_box_corners_oriented(box, range);
if (Close)
{
range::at(range, 4) = range::at(range, 0);
}
}
};
template
struct segment_to_range
{
static inline void apply(Segment const& segment, Range& range)
{
traits::resize::apply(range, 2);
typename boost::range_iterator::type it = boost::begin(range);
assign_point_from_index<0>(segment, *it);
++it;
assign_point_from_index<1>(segment, *it);
}
};
template
<
typename Range1,
typename Range2,
bool Reverse = false
>
struct range_to_range
{
typedef typename reversible_view
<
Range1 const,
Reverse ? iterate_reverse : iterate_forward
>::type rview_type;
typedef typename closeable_view
<
rview_type const,
geometry::closure::value
>::type view_type;
struct default_policy
{
template
static inline void apply(Point1 const& point1, Point2 & point2)
{
geometry::detail::conversion::convert_point_to_point(point1, point2);
}
};
static inline void apply(Range1 const& source, Range2& destination)
{
apply(source, destination, default_policy());
}
template
static inline ConvertPointPolicy apply(Range1 const& source, Range2& destination,
ConvertPointPolicy convert_point)
{
geometry::clear(destination);
rview_type rview(source);
// We consider input always as closed, and skip last
// point for open output.
view_type view(rview);
typedef typename boost::range_size::type size_type;
size_type n = boost::size(view);
if (geometry::closure::value == geometry::open)
{
n--;
}
// If size == 0 && geometry::open <=> n = numeric_limits::max()
// but ok, sice below it == end()
size_type i = 0;
for (typename boost::range_iterator::type it
= boost::begin(view);
it != boost::end(view) && i < n;
++it, ++i)
{
typename boost::range_value::type point;
convert_point.apply(*it, point);
range::push_back(destination, point);
}
return convert_point;
}
};
template
struct polygon_to_polygon
{
typedef range_to_range
<
typename geometry::ring_type::type,
typename geometry::ring_type::type,
geometry::point_order::value
!= geometry::point_order::value
> per_ring;
static inline void apply(Polygon1 const& source, Polygon2& destination)
{
// Clearing managed per ring, and in the resizing of interior rings
per_ring::apply(geometry::exterior_ring(source),
geometry::exterior_ring(destination));
// Container should be resizeable
traits::resize
<
typename boost::remove_reference
<
typename traits::interior_mutable_type::type
>::type
>::apply(interior_rings(destination), num_interior_rings(source));
typename interior_return_type::type
rings_source = interior_rings(source);
typename interior_return_type::type
rings_dest = interior_rings(destination);
typename detail::interior_iterator::type
it_source = boost::begin(rings_source);
typename detail::interior_iterator::type
it_dest = boost::begin(rings_dest);
for ( ; it_source != boost::end(rings_source); ++it_source, ++it_dest)
{
per_ring::apply(*it_source, *it_dest);
}
}
};
template
struct single_to_multi: private Policy
{
static inline void apply(Single const& single, Multi& multi)
{
traits::resize::apply(multi, 1);
Policy::apply(single, *boost::begin(multi));
}
};
template
struct multi_to_multi: private Policy
{
static inline void apply(Multi1 const& multi1, Multi2& multi2)
{
traits::resize::apply(multi2, boost::size(multi1));
typename boost::range_iterator::type it1
= boost::begin(multi1);
typename boost::range_iterator::type it2
= boost::begin(multi2);
for (; it1 != boost::end(multi1); ++it1, ++it2)
{
Policy::apply(*it1, *it2);
}
}
};
}} // namespace detail::conversion
#endif // DOXYGEN_NO_DETAIL
#ifndef DOXYGEN_NO_DISPATCH
namespace dispatch
{
template
<
typename Geometry1, typename Geometry2,
typename Tag1 = typename tag_cast::type, multi_tag>::type,
typename Tag2 = typename tag_cast::type, multi_tag>::type,
std::size_t DimensionCount = dimension::type::value,
bool UseAssignment = boost::is_same::value
&& !boost::is_array::value
>
struct convert: not_implemented >
{};
template
<
typename Geometry1, typename Geometry2,
typename Tag,
std::size_t DimensionCount
>
struct convert
{
// Same geometry type -> copy whole geometry
static inline void apply(Geometry1 const& source, Geometry2& destination)
{
destination = source;
}
};
template
<
typename Geometry1, typename Geometry2,
std::size_t DimensionCount
>
struct convert
: detail::conversion::point_to_point
{};
template
<
typename Box1, typename Box2,
std::size_t DimensionCount
>
struct convert
: detail::conversion::indexed_to_indexed
{};
template
<
typename Segment1, typename Segment2,
std::size_t DimensionCount
>
struct convert
: detail::conversion::indexed_to_indexed
{};
template
struct convert
: detail::conversion::segment_to_range
{};
template
struct convert
: detail::conversion::range_to_range
<
Ring1,
Ring2,
geometry::point_order::value
!= geometry::point_order::value
>
{};
template
struct convert
: detail::conversion::range_to_range
{};
template
struct convert
: detail::conversion::polygon_to_polygon
{};
template
struct convert
: detail::conversion::box_to_range
<
Box,
Ring,
geometry::closure::value == closed,
geometry::point_order::value == counterclockwise
>
{};
template
struct convert
{
static inline void apply(Box const& box, Polygon& polygon)
{
typedef typename ring_type::type ring_type;
convert
<
Box, ring_type,
box_tag, ring_tag,
2, false
>::apply(box, exterior_ring(polygon));
}
};
template
struct convert
{
static inline void apply(Point const& point, Box& box)
{
detail::conversion::point_to_box
<
Point, Box, min_corner, 0, DimensionCount
>::apply(point, box);
detail::conversion::point_to_box
<
Point, Box, max_corner, 0, DimensionCount
>::apply(point, box);
}
};
template
struct convert
{
static inline void apply(Ring const& ring, Polygon& polygon)
{
typedef typename ring_type::type ring_type;
convert
<
Ring, ring_type,
ring_tag, ring_tag,
DimensionCount, false
>::apply(ring, exterior_ring(polygon));
}
};
template
struct convert
{
static inline void apply(Polygon const& polygon, Ring& ring)
{
typedef typename ring_type::type ring_type;
convert
<
ring_type, Ring,
ring_tag, ring_tag,
DimensionCount, false
>::apply(exterior_ring(polygon), ring);
}
};
// Dispatch for multi <-> multi, specifying their single-version as policy.
// Note that, even if the multi-types are mutually different, their single
// version types might be the same and therefore we call boost::is_same again
template
struct convert
: detail::conversion::multi_to_multi
<
Multi1,
Multi2,
convert
<
typename boost::range_value::type,
typename boost::range_value::type,
typename single_tag_of
<
typename tag::type
>::type,
typename single_tag_of
<
typename tag::type
>::type,
DimensionCount
>
>
{};
template
struct convert
: detail::conversion::single_to_multi
<
Single,
Multi,
convert
<
Single,
typename boost::range_value::type,
typename tag::type,
typename single_tag_of
<
typename tag::type
>::type,
DimensionCount,
false
>
>
{};
} // namespace dispatch
#endif // DOXYGEN_NO_DISPATCH
namespace resolve_variant {
template
struct convert
{
static inline void apply(Geometry1 const& geometry1, Geometry2& geometry2)
{
concepts::check_concepts_and_equal_dimensions();
dispatch::convert::apply(geometry1, geometry2);
}
};
template
struct convert, Geometry2>
{
struct visitor: static_visitor
{
Geometry2& m_geometry2;
visitor(Geometry2& geometry2)
: m_geometry2(geometry2)
{}
template
inline void operator()(Geometry1 const& geometry1) const
{
convert::apply(geometry1, m_geometry2);
}
};
static inline void apply(
boost::variant const& geometry1,
Geometry2& geometry2
)
{
boost::apply_visitor(visitor(geometry2), geometry1);
}
};
}
/*!
\brief Converts one geometry to another geometry
\details The convert algorithm converts one geometry, e.g. a BOX, to another
geometry, e.g. a RING. This only works if it is possible and applicable.
If the point-order is different, or the closure is different between two
geometry types, it will be converted correctly by explicitly reversing the
points or closing or opening the polygon rings.
\ingroup convert
\tparam Geometry1 \tparam_geometry
\tparam Geometry2 \tparam_geometry
\param geometry1 \param_geometry (source)
\param geometry2 \param_geometry (target)
\qbk{[include reference/algorithms/convert.qbk]}
*/
template
inline void convert(Geometry1 const& geometry1, Geometry2& geometry2)
{
resolve_variant::convert::apply(geometry1, geometry2);
}
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_CONVERT_HPP