ceph/src/boost/boost/geometry/policies/robustness/get_rescale_policy.hpp

   1 // Boost.Geometry (aka GGL, Generic Geometry Library)
   2
   3 // Copyright (c) 2014-2015 Barend Gehrels, Amsterdam, the Netherlands.
   4 // Copyright (c) 2014-2015 Bruno Lalande, Paris, France.
   5 // Copyright (c) 2014-2015 Mateusz Loskot, London, UK.
   6 // Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
   7
   8 // This file was modified by Oracle on 2015.
   9 // Modifications copyright (c) 2015, Oracle and/or its affiliates.
  10
  11 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
  12
  13 // Use, modification and distribution is subject to the Boost Software License,
  14 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  15 // http://www.boost.org/LICENSE_1_0.txt)
  16
  17 #ifndef BOOST_GEOMETRY_POLICIES_ROBUSTNESS_GET_RESCALE_POLICY_HPP
  18 #define BOOST_GEOMETRY_POLICIES_ROBUSTNESS_GET_RESCALE_POLICY_HPP
  19
  20
  21 #include <cstddef>
  22
  23 #include <boost/mpl/assert.hpp>
  24 #include <boost/type_traits/is_floating_point.hpp>
  25 #include <boost/type_traits/is_same.hpp>
  26
  27 #include <boost/geometry/core/assert.hpp>
  28 #include <boost/geometry/core/tag_cast.hpp>
  29
  30 #include <boost/geometry/algorithms/envelope.hpp>
  31 #include <boost/geometry/algorithms/expand.hpp>
  32 #include <boost/geometry/algorithms/is_empty.hpp>
  33 #include <boost/geometry/algorithms/detail/recalculate.hpp>
  34 #include <boost/geometry/algorithms/detail/get_max_size.hpp>
  35 #include <boost/geometry/policies/robustness/robust_type.hpp>
  36
  37 #include <boost/geometry/geometries/point.hpp>
  38 #include <boost/geometry/geometries/box.hpp>
  39
  40 #include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
  41 #include <boost/geometry/policies/robustness/rescale_policy.hpp>
  42
  43 #include <boost/geometry/util/promote_floating_point.hpp>
  44
  45 namespace boost { namespace geometry
  46 {
  47
  48 #ifndef DOXYGEN_NO_DETAIL
  49 namespace detail { namespace get_rescale_policy
  50 {
  51
  52 template
  53 <
  54     typename Box,
  55     typename Point,
  56     typename RobustPoint,
  57     typename Factor
  58 >
  59 inline void scale_box_to_integer_range(Box const& box,
  60                                        Point& min_point,
  61                                        RobustPoint& min_robust_point,
  62                                        Factor& factor)
  63 {
  64     // Scale box to integer-range
  65     typedef typename promote_floating_point
  66         <
  67             typename geometry::coordinate_type<Point>::type
  68         >::type num_type;
  69     num_type const diff = boost::numeric_cast<num_type>(detail::get_max_size(box));
  70     num_type const range = 10000000.0; // Define a large range to get precise integer coordinates
  71     num_type const half = 0.5;
  72     if (math::equals(diff, num_type())
  73         || diff >= range
  74         || ! boost::math::isfinite(diff))
  75     {
  76         factor = 1;
  77     }
  78     else
  79     {
  80         factor = boost::numeric_cast<num_type>(
  81             boost::numeric_cast<boost::long_long_type>(half + range / diff));
  82         BOOST_GEOMETRY_ASSERT(factor >= 1);
  83     }
  84
  85     // Assign input/output minimal points
  86     detail::assign_point_from_index<0>(box, min_point);
  87     num_type const two = 2;
  88     boost::long_long_type const min_coordinate
  89         = boost::numeric_cast<boost::long_long_type>(-range / two);
  90     assign_values(min_robust_point, min_coordinate, min_coordinate);
  91 }
  92
  93 template <typename Point, typename RobustPoint, typename Geometry, typename Factor>
  94 static inline void init_rescale_policy(Geometry const& geometry,
  95         Point& min_point,
  96         RobustPoint& min_robust_point,
  97         Factor& factor)
  98 {
  99     if (geometry::is_empty(geometry))
 100     {
 101         return;
 102     }
 103
 104     // Get bounding boxes
 105     model::box<Point> env = geometry::return_envelope<model::box<Point> >(geometry);
 106
 107     scale_box_to_integer_range(env, min_point, min_robust_point, factor);
 108 }
 109
 110 template <typename Point, typename RobustPoint, typename Geometry1, typename Geometry2, typename Factor>
 111 static inline void init_rescale_policy(Geometry1 const& geometry1,
 112         Geometry2 const& geometry2,
 113         Point& min_point,
 114         RobustPoint& min_robust_point,
 115         Factor& factor)
 116 {
 117     // Get bounding boxes (when at least one of the geometries is not empty)
 118     bool const is_empty1 = geometry::is_empty(geometry1);
 119     bool const is_empty2 = geometry::is_empty(geometry2);
 120     if (is_empty1 && is_empty2)
 121     {
 122         return;
 123     }
 124
 125     model::box<Point> env;
 126     if (is_empty1)
 127     {
 128         geometry::envelope(geometry2, env);
 129     }
 130     else if (is_empty2)
 131     {
 132         geometry::envelope(geometry1, env);
 133     }
 134     else
 135     {
 136         // The following approach (envelope + expand) may not give the
 137         // optimal MBR when then two geometries are in the spherical
 138         // equatorial or geographic coordinate systems.
 139         // TODO: implement envelope for two (or possibly more geometries)
 140         geometry::envelope(geometry1, env);
 141         model::box<Point> env2 = geometry::return_envelope
 142             <
 143                 model::box<Point>
 144             >(geometry2);
 145         geometry::expand(env, env2);
 146     }
 147
 148     scale_box_to_integer_range(env, min_point, min_robust_point, factor);
 149 }
 150
 151
 152 template
 153 <
 154     typename Point,
 155     bool IsFloatingPoint
 156 >
 157 struct rescale_policy_type
 158 {
 159     typedef no_rescale_policy type;
 160 };
 161
 162 // We rescale only all FP types
 163 template
 164 <
 165     typename Point
 166 >
 167 struct rescale_policy_type<Point, true>
 168 {
 169     typedef typename geometry::coordinate_type<Point>::type coordinate_type;
 170     typedef model::point
 171     <
 172         typename detail::robust_type<coordinate_type>::type,
 173         geometry::dimension<Point>::value,
 174         typename geometry::coordinate_system<Point>::type
 175     > robust_point_type;
 176     typedef typename promote_floating_point<coordinate_type>::type factor_type;
 177     typedef detail::robust_policy<Point, robust_point_type, factor_type> type;
 178 };
 179
 180 template <typename Policy>
 181 struct get_rescale_policy
 182 {
 183     template <typename Geometry>
 184     static inline Policy apply(Geometry const& geometry)
 185     {
 186         typedef typename point_type<Geometry>::type point_type;
 187         typedef typename geometry::coordinate_type<Geometry>::type coordinate_type;
 188         typedef typename promote_floating_point<coordinate_type>::type factor_type;
 189         typedef model::point
 190         <
 191             typename detail::robust_type<coordinate_type>::type,
 192             geometry::dimension<point_type>::value,
 193             typename geometry::coordinate_system<point_type>::type
 194         > robust_point_type;
 195
 196         point_type min_point;
 197         robust_point_type min_robust_point;
 198         factor_type factor;
 199         init_rescale_policy(geometry, min_point, min_robust_point, factor);
 200
 201         return Policy(min_point, min_robust_point, factor);
 202     }
 203
 204     template <typename Geometry1, typename Geometry2>
 205     static inline Policy apply(Geometry1 const& geometry1, Geometry2 const& geometry2)
 206     {
 207         typedef typename point_type<Geometry1>::type point_type;
 208         typedef typename geometry::coordinate_type<Geometry1>::type coordinate_type;
 209         typedef typename promote_floating_point<coordinate_type>::type factor_type;
 210         typedef model::point
 211         <
 212             typename detail::robust_type<coordinate_type>::type,
 213             geometry::dimension<point_type>::value,
 214             typename geometry::coordinate_system<point_type>::type
 215         > robust_point_type;
 216
 217         point_type min_point;
 218         robust_point_type min_robust_point;
 219         factor_type factor;
 220         init_rescale_policy(geometry1, geometry2, min_point, min_robust_point, factor);
 221
 222         return Policy(min_point, min_robust_point, factor);
 223     }
 224 };
 225
 226 // Specialization for no-rescaling
 227 template <>
 228 struct get_rescale_policy<no_rescale_policy>
 229 {
 230     template <typename Geometry>
 231     static inline no_rescale_policy apply(Geometry const& )
 232     {
 233         return no_rescale_policy();
 234     }
 235
 236     template <typename Geometry1, typename Geometry2>
 237     static inline no_rescale_policy apply(Geometry1 const& , Geometry2 const& )
 238     {
 239         return no_rescale_policy();
 240     }
 241 };
 242
 243
 244 }} // namespace detail::get_rescale_policy
 245 #endif // DOXYGEN_NO_DETAIL
 246
 247 template<typename Point>
 248 struct rescale_policy_type
 249     : public detail::get_rescale_policy::rescale_policy_type
 250     <
 251         Point,
 252 #if defined(BOOST_GEOMETRY_NO_ROBUSTNESS)
 253         false
 254 #else
 255         boost::is_floating_point
 256             <
 257                 typename geometry::coordinate_type<Point>::type
 258             >::type::value
 259         &&
 260         boost::is_same
 261             <
 262                 typename geometry::coordinate_system<Point>::type,
 263                 geometry::cs::cartesian
 264             >::value
 265 #endif
 266     >
 267 {
 268     static const bool is_point
 269         = boost::is_same
 270             <
 271                 typename geometry::tag<Point>::type,
 272                 geometry::point_tag
 273             >::type::value;
 274
 275     BOOST_MPL_ASSERT_MSG((is_point),
 276                          INVALID_INPUT_GEOMETRY,
 277                          (typename geometry::tag<Point>::type));
 278 };
 279
 280
 281 template
 282 <
 283     typename Geometry1,
 284     typename Geometry2,
 285     typename Tag1 = typename tag_cast
 286     <
 287         typename tag<Geometry1>::type,
 288         box_tag,
 289         pointlike_tag,
 290         linear_tag,
 291         areal_tag
 292     >::type,
 293     typename Tag2 = typename tag_cast
 294     <
 295         typename tag<Geometry2>::type,
 296         box_tag,
 297         pointlike_tag,
 298         linear_tag,
 299         areal_tag
 300     >::type
 301 >
 302 struct rescale_overlay_policy_type
 303     // Default: no rescaling
 304     : public detail::get_rescale_policy::rescale_policy_type
 305         <
 306             typename geometry::point_type<Geometry1>::type,
 307             false
 308         >
 309 {};
 310
 311 // Areal/areal: get rescale policy based on coordinate type
 312 template
 313 <
 314     typename Geometry1,
 315     typename Geometry2
 316 >
 317 struct rescale_overlay_policy_type<Geometry1, Geometry2, areal_tag, areal_tag>
 318     : public rescale_policy_type
 319         <
 320             typename geometry::point_type<Geometry1>::type
 321         >
 322 {};
 323
 324
 325 template <typename Policy, typename Geometry>
 326 inline Policy get_rescale_policy(Geometry const& geometry)
 327 {
 328     return detail::get_rescale_policy::get_rescale_policy<Policy>::apply(geometry);
 329 }
 330
 331 template <typename Policy, typename Geometry1, typename Geometry2>
 332 inline Policy get_rescale_policy(Geometry1 const& geometry1, Geometry2 const& geometry2)
 333 {
 334     return detail::get_rescale_policy::get_rescale_policy<Policy>::apply(geometry1, geometry2);
 335 }
 336
 337
 338 }} // namespace boost::geometry
 339
 340
 341 #endif // BOOST_GEOMETRY_POLICIES_ROBUSTNESS_GET_RESCALE_POLICY_HPP