Merge branch 'develop'

Author: vissarion

include/boost/geometry/algorithms/detail/overlay/check_enrich.hpp

@@ -21,6 +21,7 @@
 #include <cstddef>
 #include <vector>
 
+#include <boost/core/ignore_unused.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/value_type.hpp>
@@ -66,6 +67,8 @@ inline void display(MetaTurn const& meta_turn, const char* reason = "")
         //<< " -> " << op_index
         << " " << reason
         << std::endl;
+#else
+boost::ignore_unused(meta_turn, reason);
 #endif
 }
 

include/boost/geometry/strategies/geographic/distance_cross_track_box_box.hpp

@@ -189,8 +189,7 @@ struct result_from_distance
 
 public:
     template <typename T>
-    static inline return_type apply(this_strategy const& strategy,
-                                    T const& distance)
+    static inline return_type apply(this_strategy const& , T const& distance)
     {
         return static_cast<return_type>(distance);
     }

include/boost/geometry/strategies/normalize.hpp

@@ -1,7 +1,8 @@
 // Boost.Geometry (aka GGL, Generic Geometry Library)
 
-// Copyright (c) 2015-2020, Oracle and/or its affiliates.
+// Copyright (c) 2015-2025, Oracle and/or its affiliates.
 
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 
@@ -123,7 +124,7 @@ struct assign_loop<1, DimensionCount>
 template <typename PointIn, typename PointOut, bool IsEquatorial = true>
 struct normalize_point
 {
-    static inline void apply(PointIn const& point_in, PointOut& point_out)
+    static inline void apply(PointIn const& point_in, PointOut& point_out, bool exact = true)
     {
         using in_coordinate_type = coordinate_type_t<PointIn>;
 
@@ -135,7 +136,7 @@ struct normalize_point
                 typename geometry::detail::cs_angular_units<PointIn>::type,
                 IsEquatorial,
                 in_coordinate_type
-            >(longitude, latitude);
+            >(longitude, latitude, exact);
 
         assign_loop
             <
@@ -221,13 +222,13 @@ struct cartesian_box
 struct spherical_point
 {
     template <typename PointIn, typename PointOut>
-    static inline void apply(PointIn const& point_in, PointOut& point_out)
+    static inline void apply(PointIn const& point_in, PointOut& point_out, bool exact = true)
     {
         detail::normalize_point
             <
                 PointIn, PointOut,
                 (! std::is_same<cs_tag_t<PointIn>, spherical_polar_tag>::value)
-            >::apply(point_in, point_out);
+            >::apply(point_in, point_out, exact);
     }
 };
 

include/boost/geometry/strategies/spherical/point_in_point.hpp

@@ -5,11 +5,12 @@
 // Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
 // Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland
 
-// This file was modified by Oracle on 2013-2020.
-// Modifications copyright (c) 2013-2020, Oracle and/or its affiliates.
+// This file was modified by Oracle on 2013-2025.
+// Modifications copyright (c) 2013-2025, Oracle and/or its affiliates.
 
-// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
 // Contributed and/or modified by Menelaos Karavelas, 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.
@@ -67,13 +68,14 @@ class point_point_on_spheroid
     {
         static inline bool apply(Point1 const& point1, Point2 const& point2)
         {
-            typedef typename helper_geometry<Point1>::type helper_point_type1;
-            typedef typename helper_geometry<Point2>::type helper_point_type2;
+            using helper_point_type1 = typename helper_geometry<Point1>::type;
+            using helper_point_type2 = typename helper_geometry<Point2>::type;
 
             helper_point_type1 point1_normalized;
-            strategy::normalize::spherical_point::apply(point1, point1_normalized);
+            bool const exact_normalized = false;
+            strategy::normalize::spherical_point::apply(point1, point1_normalized, exact_normalized);
             helper_point_type2 point2_normalized;
-            strategy::normalize::spherical_point::apply(point2, point2_normalized);
+            strategy::normalize::spherical_point::apply(point2, point2_normalized, exact_normalized);
 
             return point_point_generic
                 <
@@ -87,11 +89,11 @@ class point_point_on_spheroid
     {
         static inline bool apply(Point1 const& point1, Point2 const& point2)
         {
-            typedef typename geometry::select_most_precise
+            using calculation_type = typename geometry::select_most_precise
                 <
                     typename fp_coordinate_type<Point1>::type,
                     typename fp_coordinate_type<Point2>::type
-                >::type calculation_type;
+                >::type;
 
             typename helper_geometry
                 <
@@ -149,7 +151,7 @@ namespace services
 template <typename PointLike1, typename PointLike2, typename Tag1, typename Tag2>
 struct default_strategy<PointLike1, PointLike2, Tag1, Tag2, pointlike_tag, pointlike_tag, spherical_tag, spherical_tag>
 {
-    typedef strategy::within::spherical_point_point type;
+    using type = strategy::within::spherical_point_point;
 };
 
 } // namespace services
@@ -166,7 +168,7 @@ namespace strategy { namespace covered_by { namespace services
 template <typename PointLike1, typename PointLike2, typename Tag1, typename Tag2>
 struct default_strategy<PointLike1, PointLike2, Tag1, Tag2, pointlike_tag, pointlike_tag, spherical_tag, spherical_tag>
 {
-    typedef strategy::within::spherical_point_point type;
+    using type = strategy::within::spherical_point_point;
 };
 
 }}} // namespace strategy::covered_by::services

include/boost/geometry/strategy/cartesian/side_by_triangle.hpp

@@ -33,6 +33,7 @@
 #include <boost/geometry/strategies/compare.hpp>
 #include <boost/geometry/strategies/side.hpp>
 
+#include <boost/geometry/util/promote_integral.hpp>
 #include <boost/geometry/util/select_calculation_type.hpp>
 #include <boost/geometry/util/select_most_precise.hpp>
 
@@ -205,23 +206,29 @@ public :
     template <typename P1, typename P2, typename P>
     static inline int apply(P1 const& p1, P2 const& p2, P const& p)
     {
-        using coor_t = typename select_calculation_type_alt<CalculationType, P1, P2, P>::type;
-
-        // Promote float->double, small int->int
-        using promoted_t = typename select_most_precise<coor_t, double>::type;
-
-        bool const are_all_integral_coordinates =
+        constexpr bool are_all_integral_coordinates =
             std::is_integral<coordinate_type_t<P1>>::value
             && std::is_integral<coordinate_type_t<P2>>::value
             && std::is_integral<coordinate_type_t<P>>::value;
 
+        // Promote float to double
+        // For integer: short -> int -> long
+        // For larger integers: long, long long, std::int64_t all stay as they are (on a Mac)
+        using coor_t = typename select_calculation_type_alt<CalculationType, P1, P2, P>::type;
+        using promoted_t = std::conditional_t
+            <
+                are_all_integral_coordinates,
+                typename promote_integral<coor_t>::type,
+                typename select_most_precise<coor_t, double>::type
+            >;
+
         eps_policy< math::detail::equals_factor_policy<promoted_t> > epsp;
-        promoted_t s = compute_side_value
+        promoted_t const s = compute_side_value
             <
                 coor_t, promoted_t, are_all_integral_coordinates
             >::apply(p1, p2, p, epsp);
 
-        promoted_t const zero = promoted_t();
+        static promoted_t const zero = promoted_t();
         return math::detail::equals_by_policy(s, zero, epsp.policy) ? 0
             : s > zero ? 1
             : -1;

include/boost/geometry/util/normalize_spheroidal_coordinates.hpp

@@ -2,8 +2,9 @@
 
 // Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
 
-// Copyright (c) 2015-2022, Oracle and/or its affiliates.
+// Copyright (c) 2015-2025, Oracle and/or its affiliates.
 
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
 // Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
 // Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
 // Contributed and/or modified by Adeel Ahmad, as part of Google Summer of Code 2018 program
@@ -151,11 +152,7 @@ struct constants_on_spheroid<CoordinateType, degree, false>
 template <typename Units, typename CoordinateType>
 inline CoordinateType latitude_convert_ep(CoordinateType const& lat)
 {
-    typedef math::detail::constants_on_spheroid
-            <
-                CoordinateType,
-                Units
-            > constants;
+    using constants = math::detail::constants_on_spheroid<CoordinateType, Units>;
 
     return constants::quarter_period() - lat;
 }
@@ -164,31 +161,21 @@ inline CoordinateType latitude_convert_ep(CoordinateType const& lat)
 template <typename Units, bool IsEquatorial, typename T>
 static bool is_latitude_pole(T const& lat)
 {
-    typedef math::detail::constants_on_spheroid
-        <
-            T,
-            Units
-        > constants;
+    using constants = math::detail::constants_on_spheroid<T, Units>;
 
     return math::equals(math::abs(IsEquatorial
                                     ? lat
                                     : math::latitude_convert_ep<Units>(lat)),
                         constants::quarter_period());
-
 }
 
 
 template <typename Units, typename T>
 static bool is_longitude_antimeridian(T const& lon)
 {
-    typedef math::detail::constants_on_spheroid
-        <
-            T,
-            Units
-        > constants;
+    using constants = math::detail::constants_on_spheroid<T, Units>;
 
     return math::equals(math::abs(lon), constants::half_period());
-
 }
 
 
@@ -218,7 +205,7 @@ struct latitude_convert_if_polar<Units, false>
 template <typename Units, typename CoordinateType, bool IsEquatorial = true>
 class normalize_spheroidal_coordinates
 {
-    typedef constants_on_spheroid<CoordinateType, Units> constants;
+    using constants = constants_on_spheroid<CoordinateType, Units>;
 
 protected:
     static inline CoordinateType normalize_up(CoordinateType const& value)
@@ -236,17 +223,22 @@ class normalize_spheroidal_coordinates
     }
 
 public:
-    static inline void apply(CoordinateType& longitude)
+    static inline void apply(CoordinateType& longitude, bool exact = true)
     {
         // normalize longitude
-        if (math::equals(math::abs(longitude), constants::half_period()))
+        CoordinateType const epsilon = std::numeric_limits<float>::epsilon();
+        static constexpr bool is_integer = std::numeric_limits<CoordinateType>::is_integer;
+
+        if (exact || is_integer ? math::equals(math::abs(longitude), constants::half_period())
+            : math::abs(math::abs(longitude) - constants::half_period()) <= epsilon)
         {
             longitude = constants::half_period();
         }
         else if (longitude > constants::half_period())
         {
             longitude = normalize_up(longitude);
-            if (math::equals(longitude, -constants::half_period()))
+            if (exact || is_integer ? math::equals(longitude, -constants::half_period())
+                : math::abs(longitude + constants::half_period()) <= epsilon)
             {
                 longitude = constants::half_period();
             }
@@ -259,7 +251,8 @@ class normalize_spheroidal_coordinates
 
     static inline void apply(CoordinateType& longitude,
                              CoordinateType& latitude,
-                             bool normalize_poles = true)
+                             bool normalize_poles = true,
+                             bool exact = true)
     {
         latitude_convert_if_polar<Units, IsEquatorial>::apply(latitude);
 
@@ -288,7 +281,7 @@ class normalize_spheroidal_coordinates
 #endif // BOOST_GEOMETRY_NORMALIZE_LATITUDE
 
         // normalize longitude
-        apply(longitude);
+        apply(longitude, exact);
 
         // finally normalize poles
         if (normalize_poles)
@@ -317,7 +310,7 @@ class normalize_spheroidal_coordinates
 template <typename Units, typename CoordinateType>
 inline void normalize_angle_loop(CoordinateType& angle)
 {
-    typedef constants_on_spheroid<CoordinateType, Units> constants;
+    using constants = constants_on_spheroid<CoordinateType, Units>;
     CoordinateType const pi = constants::half_period();
     CoordinateType const two_pi = constants::period();
     while (angle > pi)
@@ -329,7 +322,7 @@ inline void normalize_angle_loop(CoordinateType& angle)
 template <typename Units, typename CoordinateType>
 inline void normalize_angle_cond(CoordinateType& angle)
 {
-    typedef constants_on_spheroid<CoordinateType, Units> constants;
+    using constants = constants_on_spheroid<CoordinateType, Units>;
     CoordinateType const pi = constants::half_period();
     CoordinateType const two_pi = constants::period();
     if (angle > pi)
@@ -353,22 +346,24 @@ inline void normalize_angle_cond(CoordinateType& angle)
 */
 template <typename Units, typename CoordinateType>
 inline void normalize_spheroidal_coordinates(CoordinateType& longitude,
-                                             CoordinateType& latitude)
+                                             CoordinateType& latitude,
+                                             bool exact = true)
 {
     detail::normalize_spheroidal_coordinates
         <
             Units, CoordinateType
-        >::apply(longitude, latitude);
+        >::apply(longitude, latitude, true, exact);
 }
 
 template <typename Units, bool IsEquatorial, typename CoordinateType>
 inline void normalize_spheroidal_coordinates(CoordinateType& longitude,
-                                             CoordinateType& latitude)
+                                             CoordinateType& latitude,
+                                             bool exact = true)
 {
     detail::normalize_spheroidal_coordinates
         <
             Units, CoordinateType, IsEquatorial
-        >::apply(longitude, latitude);
+        >::apply(longitude, latitude, true, exact);
 }
 
 /*!
@@ -381,12 +376,12 @@ inline void normalize_spheroidal_coordinates(CoordinateType& longitude,
 \ingroup utility
 */
 template <typename Units, typename CoordinateType>
-inline void normalize_longitude(CoordinateType& longitude)
+inline void normalize_longitude(CoordinateType& longitude, bool exact = true)
 {
     detail::normalize_spheroidal_coordinates
         <
             Units, CoordinateType
-        >::apply(longitude);
+        >::apply(longitude, exact);
 }
 
 /*!
@@ -400,7 +395,7 @@ inline void normalize_longitude(CoordinateType& longitude)
 template <typename Units, typename CoordinateType>
 inline void normalize_azimuth(CoordinateType& angle)
 {
-    normalize_longitude<Units, CoordinateType>(angle);
+    math::normalize_longitude<Units, CoordinateType>(angle, true);
 }
 
 /*!
@@ -435,7 +430,7 @@ inline CoordinateType longitude_distance_signed(CoordinateType const& longitude1
                                                 CoordinateType const& longitude2)
 {
     CoordinateType diff = longitude2 - longitude1;
-    math::normalize_longitude<Units, CoordinateType>(diff);
+    math::normalize_longitude<Units, CoordinateType>(diff, true);
     return diff;
 }
 
@@ -453,10 +448,7 @@ template <typename Units, typename CoordinateType>
 inline CoordinateType longitude_distance_unsigned(CoordinateType const& longitude1,
                                                   CoordinateType const& longitude2)
 {
-    typedef math::detail::constants_on_spheroid
-        <
-            CoordinateType, Units
-        > constants;
+    using constants = math::detail::constants_on_spheroid<CoordinateType, Units>;
 
     CoordinateType const c0 = 0;
     CoordinateType diff = longitude_distance_signed<Units>(longitude1, longitude2);