detail/covered_by/interface.hpp

0001 // Boost.Geometry (aka GGL, Generic Geometry Library)
0002
0003 // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
0004 // Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
0005 // Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
0006
0007 // This file was modified by Oracle on 2013-2021.
0008 // Modifications copyright (c) 2013-2021 Oracle and/or its affiliates.
0009 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
0010
0011 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
0012 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
0013
0014 // Use, modification and distribution is subject to the Boost Software License,
0015 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
0016 // http://www.boost.org/LICENSE_1_0.txt)
0017
0018 #ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_COVERED_BY_INTERFACE_HPP
0019 #define BOOST_GEOMETRY_ALGORITHMS_DETAIL_COVERED_BY_INTERFACE_HPP
0020
0021
0022 #include <boost/geometry/algorithms/detail/within/interface.hpp>
0023 #include <boost/geometry/algorithms/not_implemented.hpp>
0024
0025 #include <boost/geometry/strategies/default_strategy.hpp>
0026 #include <boost/geometry/strategies/detail.hpp>
0027 #include <boost/geometry/strategies/relate/services.hpp>
0028
0029
0030 namespace boost { namespace geometry
0031 {
0032
0033 #ifndef DOXYGEN_NO_DISPATCH
0034 namespace dispatch
0035 {
0036
0037 template
0038 <
0039     typename Geometry1,
0040     typename Geometry2,
0041     typename Tag1 = tag_t<Geometry1>,
0042     typename Tag2 = tag_t<Geometry2>
0043 >
0044 struct covered_by
0045     : not_implemented<Tag1, Tag2>
0046 {};
0047
0048 } // namespace dispatch
0049 #endif // DOXYGEN_NO_DISPATCH
0050
0051
0052 namespace resolve_strategy {
0053
0054 template
0055 <
0056     typename Strategy,
0057     bool IsUmbrella = strategies::detail::is_umbrella_strategy<Strategy>::value
0058 >
0059 struct covered_by
0060 {
0061     template <typename Geometry1, typename Geometry2>
0062     static inline bool apply(Geometry1 const& geometry1,
0063                              Geometry2 const& geometry2,
0064                              Strategy const& strategy)
0065     {
0066         concepts::within::check<Geometry1, Geometry2, Strategy>();
0067         concepts::check<Geometry1 const>();
0068         concepts::check<Geometry2 const>();
0069         assert_dimension_equal<Geometry1, Geometry2>();
0070
0071         return dispatch::covered_by
0072             <
0073                 Geometry1, Geometry2
0074             >::apply(geometry1, geometry2, strategy);
0075     }
0076 };
0077
0078 template <typename Strategy>
0079 struct covered_by<Strategy, false>
0080 {
0081     template <typename Geometry1, typename Geometry2>
0082     static inline bool apply(Geometry1 const& geometry1,
0083                              Geometry2 const& geometry2,
0084                              Strategy const& strategy)
0085     {
0086         using strategies::relate::services::strategy_converter;
0087
0088         return covered_by
0089             <
0090                 decltype(strategy_converter<Strategy>::get(strategy))
0091             >::apply(geometry1, geometry2,
0092                         strategy_converter<Strategy>::get(strategy));
0093     }
0094 };
0095
0096 template <>
0097 struct covered_by<default_strategy, false>
0098 {
0099     template <typename Geometry1, typename Geometry2>
0100     static inline bool apply(Geometry1 const& geometry1,
0101                              Geometry2 const& geometry2,
0102                              default_strategy)
0103     {
0104         typedef typename strategies::relate::services::default_strategy
0105             <
0106                 Geometry1,
0107                 Geometry2
0108             >::type strategy_type;
0109
0110         return covered_by
0111             <
0112                 strategy_type
0113             >::apply(geometry1, geometry2, strategy_type());
0114     }
0115 };
0116
0117 } // namespace resolve_strategy
0118
0119
0120 namespace resolve_dynamic {
0121
0122 template
0123 <
0124     typename Geometry1, typename Geometry2,
0125     typename Tag1 = geometry::tag_t<Geometry1>,
0126     typename Tag2 = geometry::tag_t<Geometry2>
0127 >
0128 struct covered_by
0129 {
0130     template <typename Strategy>
0131     static inline bool apply(Geometry1 const& geometry1,
0132                              Geometry2 const& geometry2,
0133                              Strategy const& strategy)
0134     {
0135         return resolve_strategy::covered_by
0136             <
0137                 Strategy
0138             >::apply(geometry1, geometry2, strategy);
0139     }
0140 };
0141
0142 template <typename Geometry1, typename Geometry2, typename Tag2>
0143 struct covered_by<Geometry1, Geometry2, dynamic_geometry_tag, Tag2>
0144 {
0145     template <typename Strategy>
0146     static inline bool apply(Geometry1 const& geometry1,
0147                              Geometry2 const& geometry2,
0148                              Strategy const& strategy)
0149     {
0150         bool result = false;
0151         traits::visit<Geometry1>::apply([&](auto const& g1)
0152         {
0153             result = resolve_strategy::covered_by
0154                 <
0155                     Strategy
0156                 >::apply(g1, geometry2, strategy);
0157         }, geometry1);
0158         return result;
0159     }
0160 };
0161
0162 template <typename Geometry1, typename Geometry2, typename Tag1>
0163 struct covered_by<Geometry1, Geometry2, Tag1, dynamic_geometry_tag>
0164 {
0165     template <typename Strategy>
0166     static inline bool apply(Geometry1 const& geometry1,
0167                              Geometry2 const& geometry2,
0168                              Strategy const& strategy)
0169     {
0170         bool result = false;
0171         traits::visit<Geometry2>::apply([&](auto const& g2)
0172         {
0173             result = resolve_strategy::covered_by
0174                 <
0175                     Strategy
0176                 >::apply(geometry1, g2, strategy);
0177         }, geometry2);
0178         return result;
0179     }
0180 };
0181
0182 template <typename Geometry1, typename Geometry2>
0183 struct covered_by<Geometry1, Geometry2, dynamic_geometry_tag, dynamic_geometry_tag>
0184 {
0185     template <typename Strategy>
0186     static inline bool apply(Geometry1 const& geometry1,
0187                              Geometry2 const& geometry2,
0188                              Strategy const& strategy)
0189     {
0190         bool result = false;
0191         traits::visit<Geometry1, Geometry2>::apply([&](auto const& g1, auto const& g2)
0192         {
0193             result = resolve_strategy::covered_by
0194                 <
0195                     Strategy
0196                 >::apply(g1, g2, strategy);
0197         }, geometry1, geometry2);
0198         return result;
0199     }
0200 };
0201
0202 } // namespace resolve_dynamic
0203
0204
0205 /*!
0206 \brief \brief_check12{is inside or on border}
0207 \ingroup covered_by
0208 \details \details_check12{covered_by, is inside or on border}.
0209 \tparam Geometry1 \tparam_geometry
0210 \tparam Geometry2 \tparam_geometry
0211 \param geometry1 \param_geometry which might be inside or on the border of the second geometry
0212 \param geometry2 \param_geometry which might cover the first geometry
0213 \return true if geometry1 is inside of or on the border of geometry2,
0214     else false
0215 \note The default strategy is used for covered_by detection
0216
0217 \qbk{[include reference/algorithms/covered_by.qbk]}
0218 \qbk{
0219 [heading Examples]
0220 [covered_by]
0221 [covered_by_output]
0222 }
0223  */
0224 template<typename Geometry1, typename Geometry2>
0225 inline bool covered_by(Geometry1 const& geometry1, Geometry2 const& geometry2)
0226 {
0227     return resolve_dynamic::covered_by
0228         <
0229             Geometry1, Geometry2
0230         >::apply(geometry1, geometry2, default_strategy());
0231 }
0232
0233 /*!
0234 \brief \brief_check12{is inside or on border} \brief_strategy
0235 \ingroup covered_by
0236 \details \details_check12{covered_by, is inside or on border}, \brief_strategy. \details_strategy_reasons
0237 \tparam Geometry1 \tparam_geometry
0238 \tparam Geometry2 \tparam_geometry
0239 \param geometry1 \param_geometry which might be inside or on the border of the second geometry
0240 \param geometry2 \param_geometry which might cover the first geometry
0241 \param strategy strategy to be used
0242 \return true if geometry1 is inside of or on the border of geometry2,
0243     else false
0244
0245 \qbk{distinguish,with strategy}
0246 \qbk{[include reference/algorithms/covered_by.qbk]}
0247
0248 */
0249 template<typename Geometry1, typename Geometry2, typename Strategy>
0250 inline bool covered_by(Geometry1 const& geometry1, Geometry2 const& geometry2,
0251         Strategy const& strategy)
0252 {
0253     return resolve_dynamic::covered_by
0254         <
0255             Geometry1, Geometry2
0256         >::apply(geometry1, geometry2, strategy);
0257 }
0258
0259 }} // namespace boost::geometry
0260
0261 #endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_COVERED_BY_INTERFACE_HPP