request polyline with precision of 5 or 6 positions (#3220)

include/engine/api/json_factory.hpp

@@ -42,9 +42,9 @@ std::string modeToString(const extractor::TravelMode mode);
 
 } // namespace detail
 
-template <typename ForwardIter> util::json::String makePolyline(ForwardIter begin, ForwardIter end)
+template <unsigned POLYLINE_PRECISION, typename ForwardIter> util::json::String makePolyline(ForwardIter begin, ForwardIter end)
 {
-    return {encodePolyline(begin, end)};
+    return {encodePolyline<POLYLINE_PRECISION>(begin, end)};
 }
 
 template <typename ForwardIter>

include/engine/api/route_api.hpp

@@ -68,7 +68,12 @@ class RouteAPI : public BaseAPI
     {
         if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
         {
-            return json::makePolyline(begin, end);
+            return json::makePolyline<100000>(begin, end);
+        }
+
+        if (parameters.geometries == RouteParameters::GeometriesType::Polyline6)
+        {
+            return json::makePolyline<1000000>(begin, end);
         }
 
         BOOST_ASSERT(parameters.geometries == RouteParameters::GeometriesType::GeoJSON);
@@ -192,9 +197,17 @@ class RouteAPI : public BaseAPI
                     if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
                     {
                         return static_cast<util::json::Value>(
-                            json::makePolyline(leg_geometry.locations.begin() + step.geometry_begin,
+                            json::makePolyline<100000>(leg_geometry.locations.begin() + step.geometry_begin,
                                                leg_geometry.locations.begin() + step.geometry_end));
                     }
+
+                    if (parameters.geometries == RouteParameters::GeometriesType::Polyline6)
+                    {
+                        return static_cast<util::json::Value>(
+                            json::makePolyline<1000000>(leg_geometry.locations.begin() + step.geometry_begin,
+                                               leg_geometry.locations.begin() + step.geometry_end));
+                    }
+
                     BOOST_ASSERT(parameters.geometries == RouteParameters::GeometriesType::GeoJSON);
                     return static_cast<util::json::Value>(json::makeGeoJSONGeometry(
                         leg_geometry.locations.begin() + step.geometry_begin,

include/engine/api/route_parameters.hpp

@@ -45,7 +45,7 @@ namespace api
  * Holds member attributes:
  *  - steps: return route step for each route leg
  *  - alternatives: tries to find alternative routes
- *  - geometries: route geometry encoded in Polyline or GeoJSON
+ *  - geometries: route geometry encoded in Polyline, Polyline6 or GeoJSON
  *  - overview: adds overview geometry either Full, Simplified (according to highest zoom level) or
  *              False (not at all)
  *  - continue_straight: enable or disable continue_straight (disabled by default)
@@ -58,6 +58,7 @@ struct RouteParameters : public BaseParameters
     enum class GeometriesType
     {
         Polyline,
+        Polyline6,
         GeoJSON
     };
     enum class OverviewType

include/engine/polyline_compressor.hpp

@@ -3,6 +3,8 @@
 
 #include "util/coordinate.hpp"
 
+#include <boost/assert.hpp>
+#include <algorithm>
 #include <string>
 #include <vector>
 
@@ -11,16 +13,44 @@ namespace osrm
 namespace engine
 {
 namespace detail
-{
-constexpr double POLYLINE_PRECISION = 1e5;
-constexpr double COORDINATE_TO_POLYLINE = POLYLINE_PRECISION / COORDINATE_PRECISION;
-constexpr double POLYLINE_TO_COORDINATE = COORDINATE_PRECISION / POLYLINE_PRECISION;
-}
+ {
+ constexpr double POLYLINE_DECODING_PRECISION = 1e5;
+ constexpr double POLYLINE_TO_COORDINATE = COORDINATE_PRECISION / POLYLINE_DECODING_PRECISION;
 
+ std::string encode(std::vector<int> &numbers);
+ }
 using CoordVectorForwardIter = std::vector<util::Coordinate>::const_iterator;
 // Encodes geometry into polyline format.
 // See: https://developers.google.com/maps/documentation/utilities/polylinealgorithm
-std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter end);
+
+template<unsigned POLYLINE_PRECISION=100000>
+std::string encodePolyline(CoordVectorForwardIter begin, CoordVectorForwardIter end)
+{
+    double coordinate_to_polyline = POLYLINE_PRECISION / COORDINATE_PRECISION;
+    auto size = std::distance(begin, end);
+    if (size == 0)
+    {
+        return {};
+    }
+
+    std::vector<int> delta_numbers;
+    BOOST_ASSERT(size > 0);
+    delta_numbers.reserve((size - 1) * 2);
+    int current_lat = 0;
+    int current_lon = 0;
+    std::for_each(
+        begin, end, [&delta_numbers, &current_lat, &current_lon, coordinate_to_polyline](const util::Coordinate loc) {
+            const int lat_diff =
+                std::round(static_cast<int>(loc.lat) * coordinate_to_polyline) - current_lat;
+            const int lon_diff =
+                std::round(static_cast<int>(loc.lon) * coordinate_to_polyline) - current_lon;
+            delta_numbers.emplace_back(lat_diff);
+            delta_numbers.emplace_back(lon_diff);
+            current_lat += lat_diff;
+            current_lon += lon_diff;
+        });
+    return detail::encode(delta_numbers);
+}
 
 // Decodes geometry from polyline format
 // See: https://developers.google.com/maps/documentation/utilities/polylinealgorithm

include/server/api/route_parameters_grammar.hpp

@@ -43,7 +43,8 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
     RouteParametersGrammar(qi::rule<Iterator, Signature> &root_rule_) : BaseGrammar(root_rule_)
     {
         geometries_type.add("geojson", engine::api::RouteParameters::GeometriesType::GeoJSON)(
-            "polyline", engine::api::RouteParameters::GeometriesType::Polyline);
+            "polyline", engine::api::RouteParameters::GeometriesType::Polyline)(
+            "polyline6", engine::api::RouteParameters::GeometriesType::Polyline6);
 
         overview_type.add("simplified", engine::api::RouteParameters::OverviewType::Simplified)(
             "full", engine::api::RouteParameters::OverviewType::Full)(