First round of lat,lng -> lng,lat switcheroo

include/extractor/edge_based_node.hpp

@@ -22,8 +22,7 @@ struct EdgeBasedNode
     EdgeBasedNode()
         : forward_edge_based_node_id(SPECIAL_NODEID), reverse_edge_based_node_id(SPECIAL_NODEID),
           u(SPECIAL_NODEID), v(SPECIAL_NODEID), name_id(0),
-          forward_packed_geometry_id(SPECIAL_EDGEID),
-          reverse_packed_geometry_id(SPECIAL_EDGEID),
+          forward_packed_geometry_id(SPECIAL_EDGEID), reverse_packed_geometry_id(SPECIAL_EDGEID),
           component{INVALID_COMPONENTID, false},
           fwd_segment_position(std::numeric_limits<unsigned short>::max()),
           forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
@@ -47,21 +46,19 @@ struct EdgeBasedNode
           reverse_edge_based_node_id(reverse_edge_based_node_id), u(u), v(v), name_id(name_id),
           forward_packed_geometry_id(forward_weight_or_packed_geometry_id_),
           reverse_packed_geometry_id(reverse_weight_or_packed_geometry_id_),
-          component{component_id, is_tiny_component},
-          fwd_segment_position(fwd_segment_position), forward_travel_mode(forward_travel_mode),
-          backward_travel_mode(backward_travel_mode)
+          component{component_id, is_tiny_component}, fwd_segment_position(fwd_segment_position),
+          forward_travel_mode(forward_travel_mode), backward_travel_mode(backward_travel_mode)
     {
         BOOST_ASSERT((forward_edge_based_node_id != SPECIAL_NODEID) ||
                      (reverse_edge_based_node_id != SPECIAL_NODEID));
     }
 
-    static inline util::FixedPointCoordinate Centroid(const util::FixedPointCoordinate a,
-                                                      const util::FixedPointCoordinate b)
+    static inline util::Coordinate Centroid(const util::Coordinate a, const util::Coordinate b)
     {
-        util::FixedPointCoordinate centroid;
+        util::Coordinate centroid;
         // The coordinates of the midpoint are given by:
-        centroid.lat = (a.lat + b.lat) / 2;
-        centroid.lon = (a.lon + b.lon) / 2;
+        centroid.lon = (a.lon + b.lon) / util::FixedLongitude(2);
+        centroid.lat = (a.lat + b.lat) / util::FixedLatitude(2);
         return centroid;
     }
 

include/extractor/external_memory_node.hpp

@@ -12,8 +12,12 @@ namespace extractor
 
 struct ExternalMemoryNode : QueryNode
 {
-    ExternalMemoryNode(int lat, int lon, OSMNodeID node_id, bool barrier, bool traffic_lights)
-        : QueryNode(lat, lon, node_id), barrier(barrier), traffic_lights(traffic_lights)
+    ExternalMemoryNode(const util::FixedLongitude lon_,
+                       const util::FixedLatitude lat_,
+                       OSMNodeID node_id_,
+                       bool barrier_,
+                       bool traffic_lights_)
+        : QueryNode(lon_, lat_, node_id_), barrier(barrier_), traffic_lights(traffic_lights_)
     {
     }
 
@@ -21,12 +25,14 @@ struct ExternalMemoryNode : QueryNode
 
     static ExternalMemoryNode min_value()
     {
-        return ExternalMemoryNode(0, 0, MIN_OSM_NODEID, false, false);
+        return ExternalMemoryNode(util::FixedLongitude(0), util::FixedLatitude(0), MIN_OSM_NODEID,
+                                  false, false);
     }
 
     static ExternalMemoryNode max_value()
     {
-        return ExternalMemoryNode(std::numeric_limits<int>::max(), std::numeric_limits<int>::max(),
+        return ExternalMemoryNode(util::FixedLongitude(std::numeric_limits<int>::max()),
+                                  util::FixedLatitude(std::numeric_limits<int>::max()),
                                   MAX_OSM_NODEID, false, false);
     }
 

include/extractor/internal_extractor_edge.hpp

@@ -85,7 +85,7 @@ struct InternalExtractorEdge
     // intermediate edge weight
     WeightData weight_data;
     // coordinate of the source node
-    util::FixedPointCoordinate source_coordinate;
+    util::Coordinate source_coordinate;
 
     // necessary static util functions for stxxl's sorting
     static InternalExtractorEdge min_osm_value()

include/extractor/query_node.hpp

@@ -3,7 +3,7 @@
 
 #include "util/typedefs.hpp"
 
-#include "osrm/coordinate.hpp"
+#include "util/coordinate.hpp"
 
 #include <limits>
 
@@ -17,30 +17,32 @@ struct QueryNode
     using key_type = OSMNodeID; // type of NodeID
     using value_type = int;     // type of lat,lons
 
-    explicit QueryNode(int lat, int lon, key_type node_id)
-        : lat(lat), lon(lon), node_id(std::move(node_id))
+    explicit QueryNode(const util::FixedLongitude lon_,
+                       const util::FixedLatitude lat_,
+                       key_type node_id)
+        : lon(lon_), lat(lat_), node_id(std::move(node_id))
     {
     }
     QueryNode()
-        : lat(std::numeric_limits<int>::max()), lon(std::numeric_limits<int>::max()),
+        : lon(std::numeric_limits<int>::max()), lat(std::numeric_limits<int>::max()),
           node_id(SPECIAL_OSM_NODEID)
     {
     }
 
-    int lat;
-    int lon;
+    util::FixedLongitude lon;
+    util::FixedLatitude lat;
     key_type node_id;
 
     static QueryNode min_value()
     {
-        return QueryNode(static_cast<int>(-90 * COORDINATE_PRECISION),
-                         static_cast<int>(-180 * COORDINATE_PRECISION), MIN_OSM_NODEID);
+        return QueryNode(util::FixedLongitude(-180 * COORDINATE_PRECISION),
+                         util::FixedLatitude(-90 * COORDINATE_PRECISION), MIN_OSM_NODEID);
     }
 
     static QueryNode max_value()
     {
-        return QueryNode(static_cast<int>(90 * COORDINATE_PRECISION),
-                         static_cast<int>(180 * COORDINATE_PRECISION), MAX_OSM_NODEID);
+        return QueryNode(util::FixedLongitude(180 * COORDINATE_PRECISION),
+                         util::FixedLatitude(90 * COORDINATE_PRECISION), MAX_OSM_NODEID);
     }
 };
 }