345 lines
9.6 KiB
C++
345 lines
9.6 KiB
C++
// 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-2023.
|
|
// Modifications copyright (c) 2017-2023 Oracle and/or its affiliates.
|
|
// Contributed and/or modified by Vissarion Fysikopoulos, 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.
|
|
|
|
// 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 <algorithm>
|
|
#include <functional>
|
|
|
|
#include <boost/range/begin.hpp>
|
|
#include <boost/range/end.hpp>
|
|
|
|
#include <boost/geometry/algorithms/area.hpp>
|
|
#include <boost/geometry/algorithms/correct_closure.hpp>
|
|
#include <boost/geometry/algorithms/detail/multi_modify.hpp>
|
|
#include <boost/geometry/algorithms/detail/visit.hpp>
|
|
|
|
#include <boost/geometry/core/exterior_ring.hpp>
|
|
#include <boost/geometry/core/interior_rings.hpp>
|
|
#include <boost/geometry/core/tags.hpp>
|
|
#include <boost/geometry/core/visit.hpp>
|
|
|
|
#include <boost/geometry/geometries/adapted/boost_variant.hpp> // For backward compatibility
|
|
#include <boost/geometry/geometries/concepts/check.hpp>
|
|
|
|
#include <boost/geometry/strategies/area/cartesian.hpp>
|
|
#include <boost/geometry/strategies/area/geographic.hpp>
|
|
#include <boost/geometry/strategies/area/spherical.hpp>
|
|
#include <boost/geometry/strategies/detail.hpp>
|
|
|
|
#include <boost/geometry/util/algorithm.hpp>
|
|
|
|
|
|
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
|
|
{
|
|
|
|
struct correct_nop
|
|
{
|
|
template <typename Geometry, typename Strategy>
|
|
static inline void apply(Geometry& , Strategy const& )
|
|
{}
|
|
};
|
|
|
|
|
|
// Correct a box: make min/max correct
|
|
struct correct_box
|
|
{
|
|
template <typename Box, typename Strategy>
|
|
static inline void apply(Box& box, Strategy const& )
|
|
{
|
|
using coordinate_type = typename geometry::coordinate_type<Box>::type;
|
|
|
|
// Currently only for Cartesian coordinates
|
|
// (or spherical without crossing dateline)
|
|
// Future version: adapt using strategies
|
|
detail::for_each_dimension<Box>([&](auto dimension)
|
|
{
|
|
if (get<min_corner, dimension>(box) > get<max_corner, dimension>(box))
|
|
{
|
|
// Swap the coordinates
|
|
coordinate_type max_value = get<min_corner, dimension>(box);
|
|
coordinate_type min_value = get<max_corner, dimension>(box);
|
|
set<min_corner, dimension>(box, min_value);
|
|
set<max_corner, dimension>(box, max_value);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
// Close a ring, if not closed
|
|
template <typename Predicate = std::less<>>
|
|
struct correct_ring
|
|
{
|
|
template <typename Ring, typename Strategy>
|
|
static inline void apply(Ring& r, Strategy const& strategy)
|
|
{
|
|
// Correct closure if necessary
|
|
detail::correct_closure::close_or_open_ring::apply(r);
|
|
|
|
// NOTE: calculate_point_order should probably be used here instead.
|
|
|
|
// Check area
|
|
using area_t = typename area_result<Ring, Strategy>::type;
|
|
area_t const zero = 0;
|
|
if (Predicate()(detail::area::ring_area::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)
|
|
struct correct_polygon
|
|
{
|
|
template <typename Polygon, typename Strategy>
|
|
static inline void apply(Polygon& poly, Strategy const& strategy)
|
|
{
|
|
correct_ring<std::less<>>::apply(exterior_ring(poly), strategy);
|
|
|
|
auto&& rings = interior_rings(poly);
|
|
auto const end = boost::end(rings);
|
|
for (auto it = boost::begin(rings); it != end; ++it)
|
|
{
|
|
correct_ring<std::greater<>>::apply(*it, strategy);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
}} // namespace detail::correct
|
|
#endif // DOXYGEN_NO_DETAIL
|
|
|
|
|
|
#ifndef DOXYGEN_NO_DISPATCH
|
|
namespace dispatch
|
|
{
|
|
|
|
template <typename Geometry, typename Tag = typename tag<Geometry>::type>
|
|
struct correct: not_implemented<Tag>
|
|
{};
|
|
|
|
template <typename Point>
|
|
struct correct<Point, point_tag>
|
|
: detail::correct::correct_nop
|
|
{};
|
|
|
|
template <typename LineString>
|
|
struct correct<LineString, linestring_tag>
|
|
: detail::correct::correct_nop
|
|
{};
|
|
|
|
template <typename Segment>
|
|
struct correct<Segment, segment_tag>
|
|
: detail::correct::correct_nop
|
|
{};
|
|
|
|
|
|
template <typename Box>
|
|
struct correct<Box, box_tag>
|
|
: detail::correct::correct_box
|
|
{};
|
|
|
|
template <typename Ring>
|
|
struct correct<Ring, ring_tag>
|
|
: detail::correct::correct_ring<>
|
|
{};
|
|
|
|
template <typename Polygon>
|
|
struct correct<Polygon, polygon_tag>
|
|
: detail::correct::correct_polygon
|
|
{};
|
|
|
|
|
|
template <typename MultiPoint>
|
|
struct correct<MultiPoint, multi_point_tag>
|
|
: detail::correct::correct_nop
|
|
{};
|
|
|
|
|
|
template <typename MultiLineString>
|
|
struct correct<MultiLineString, multi_linestring_tag>
|
|
: detail::correct::correct_nop
|
|
{};
|
|
|
|
|
|
template <typename Geometry>
|
|
struct correct<Geometry, multi_polygon_tag>
|
|
: detail::multi_modify<detail::correct::correct_polygon>
|
|
{};
|
|
|
|
|
|
} // namespace dispatch
|
|
#endif // DOXYGEN_NO_DISPATCH
|
|
|
|
|
|
namespace resolve_strategy
|
|
{
|
|
|
|
template
|
|
<
|
|
typename Strategy,
|
|
bool IsUmbrella = strategies::detail::is_umbrella_strategy<Strategy>::value
|
|
>
|
|
struct correct
|
|
{
|
|
template <typename Geometry>
|
|
static inline void apply(Geometry& geometry, Strategy const& strategy)
|
|
{
|
|
dispatch::correct<Geometry>::apply(geometry, strategy);
|
|
}
|
|
};
|
|
|
|
template <typename Strategy>
|
|
struct correct<Strategy, false>
|
|
{
|
|
template <typename Geometry>
|
|
static inline void apply(Geometry& geometry, Strategy const& strategy)
|
|
{
|
|
// NOTE: calculate_point_order strategy should probably be used here instead.
|
|
using geometry::strategies::area::services::strategy_converter;
|
|
dispatch::correct<Geometry>::apply(geometry, strategy_converter<Strategy>::get(strategy));
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct correct<default_strategy, false>
|
|
{
|
|
template <typename Geometry>
|
|
static inline void apply(Geometry& geometry, default_strategy const& )
|
|
{
|
|
// NOTE: calculate_point_order strategy should probably be used here instead.
|
|
using strategy_type = typename strategies::area::services::default_strategy
|
|
<
|
|
Geometry
|
|
>::type;
|
|
dispatch::correct<Geometry>::apply(geometry, strategy_type());
|
|
}
|
|
};
|
|
|
|
} // namespace resolve_strategy
|
|
|
|
|
|
namespace resolve_dynamic
|
|
{
|
|
|
|
template <typename Geometry, typename Tag = typename tag<Geometry>::type>
|
|
struct correct
|
|
{
|
|
template <typename Strategy>
|
|
static inline void apply(Geometry& geometry, Strategy const& strategy)
|
|
{
|
|
concepts::check<Geometry>();
|
|
resolve_strategy::correct<Strategy>::apply(geometry, strategy);
|
|
}
|
|
};
|
|
|
|
template <typename Geometry>
|
|
struct correct<Geometry, dynamic_geometry_tag>
|
|
{
|
|
template <typename Strategy>
|
|
static inline void apply(Geometry& geometry, Strategy const& strategy)
|
|
{
|
|
traits::visit<Geometry>::apply([&](auto & g)
|
|
{
|
|
correct<util::remove_cref_t<decltype(g)>>::apply(g, strategy);
|
|
}, geometry);
|
|
}
|
|
};
|
|
|
|
template <typename Geometry>
|
|
struct correct<Geometry, geometry_collection_tag>
|
|
{
|
|
template <typename Strategy>
|
|
static inline void apply(Geometry& geometry, Strategy const& strategy)
|
|
{
|
|
detail::visit_breadth_first([&](auto & g)
|
|
{
|
|
correct<util::remove_cref_t<decltype(g)>>::apply(g, strategy);
|
|
return true;
|
|
}, geometry);
|
|
}
|
|
};
|
|
|
|
|
|
} // namespace resolve_dynamic
|
|
|
|
|
|
/*!
|
|
\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 <typename Geometry>
|
|
inline void correct(Geometry& geometry)
|
|
{
|
|
resolve_dynamic::correct<Geometry>::apply(geometry, default_strategy());
|
|
}
|
|
|
|
/*!
|
|
\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 <typename Geometry, typename Strategy>
|
|
inline void correct(Geometry& geometry, Strategy const& strategy)
|
|
{
|
|
resolve_dynamic::correct<Geometry>::apply(geometry, strategy);
|
|
}
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
}} // namespace boost::geometry
|
|
|
|
|
|
#endif // BOOST_GEOMETRY_ALGORITHMS_CORRECT_HPP
|