ceph/src/boost/boost/geometry/algorithms/area.hpp

   1 // Boost.Geometry (aka GGL, Generic Geometry Library)
   2
   3 // Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
   4 // Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
   5 // Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
   6
   7 // This file was modified by Oracle on 2017.
   8 // Modifications copyright (c) 2017 Oracle and/or its affiliates.
   9 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
  10
  11 // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
  12 // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
  13
  14 // Use, modification and distribution is subject to the Boost Software License,
  15 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  16 // http://www.boost.org/LICENSE_1_0.txt)
  17
  18 #ifndef BOOST_GEOMETRY_ALGORITHMS_AREA_HPP
  19 #define BOOST_GEOMETRY_ALGORITHMS_AREA_HPP
  20
  21 #include <boost/concept_check.hpp>
  22 #include <boost/mpl/if.hpp>
  23 #include <boost/range/functions.hpp>
  24 #include <boost/range/metafunctions.hpp>
  25
  26 #include <boost/variant/apply_visitor.hpp>
  27 #include <boost/variant/static_visitor.hpp>
  28 #include <boost/variant/variant_fwd.hpp>
  29
  30 #include <boost/geometry/core/closure.hpp>
  31 #include <boost/geometry/core/exterior_ring.hpp>
  32 #include <boost/geometry/core/interior_rings.hpp>
  33 #include <boost/geometry/core/point_order.hpp>
  34 #include <boost/geometry/core/point_type.hpp>
  35 #include <boost/geometry/core/ring_type.hpp>
  36 #include <boost/geometry/core/tags.hpp>
  37
  38 #include <boost/geometry/geometries/concepts/check.hpp>
  39
  40 #include <boost/geometry/algorithms/detail/calculate_null.hpp>
  41 #include <boost/geometry/algorithms/detail/calculate_sum.hpp>
  42 // #include <boost/geometry/algorithms/detail/throw_on_empty_input.hpp>
  43 #include <boost/geometry/algorithms/detail/multi_sum.hpp>
  44
  45 #include <boost/geometry/strategies/area.hpp>
  46 #include <boost/geometry/strategies/default_area_result.hpp>
  47
  48 #include <boost/geometry/strategies/concepts/area_concept.hpp>
  49
  50 #include <boost/geometry/util/math.hpp>
  51 #include <boost/geometry/util/order_as_direction.hpp>
  52 #include <boost/geometry/views/closeable_view.hpp>
  53 #include <boost/geometry/views/reversible_view.hpp>
  54
  55
  56 namespace boost { namespace geometry
  57 {
  58
  59 #ifndef DOXYGEN_NO_DETAIL
  60 namespace detail { namespace area
  61 {
  62
  63 struct box_area
  64 {
  65     template <typename Box, typename Strategy>
  66     static inline typename coordinate_type<Box>::type
  67     apply(Box const& box, Strategy const&)
  68     {
  69         // Currently only works for 2D Cartesian boxes
  70         assert_dimension<Box, 2>();
  71
  72         return (get<max_corner, 0>(box) - get<min_corner, 0>(box))
  73              * (get<max_corner, 1>(box) - get<min_corner, 1>(box));
  74     }
  75 };
  76
  77
  78 template
  79 <
  80     iterate_direction Direction,
  81     closure_selector Closure
  82 >
  83 struct ring_area
  84 {
  85     template <typename Ring, typename Strategy>
  86     static inline typename Strategy::return_type
  87     apply(Ring const& ring, Strategy const& strategy)
  88     {
  89         BOOST_CONCEPT_ASSERT( (geometry::concepts::AreaStrategy<Strategy>) );
  90         assert_dimension<Ring, 2>();
  91
  92         // Ignore warning (because using static method sometimes) on strategy
  93         boost::ignore_unused_variable_warning(strategy);
  94
  95         // An open ring has at least three points,
  96         // A closed ring has at least four points,
  97         // if not, there is no (zero) area
  98         if (boost::size(ring)
  99                 < core_detail::closure::minimum_ring_size<Closure>::value)
 100         {
 101             return typename Strategy::return_type();
 102         }
 103
 104         typedef typename reversible_view<Ring const, Direction>::type rview_type;
 105         typedef typename closeable_view
 106             <
 107                 rview_type const, Closure
 108             >::type view_type;
 109         typedef typename boost::range_iterator<view_type const>::type iterator_type;
 110
 111         rview_type rview(ring);
 112         view_type view(rview);
 113         typename Strategy::state_type state;
 114         iterator_type it = boost::begin(view);
 115         iterator_type end = boost::end(view);
 116
 117         for (iterator_type previous = it++;
 118             it != end;
 119             ++previous, ++it)
 120         {
 121             strategy.apply(*previous, *it, state);
 122         }
 123
 124         return strategy.result(state);
 125     }
 126 };
 127
 128
 129 }} // namespace detail::area
 130
 131
 132 #endif // DOXYGEN_NO_DETAIL
 133
 134
 135 #ifndef DOXYGEN_NO_DISPATCH
 136 namespace dispatch
 137 {
 138
 139 template
 140 <
 141     typename Geometry,
 142     typename Tag = typename tag<Geometry>::type
 143 >
 144 struct area : detail::calculate_null
 145 {
 146     template <typename Strategy>
 147     static inline typename Strategy::return_type apply(Geometry const& geometry, Strategy const& strategy)
 148     {
 149         return calculate_null::apply<typename Strategy::return_type>(geometry, strategy);
 150     }
 151 };
 152
 153
 154 template <typename Geometry>
 155 struct area<Geometry, box_tag> : detail::area::box_area
 156 {};
 157
 158
 159 template <typename Ring>
 160 struct area<Ring, ring_tag>
 161     : detail::area::ring_area
 162         <
 163             order_as_direction<geometry::point_order<Ring>::value>::value,
 164             geometry::closure<Ring>::value
 165         >
 166 {};
 167
 168
 169 template <typename Polygon>
 170 struct area<Polygon, polygon_tag> : detail::calculate_polygon_sum
 171 {
 172     template <typename Strategy>
 173     static inline typename Strategy::return_type apply(Polygon const& polygon, Strategy const& strategy)
 174     {
 175         return calculate_polygon_sum::apply<
 176             typename Strategy::return_type,
 177             detail::area::ring_area
 178                 <
 179                     order_as_direction<geometry::point_order<Polygon>::value>::value,
 180                     geometry::closure<Polygon>::value
 181                 >
 182             >(polygon, strategy);
 183     }
 184 };
 185
 186
 187 template <typename MultiGeometry>
 188 struct area<MultiGeometry, multi_polygon_tag> : detail::multi_sum
 189 {
 190     template <typename Strategy>
 191     static inline typename Strategy::return_type
 192     apply(MultiGeometry const& multi, Strategy const& strategy)
 193     {
 194         return multi_sum::apply
 195                <
 196                    typename Strategy::return_type,
 197                    area<typename boost::range_value<MultiGeometry>::type>
 198                >(multi, strategy);
 199     }
 200 };
 201
 202
 203 } // namespace dispatch
 204 #endif // DOXYGEN_NO_DISPATCH
 205
 206
 207 namespace resolve_variant {
 208
 209 template <typename Geometry>
 210 struct area
 211 {
 212     template <typename Strategy>
 213     static inline typename Strategy::return_type apply(Geometry const& geometry,
 214                                                        Strategy const& strategy)
 215     {
 216         return dispatch::area<Geometry>::apply(geometry, strategy);
 217     }
 218 };
 219
 220 template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
 221 struct area<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
 222 {
 223     template <typename Strategy>
 224     struct visitor: boost::static_visitor<typename Strategy::return_type>
 225     {
 226         Strategy const& m_strategy;
 227
 228         visitor(Strategy const& strategy): m_strategy(strategy) {}
 229
 230         template <typename Geometry>
 231         typename Strategy::return_type operator()(Geometry const& geometry) const
 232         {
 233             return area<Geometry>::apply(geometry, m_strategy);
 234         }
 235     };
 236
 237     template <typename Strategy>
 238     static inline typename Strategy::return_type
 239     apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
 240           Strategy const& strategy)
 241     {
 242         return boost::apply_visitor(visitor<Strategy>(strategy), geometry);
 243     }
 244 };
 245
 246 } // namespace resolve_variant
 247
 248
 249 /*!
 250 \brief \brief_calc{area}
 251 \ingroup area
 252 \details \details_calc{area}. \details_default_strategy
 253
 254 The area algorithm calculates the surface area of all geometries having a surface, namely
 255 box, polygon, ring, multipolygon. The units are the square of the units used for the points
 256 defining the surface. If subject geometry is defined in meters, then area is calculated
 257 in square meters.
 258
 259 The area calculation can be done in all three common coordinate systems, Cartesian, Spherical
 260 and Geographic as well.
 261
 262 \tparam Geometry \tparam_geometry
 263 \param geometry \param_geometry
 264 \return \return_calc{area}
 265
 266 \qbk{[include reference/algorithms/area.qbk]}
 267 \qbk{[heading Examples]}
 268 \qbk{[area] [area_output]}
 269 */
 270 template <typename Geometry>
 271 inline typename default_area_result<Geometry>::type area(Geometry const& geometry)
 272 {
 273     concepts::check<Geometry const>();
 274
 275     // TODO put this into a resolve_strategy stage
 276     //      (and take the return type from resolve_variant)
 277     typedef typename point_type<Geometry>::type point_type;
 278     typedef typename strategy::area::services::default_strategy
 279         <
 280             typename cs_tag<point_type>::type,
 281             point_type
 282         >::type strategy_type;
 283
 284     // detail::throw_on_empty_input(geometry);
 285
 286     return resolve_variant::area<Geometry>::apply(geometry, strategy_type());
 287 }
 288
 289 /*!
 290 \brief \brief_calc{area} \brief_strategy
 291 \ingroup area
 292 \details \details_calc{area} \brief_strategy. \details_strategy_reasons
 293 \tparam Geometry \tparam_geometry
 294 \tparam Strategy \tparam_strategy{Area}
 295 \param geometry \param_geometry
 296 \param strategy \param_strategy{area}
 297 \return \return_calc{area}
 298
 299 \qbk{distinguish,with strategy}
 300
 301 \qbk{
 302 [include reference/algorithms/area.qbk]
 303
 304 [heading Example]
 305 [area_with_strategy]
 306 [area_with_strategy_output]
 307
 308 [heading Available Strategies]
 309 \* [link geometry.reference.strategies.strategy_area_surveyor Surveyor (cartesian)]
 310 \* [link geometry.reference.strategies.strategy_area_spherical Spherical]
 311 [/link geometry.reference.strategies.strategy_area_geographic Geographic]
 312 }
 313  */
 314 template <typename Geometry, typename Strategy>
 315 inline typename Strategy::return_type area(
 316         Geometry const& geometry, Strategy const& strategy)
 317 {
 318     concepts::check<Geometry const>();
 319
 320     // detail::throw_on_empty_input(geometry);
 321
 322     return resolve_variant::area<Geometry>::apply(geometry, strategy);
 323 }
 324
 325
 326 }} // namespace boost::geometry
 327
 328
 329 #endif // BOOST_GEOMETRY_ALGORITHMS_AREA_HPP