Fix naming in coordinate_calculation

include/engine/descriptors/gpx_descriptor.hpp

@@ -3,17 +3,28 @@
 
 #include "engine/descriptors/descriptor_base.hpp"
 #include "util/xml_renderer.hpp"
+#include "util/string_util.hpp"
 
 #include "osrm/json_container.hpp"
 
 #include <iostream>
 
+
+
 template <class DataFacadeT> class GPXDescriptor final : public BaseDescriptor<DataFacadeT>
 {
   private:
     DescriptorConfig config;
     DataFacadeT *facade;
 
+    template<std::size_t digits>
+    void fixedIntToString(const int value, std::string &output)
+    {
+        char buffer[digits];
+        buffer[digits-1] = 0; // zero termination
+        output = printInt<11, 6>(buffer, value);
+    }
+
     void AddRoutePoint(const FixedPointCoordinate &coordinate, osrm::json::Array &json_route)
     {
         osrm::json::Object json_lat;
@@ -22,10 +33,10 @@ template <class DataFacadeT> class GPXDescriptor final : public BaseDescriptor<D
 
         std::string tmp;
 
-        coordinate_calculation::lat_or_lon_to_string(coordinate.lat, tmp);
+        fixedIntToString<12>(coordinate.lat, tmp);
         json_lat.values["_lat"] = tmp;
 
-        coordinate_calculation::lat_or_lon_to_string(coordinate.lon, tmp);
+        fixedIntToString<12>(coordinate.lon, tmp);
         json_lon.values["_lon"] = tmp;
 
         json_row.values.push_back(json_lat);

include/engine/geospatial_query.hpp

@@ -133,7 +133,7 @@ template <typename RTreeT> class GeospatialQuery
     {
         FixedPointCoordinate point_on_segment;
         double ratio;
-        const auto current_perpendicular_distance = coordinate_calculation::perpendicular_distance(
+        const auto current_perpendicular_distance = coordinate_calculation::perpendicularDistance(
             coordinates->at(data.u), coordinates->at(data.v), input_coordinate, point_on_segment,
             ratio);
 

include/engine/plugins/match.hpp

@@ -76,7 +76,7 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
 
         double query_radius = 10 * gps_precision;
         double last_distance =
-            coordinate_calculation::haversine_distance(input_coords[0], input_coords[1]);
+            coordinate_calculation::haversineDistance(input_coords[0], input_coords[1]);
 
         sub_trace_lengths.resize(input_coords.size());
         sub_trace_lengths[0] = 0;
@@ -85,7 +85,7 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
             bool allow_uturn = false;
             if (0 < current_coordinate)
             {
-                last_distance = coordinate_calculation::haversine_distance(
+                last_distance = coordinate_calculation::haversineDistance(
                     input_coords[current_coordinate - 1], input_coords[current_coordinate]);
 
                 sub_trace_lengths[current_coordinate] +=

include/engine/routing_algorithms/map_matching.hpp

@@ -196,7 +196,7 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
             const auto &current_coordinate = trace_coordinates[t];
 
             const auto haversine_distance =
-                coordinate_calculation::haversine_distance(prev_coordinate, current_coordinate);
+                coordinate_calculation::haversineDistance(prev_coordinate, current_coordinate);
 
             // compute d_t for this timestamp and the next one
             for (const auto s : osrm::irange<std::size_t>(0u, prev_viterbi.size()))

include/engine/routing_algorithms/routing_base.hpp

@@ -648,11 +648,11 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
             for (const auto &p : unpacked_path)
             {
                 current_coordinate = facade->GetCoordinateOfNode(p.node);
-                distance += coordinate_calculation::haversine_distance(previous_coordinate,
+                distance += coordinate_calculation::haversineDistance(previous_coordinate,
                                                                        current_coordinate);
                 previous_coordinate = current_coordinate;
             }
-            distance += coordinate_calculation::haversine_distance(previous_coordinate,
+            distance += coordinate_calculation::haversineDistance(previous_coordinate,
                                                                    target_phantom.location);
         }
         return distance;