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 pdalboost::remove_reference
<
typename traits::interior_mutable_type<Polygon2>::type
>::type
>::apply(interior_rings(destination), num_interior_rings(source));
typename interior_return_type<Polygon1 const>::type rings_source
= interior_rings(source);
typename interior_return_type<Polygon2>::type rings_dest
= interior_rings(destination);
BOOST_AUTO_TPL(it_source, pdalboost::begin(rings_source));
BOOST_AUTO_TPL(it_dest, pdalboost::begin(rings_dest));
for ( ; it_source != pdalboost::end(rings_source); ++it_source, ++it_dest)
{
per_ring::apply(*it_source, *it_dest);
}
}
static inline void apply(Polygon& polygon, Point const& point,
int ring_index, int = 0)
{
if (ring_index == -1)
{
append_point<ring_type, Point>::apply(
exterior_ring(polygon), point);
}
else if (ring_index < int(num_interior_rings(polygon)))
{
append_point<ring_type, Point>::apply(
range::at(interior_rings(polygon), ring_index), point);
}
}
static inline void apply(Polygon& polygon, Range const& range,
int ring_index, int = 0)
{
if (ring_index == -1)
{
append_range<ring_type, Range>::apply(
exterior_ring(polygon), range);
}
else if (ring_index < int(num_interior_rings(polygon)))
{
append_range<ring_type, Range>::apply(
range::at(interior_rings(polygon), ring_index), range);
}
}
static inline bool apply(Polygon1 const& poly1, Polygon2& poly2,
Strategy const& strategy)
{
typedef typename ring_type<Polygon1>::type ring1_type;
typedef typename ring_type<Polygon2>::type ring2_type;
typedef typename point_type<Polygon2>::type point2_type;
geometry::clear(poly2);
if (!transform_range_out<point2_type>(exterior_ring(poly1),
std::back_inserter(exterior_ring(poly2)), strategy))
{
return false;
}
// Note: here a resizeable container is assumed.
traits::resize
<
typename boost::remove_reference
<
typename traits::interior_mutable_type<Polygon2>::type
>::type
>::apply(interior_rings(poly2), num_interior_rings(poly1));
typename interior_return_type<Polygon1 const>::type rings1
= interior_rings(poly1);
typename interior_return_type<Polygon2>::type rings2
= interior_rings(poly2);
BOOST_AUTO_TPL(it1, boost::begin(rings1));
BOOST_AUTO_TPL(it2, boost::begin(rings2));
for ( ; it1 != boost::end(interior_rings(poly1)); ++it1, ++it2)
{
if (!transform_range_out<point2_type>(*it1,
std::back_inserter(*it2), strategy))
{
return false;
}
}
return true;
}
static inline void apply(Polygon const& poly_in, Polygon& poly_out,
Distance const& max_distance, Strategy const& strategy)
{
typedef typename ring_type<Polygon>::type ring_type;
int const Minimum = core_detail::closure::minimum_ring_size
<
geometry::closure<Polygon>::value
>::value;
// Note that if there are inner rings, and distance is too large,
// they might intersect with the outer ring in the output,
// while it didn't in the input.
simplify_range<ring_type, Strategy, Minimum>::apply(exterior_ring(poly_in),
exterior_ring(poly_out),
max_distance, strategy);
traits::resize
<
typename boost::remove_reference
<
typename traits::interior_mutable_type<Polygon>::type
>::type
>::apply(interior_rings(poly_out), num_interior_rings(poly_in));
typename interior_return_type<Polygon const>::type rings_in
= interior_rings(poly_in);
typename interior_return_type<Polygon>::type rings_out
= interior_rings(poly_out);
BOOST_AUTO_TPL(it_out, boost::begin(rings_out));
for (BOOST_AUTO_TPL(it_in, boost::begin(rings_in));
it_in != boost::end(rings_in);
++it_in, ++it_out)
{
simplify_range<ring_type, Strategy, Minimum>::apply(*it_in,
*it_out, max_distance, strategy);
}
}