[Boost-commit] svn:boost r85057 - in trunk: boost/geometry/extensions/gis/geographic/strategies libs/geometry/extensions/test/gis/latlong

Subject: [Boost-commit] svn:boost r85057 - in trunk: boost/geometry/extensions/gis/geographic/strategies libs/geometry/extensions/test/gis/latlong
From: barend.gehrels_at_[hidden]
Date: 2013-07-17 09:32:12

Author: barendgehrels
Date: 2013-07-17 09:32:12 EDT (Wed, 17 Jul 2013)
New Revision: 85057
URL: http://svn.boost.org/trac/boost/changeset/85057

Log:
[geometry] adapted extension andoyer to new structure strategies

Text files modified: 
   trunk/boost/geometry/extensions/gis/geographic/strategies/andoyer.hpp |   218 +++++++++++++++++++-------------------- 
   trunk/libs/geometry/extensions/test/gis/latlong/andoyer.cpp           |    18 ++                                      
   2 files changed, 118 insertions(+), 118 deletions(-)

Modified: trunk/boost/geometry/extensions/gis/geographic/strategies/andoyer.hpp
==============================================================================
--- trunk/boost/geometry/extensions/gis/geographic/strategies/andoyer.hpp	Wed Jul 17 05:48:43 2013	(r85056)
+++ trunk/boost/geometry/extensions/gis/geographic/strategies/andoyer.hpp	2013-07-17 09:32:12 EDT (Wed, 17 Jul 2013)	(r85057)
@@ -30,8 +30,6 @@
 /*!
 \brief Point-point distance approximation taking flattening into account
 \ingroup distance
-\tparam Point1 \tparam_first_point
-\tparam Point2 \tparam_second_point
 \tparam CalculationType \tparam_calculation
 \author After Andoyer, 19xx, republished 1950, republished by Meeus, 1999
 \note Although not so well-known, the approximation is very good: in all cases the results
@@ -45,101 +43,109 @@
 */
 template
 <
-    typename Point1,
-    typename Point2 = Point1,
+    typename RadiusType,
     typename CalculationType = void
 >
 class andoyer
 {
-    public :
-    typedef typename promote_floating_point
-        <
-            typename select_calculation_type
-                <
-                    Point1,
-                    Point2,
-                    CalculationType
-                >::type
-        >::type calculation_type;
-
-        inline andoyer()
-            : m_ellipsoid()
-        {}
-
-        explicit inline andoyer(calculation_type f)
-            : m_ellipsoid(f)
-        {}
-
-        explicit inline andoyer(geometry::detail::ellipsoid<calculation_type> const& e)
-            : m_ellipsoid(e)
-        {}
+public :
+    template <typename Point1, typename Point2>
+    struct calculation_type
+        : promote_floating_point
+          <
+              typename select_calculation_type
+                  <
+                      Point1,
+                      Point2,
+                      CalculationType
+                  >::type
+          >
+    {};
+
+    inline andoyer()
+        : m_ellipsoid()
+    {}
+
+    explicit inline andoyer(RadiusType f)
+        : m_ellipsoid(f)
+    {}
+
+    explicit inline andoyer(geometry::detail::ellipsoid<RadiusType> const& e)
+        : m_ellipsoid(e)
+    {}
+
+
+    template <typename Point1, typename Point2>
+    inline typename calculation_type<Point1, Point2>::type
+    apply(Point1 const& point1, Point2 const& point2) const
+    {
+        return calc<typename calculation_type<Point1, Point2>::type>
+            (
+                get_as_radian<0>(point1), get_as_radian<1>(point1),
+                get_as_radian<0>(point2), get_as_radian<1>(point2)
+            );
+    }
 
+    inline geometry::detail::ellipsoid<RadiusType> ellipsoid() const
+    {
+        return m_ellipsoid;
+    }
 
-        inline calculation_type apply(Point1 const& point1, Point2 const& point2) const
-        {
-            return calc(get_as_radian<0>(point1), get_as_radian<1>(point1),
-                            get_as_radian<0>(point2), get_as_radian<1>(point2));
-        }
+    inline RadiusType radius() const
+    {
+        return m_ellipsoid.a();
+    }
 
-        inline geometry::detail::ellipsoid<calculation_type> ellipsoid() const
-        {
-            return m_ellipsoid;
-        }
 
-        inline calculation_type radius() const
+private :
+    geometry::detail::ellipsoid<RadiusType> m_ellipsoid;
+
+    template <typename CT, typename T>
+    inline CT calc(T const& lon1,
+                T const& lat1,
+                T const& lon2,
+                T const& lat2) const
+    {
+        CT const G = (lat1 - lat2) / 2.0;
+        CT const lambda = (lon1 - lon2) / 2.0;
+
+        if (geometry::math::equals(lambda, 0.0)
+            && geometry::math::equals(G, 0.0))
         {
-            return m_ellipsoid.a();
+            return 0.0;
         }
 
+        CT const F = (lat1 + lat2) / 2.0;
 
-    private :
-        geometry::detail::ellipsoid<calculation_type> m_ellipsoid;
+        CT const sinG2 = math::sqr(sin(G));
+        CT const cosG2 = math::sqr(cos(G));
+        CT const sinF2 = math::sqr(sin(F));
+        CT const cosF2 = math::sqr(cos(F));
+        CT const sinL2 = math::sqr(sin(lambda));
+        CT const cosL2 = math::sqr(cos(lambda));
+
+        CT const S = sinG2 * cosL2 + cosF2 * sinL2;
+        CT const C = cosG2 * cosL2 + sinF2 * sinL2;
+
+        CT const c0 = 0;
+        CT const c1 = 1;
+        CT const c2 = 2;
+        CT const c3 = 3;
 
-        inline calculation_type calc(calculation_type const& lon1,
-                    calculation_type const& lat1,
-                    calculation_type const& lon2,
-                    calculation_type const& lat2) const
+        if (geometry::math::equals(S, c0) || geometry::math::equals(C, c0))
         {
-            calculation_type const G = (lat1 - lat2) / 2.0;
-            calculation_type const lambda = (lon1 - lon2) / 2.0;
+            return c0;
+        }
 
-            if (geometry::math::equals(lambda, 0.0)
-                && geometry::math::equals(G, 0.0))
-            {
-                return 0.0;
-            }
-
-            calculation_type const F = (lat1 + lat2) / 2.0;
-
-            calculation_type const sinG2 = math::sqr(sin(G));
-            calculation_type const cosG2 = math::sqr(cos(G));
-            calculation_type const sinF2 = math::sqr(sin(F));
-            calculation_type const cosF2 = math::sqr(cos(F));
-            calculation_type const sinL2 = math::sqr(sin(lambda));
-            calculation_type const cosL2 = math::sqr(cos(lambda));
-
-            calculation_type const S = sinG2 * cosL2 + cosF2 * sinL2;
-            calculation_type const C = cosG2 * cosL2 + sinF2 * sinL2;
-
-            calculation_type const c0 = 0;
-            calculation_type const c1 = 1;
-            calculation_type const c2 = 2;
-            calculation_type const c3 = 3;
-
-            if (geometry::math::equals(S, c0) || geometry::math::equals(C, c0))
-            {
-                return c0;
-            }
-
-            calculation_type const omega = atan(sqrt(S / C));
-            calculation_type const r3 = c3 * sqrt(S * C) / omega; // not sure if this is r or greek nu
-            calculation_type const D = c2 * omega * m_ellipsoid.a();
-            calculation_type const H1 = (r3 - c1) / (c2 * C);
-            calculation_type const H2 = (r3 + c1) / (c2 * S);
-            calculation_type const f = m_ellipsoid.f();
+        CT const omega = atan(sqrt(S / C));
+        CT const r3 = c3 * sqrt(S * C) / omega; // not sure if this is r or greek nu
+        CT const D = c2 * omega * m_ellipsoid.a();
+        CT const H1 = (r3 - c1) / (c2 * C);
+        CT const H2 = (r3 + c1) / (c2 * S);
+        CT const f = m_ellipsoid.f();
 
-            return D * (c1 + f * H1 * sinF2 * cosG2 - f * H2 * cosF2 * sinG2);
-        }
+        return D * (c1 + f * H1 * sinF2 * cosG2 - f * H2 * cosF2 * sinG2);
+    }
 };
 
 
@@ -147,57 +153,41 @@
 namespace services
 {
 
-template <typename Point1, typename Point2>
-struct tag<strategy::distance::andoyer<Point1, Point2> >
+template <typename RadiusType, typename CalculationType>
+struct tag<strategy::distance::andoyer<RadiusType, CalculationType> >
 {
     typedef strategy_tag_distance_point_point type;
 };
 
 
-template <typename Point1, typename Point2>
-struct return_type<strategy::distance::andoyer<Point1, Point2> >
-{
-    typedef typename strategy::distance::andoyer<Point1, Point2>::calculation_type type;
-};
-
-
-template <typename Point1, typename Point2, typename P1, typename P2>
-struct similar_type<andoyer<Point1, Point2>, P1, P2>
-{
-    typedef andoyer<P1, P2> type;
-};
-
+template <typename RadiusType, typename CalculationType, typename P1, typename P2>
+struct return_type<strategy::distance::andoyer<RadiusType, CalculationType>, P1, P2>
+    : andoyer<RadiusType, CalculationType>::template calculation_type<P1, P2>
+{};
 
-template <typename Point1, typename Point2, typename P1, typename P2>
-struct get_similar<andoyer<Point1, Point2>, P1, P2>
-{
-    static inline andoyer<P1, P2> apply(andoyer<Point1, Point2> const& input)
-    {
-        return andoyer<P1, P2>(input.ellipsoid());
-    }
-};
 
-template <typename Point1, typename Point2>
-struct comparable_type<andoyer<Point1, Point2> >
+template <typename RadiusType, typename CalculationType>
+struct comparable_type<andoyer<RadiusType, CalculationType> >
 {
-    typedef andoyer<Point1, Point2> type;
+    typedef andoyer<RadiusType, CalculationType> type;
 };
 
 
-template <typename Point1, typename Point2>
-struct get_comparable<andoyer<Point1, Point2> >
+template <typename RadiusType, typename CalculationType>
+struct get_comparable<andoyer<RadiusType, CalculationType> >
 {
-    static inline andoyer<Point1, Point2> apply(andoyer<Point1, Point2> const& input)
+    static inline andoyer<RadiusType, CalculationType> apply(andoyer<RadiusType, CalculationType> const& input)
     {
         return input;
     }
 };
 
-template <typename Point1, typename Point2>
-struct result_from_distance<andoyer<Point1, Point2> >
+template <typename RadiusType, typename CalculationType, typename P1, typename P2>
+struct result_from_distance<andoyer<RadiusType, CalculationType>, P1, P2>
 {
     template <typename T>
-    static inline typename return_type<andoyer<Point1, Point2> >::type apply(andoyer<Point1, Point2> const& , T const& value)
+    static inline typename return_type<andoyer<RadiusType, CalculationType>, P1, P2>::type 
+        apply(andoyer<RadiusType, CalculationType> const& , T const& value)
     {
         return value;
     }
@@ -207,7 +197,7 @@
 template <typename Point1, typename Point2>
 struct default_strategy<point_tag, Point1, Point2, geographic_tag, geographic_tag>
 {
-    typedef strategy::distance::andoyer<Point1, Point2> type;
+    typedef strategy::distance::andoyer<double> type;
 };
 
 

Modified: trunk/libs/geometry/extensions/test/gis/latlong/andoyer.cpp
==============================================================================
--- trunk/libs/geometry/extensions/test/gis/latlong/andoyer.cpp	Wed Jul 17 05:48:43 2013	(r85056)
+++ trunk/libs/geometry/extensions/test/gis/latlong/andoyer.cpp	2013-07-17 09:32:12 EDT (Wed, 17 Jul 2013)	(r85057)
@@ -33,12 +33,22 @@
 template <typename P1, typename P2>
 void test_andoyer(double lon1, double lat1, double lon2, double lat2, double expected_km)
 {
-    typedef bg::strategy::distance::andoyer<P1, P2> andoyer_type;
-
-    BOOST_CONCEPT_ASSERT( (bg::concept::PointDistanceStrategy<andoyer_type>) );
+    // Set radius type, but for integer coordinates we want to have floating point radius type
+    typedef typename bg::promote_floating_point
+        <
+            typename bg::coordinate_type<P1>::type
+        >::type rtype;
+
+    typedef bg::strategy::distance::andoyer<rtype> andoyer_type;
+
+    BOOST_CONCEPT_ASSERT
+        ( 
+            (bg::concept::PointDistanceStrategy<andoyer_type, P1, P2>) 
+        );
 
     andoyer_type andoyer;
-    typedef typename bg::strategy::distance::services::return_type<andoyer_type>::type return_type;
+    typedef typename bg::strategy::distance
+        ::services::return_type<andoyer_type, P1, P2>::type return_type;
 
 
     P1 p1, p2;