From 8f3482561bcd5c1f8e5d28efca7d5856d11065e4 Mon Sep 17 00:00:00 2001 From: Daniel Patterson Date: Tue, 27 Oct 2015 13:45:41 -0700 Subject: [PATCH] Rename great_circle_distance->haversine_distance, and euclidean_distance->great_circle_distance, because that's what they actually are. --- algorithms/coordinate_calculation.cpp | 14 ++++---- algorithms/coordinate_calculation.hpp | 8 ++--- data_structures/rectangle.hpp | 32 ++++++++--------- data_structures/static_rtree.hpp | 40 ++++++++++----------- descriptors/description_factory.cpp | 2 +- extractor/extraction_containers.cpp | 2 +- plugins/match.hpp | 4 +-- routing_algorithms/map_matching.hpp | 6 ++-- routing_algorithms/routing_base.hpp | 4 +-- tools/components.cpp | 2 +- unit_tests/data_structures/static_rtree.cpp | 28 +++++++-------- util/matching_debug_info.hpp | 4 +-- 12 files changed, 73 insertions(+), 73 deletions(-) diff --git a/algorithms/coordinate_calculation.cpp b/algorithms/coordinate_calculation.cpp index 1400b29c6..ff7626e90 100644 --- a/algorithms/coordinate_calculation.cpp +++ b/algorithms/coordinate_calculation.cpp @@ -49,7 +49,7 @@ constexpr static const float earth_radius = 6372797.560856f; namespace coordinate_calculation { -double great_circle_distance(const int lat1, +double haversine_distance(const int lat1, const int lon1, const int lat2, const int lon2) @@ -77,21 +77,21 @@ double great_circle_distance(const int lat1, return earth_radius * cHarv; } -double great_circle_distance(const FixedPointCoordinate &coordinate_1, +double haversine_distance(const FixedPointCoordinate &coordinate_1, const FixedPointCoordinate &coordinate_2) { - return great_circle_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat, + return haversine_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat, coordinate_2.lon); } -float euclidean_distance(const FixedPointCoordinate &coordinate_1, +float great_circle_distance(const FixedPointCoordinate &coordinate_1, const FixedPointCoordinate &coordinate_2) { - return euclidean_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat, + return great_circle_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat, coordinate_2.lon); } -float euclidean_distance(const int lat1, +float great_circle_distance(const int lat1, const int lon1, const int lat2, const int lon2) @@ -224,7 +224,7 @@ float perpendicular_distance_from_projected_coordinate( BOOST_ASSERT(nearest_location.is_valid()); const float approximate_distance = - euclidean_distance(query_location, nearest_location); + great_circle_distance(query_location, nearest_location); BOOST_ASSERT(0.f <= approximate_distance); return approximate_distance; } diff --git a/algorithms/coordinate_calculation.hpp b/algorithms/coordinate_calculation.hpp index 309982a6a..80ec7c289 100644 --- a/algorithms/coordinate_calculation.hpp +++ b/algorithms/coordinate_calculation.hpp @@ -36,15 +36,15 @@ struct FixedPointCoordinate; namespace coordinate_calculation { double - great_circle_distance(const int lat1, const int lon1, const int lat2, const int lon2); + haversine_distance(const int lat1, const int lon1, const int lat2, const int lon2); - double great_circle_distance(const FixedPointCoordinate &first_coordinate, + double haversine_distance(const FixedPointCoordinate &first_coordinate, const FixedPointCoordinate &second_coordinate); - float euclidean_distance(const FixedPointCoordinate &first_coordinate, + float great_circle_distance(const FixedPointCoordinate &first_coordinate, const FixedPointCoordinate &second_coordinate); - float euclidean_distance(const int lat1, const int lon1, const int lat2, const int lon2); + float great_circle_distance(const int lat1, const int lon1, const int lat2, const int lon2); void lat_or_lon_to_string(const int value, std::string &output); diff --git a/data_structures/rectangle.hpp b/data_structures/rectangle.hpp index 9066efc8b..b65c81426 100644 --- a/data_structures/rectangle.hpp +++ b/data_structures/rectangle.hpp @@ -121,35 +121,35 @@ struct RectangleInt2D switch (d) { case NORTH: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(max_lat, location.lon)); break; case SOUTH: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(min_lat, location.lon)); break; case WEST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(location.lat, min_lon)); break; case EAST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(location.lat, max_lon)); break; case NORTH_EAST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(max_lat, max_lon)); break; case NORTH_WEST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(max_lat, min_lon)); break; case SOUTH_EAST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(min_lat, max_lon)); break; case SOUTH_WEST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(min_lat, min_lon)); break; default: @@ -172,23 +172,23 @@ struct RectangleInt2D min_max_dist = std::min(min_max_dist, - std::max(coordinate_calculation::euclidean_distance(location, upper_left), - coordinate_calculation::euclidean_distance(location, upper_right))); + std::max(coordinate_calculation::great_circle_distance(location, upper_left), + coordinate_calculation::great_circle_distance(location, upper_right))); min_max_dist = std::min(min_max_dist, - std::max(coordinate_calculation::euclidean_distance(location, upper_right), - coordinate_calculation::euclidean_distance(location, lower_right))); + std::max(coordinate_calculation::great_circle_distance(location, upper_right), + coordinate_calculation::great_circle_distance(location, lower_right))); min_max_dist = std::min(min_max_dist, - std::max(coordinate_calculation::euclidean_distance(location, lower_right), - coordinate_calculation::euclidean_distance(location, lower_left))); + std::max(coordinate_calculation::great_circle_distance(location, lower_right), + coordinate_calculation::great_circle_distance(location, lower_left))); min_max_dist = std::min(min_max_dist, - std::max(coordinate_calculation::euclidean_distance(location, lower_left), - coordinate_calculation::euclidean_distance(location, upper_left))); + std::max(coordinate_calculation::great_circle_distance(location, lower_left), + coordinate_calculation::great_circle_distance(location, upper_left))); return min_max_dist; } diff --git a/data_structures/static_rtree.hpp b/data_structures/static_rtree.hpp index 04ff2b09a..22d1b77bb 100644 --- a/data_structures/static_rtree.hpp +++ b/data_structures/static_rtree.hpp @@ -173,35 +173,35 @@ class StaticRTree switch (d) { case NORTH: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(max_lat, location.lon)); break; case SOUTH: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(min_lat, location.lon)); break; case WEST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(location.lat, min_lon)); break; case EAST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(location.lat, max_lon)); break; case NORTH_EAST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(max_lat, max_lon)); break; case NORTH_WEST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(max_lat, min_lon)); break; case SOUTH_EAST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(min_lat, max_lon)); break; case SOUTH_WEST: - min_dist = coordinate_calculation::euclidean_distance( + min_dist = coordinate_calculation::great_circle_distance( location, FixedPointCoordinate(min_lat, min_lon)); break; default: @@ -224,23 +224,23 @@ class StaticRTree min_max_dist = std::min( min_max_dist, - std::max(coordinate_calculation::euclidean_distance(location, upper_left), - coordinate_calculation::euclidean_distance(location, upper_right))); + std::max(coordinate_calculation::great_circle_distance(location, upper_left), + coordinate_calculation::great_circle_distance(location, upper_right))); min_max_dist = std::min( min_max_dist, - std::max(coordinate_calculation::euclidean_distance(location, upper_right), - coordinate_calculation::euclidean_distance(location, lower_right))); + std::max(coordinate_calculation::great_circle_distance(location, upper_right), + coordinate_calculation::great_circle_distance(location, lower_right))); min_max_dist = std::min( min_max_dist, - std::max(coordinate_calculation::euclidean_distance(location, lower_right), - coordinate_calculation::euclidean_distance(location, lower_left))); + std::max(coordinate_calculation::great_circle_distance(location, lower_right), + coordinate_calculation::great_circle_distance(location, lower_left))); min_max_dist = std::min( min_max_dist, - std::max(coordinate_calculation::euclidean_distance(location, lower_left), - coordinate_calculation::euclidean_distance(location, upper_left))); + std::max(coordinate_calculation::great_circle_distance(location, lower_left), + coordinate_calculation::great_circle_distance(location, upper_left))); return min_max_dist; } @@ -608,7 +608,7 @@ class StaticRTree continue; } - float current_minimum_distance = coordinate_calculation::euclidean_distance( + float current_minimum_distance = coordinate_calculation::great_circle_distance( input_coordinate.lat, input_coordinate.lon, m_coordinate_list->at(current_edge.u).lat, m_coordinate_list->at(current_edge.u).lon); @@ -619,7 +619,7 @@ class StaticRTree result_coordinate = m_coordinate_list->at(current_edge.u); } - current_minimum_distance = coordinate_calculation::euclidean_distance( + current_minimum_distance = coordinate_calculation::great_circle_distance( input_coordinate.lat, input_coordinate.lon, m_coordinate_list->at(current_edge.v).lat, m_coordinate_list->at(current_edge.v).lon); @@ -1098,9 +1098,9 @@ class StaticRTree inline void SetForwardAndReverseWeightsOnPhantomNode(const EdgeDataT &nearest_edge, PhantomNode &result_phantom_node) const { - const float distance_1 = coordinate_calculation::euclidean_distance( + const float distance_1 = coordinate_calculation::great_circle_distance( m_coordinate_list->at(nearest_edge.u), result_phantom_node.location); - const float distance_2 = coordinate_calculation::euclidean_distance( + const float distance_2 = coordinate_calculation::great_circle_distance( m_coordinate_list->at(nearest_edge.u), m_coordinate_list->at(nearest_edge.v)); const float ratio = std::min(1.f, distance_1 / distance_2); diff --git a/descriptors/description_factory.cpp b/descriptors/description_factory.cpp index 3609bc3df..96883652b 100644 --- a/descriptors/description_factory.cpp +++ b/descriptors/description_factory.cpp @@ -127,7 +127,7 @@ void DescriptionFactory::Run(const unsigned zoom_level) { // move down names by one, q&d hack path_description[i - 1].name_id = path_description[i].name_id; - path_description[i].length = coordinate_calculation::euclidean_distance( + path_description[i].length = coordinate_calculation::great_circle_distance( path_description[i - 1].location, path_description[i].location); } diff --git a/extractor/extraction_containers.cpp b/extractor/extraction_containers.cpp index 96a5c0331..10b9c29fb 100644 --- a/extractor/extraction_containers.cpp +++ b/extractor/extraction_containers.cpp @@ -306,7 +306,7 @@ void ExtractionContainers::PrepareEdges(lua_State *segment_state) BOOST_ASSERT(edge_iterator->source_coordinate.lat != std::numeric_limits::min()); BOOST_ASSERT(edge_iterator->source_coordinate.lon != std::numeric_limits::min()); - const double distance = coordinate_calculation::euclidean_distance( + const double distance = coordinate_calculation::great_circle_distance( edge_iterator->source_coordinate.lat, edge_iterator->source_coordinate.lon, node_iterator->lat, node_iterator->lon); diff --git a/plugins/match.hpp b/plugins/match.hpp index d12ed4666..40394ffc8 100644 --- a/plugins/match.hpp +++ b/plugins/match.hpp @@ -100,7 +100,7 @@ template class MapMatchingPlugin : public BasePlugin osrm::matching::CandidateLists &candidates_lists) { double query_radius = 10 * gps_precision; - double last_distance = coordinate_calculation::great_circle_distance(input_coords[0], input_coords[1]); + double last_distance = coordinate_calculation::haversine_distance(input_coords[0], input_coords[1]); sub_trace_lengths.resize(input_coords.size()); sub_trace_lengths[0] = 0; @@ -109,7 +109,7 @@ template class MapMatchingPlugin : public BasePlugin bool allow_uturn = false; if (0 < current_coordinate) { - last_distance = coordinate_calculation::great_circle_distance(input_coords[current_coordinate - 1], input_coords[current_coordinate]); + last_distance = coordinate_calculation::haversine_distance(input_coords[current_coordinate - 1], input_coords[current_coordinate]); sub_trace_lengths[current_coordinate] += sub_trace_lengths[current_coordinate - 1] + last_distance; diff --git a/routing_algorithms/map_matching.hpp b/routing_algorithms/map_matching.hpp index 543900d05..bc36947d4 100644 --- a/routing_algorithms/map_matching.hpp +++ b/routing_algorithms/map_matching.hpp @@ -217,7 +217,7 @@ class MapMatching final : public BasicRoutingInterface(0u, prev_viterbi.size())) @@ -247,7 +247,7 @@ class MapMatching final : public BasicRoutingInterface prune if (d_t >= max_distance_delta) @@ -260,7 +260,7 @@ class MapMatching final : public BasicRoutingInterface current_viterbi[s_prime]) { diff --git a/routing_algorithms/routing_base.hpp b/routing_algorithms/routing_base.hpp index 658850a8b..e43d6b725 100644 --- a/routing_algorithms/routing_base.hpp +++ b/routing_algorithms/routing_base.hpp @@ -484,11 +484,11 @@ template class BasicRoutingInterface for (const auto &p : unpacked_path) { current_coordinate = facade->GetCoordinateOfNode(p.node); - distance += coordinate_calculation::great_circle_distance(previous_coordinate, + distance += coordinate_calculation::haversine_distance(previous_coordinate, current_coordinate); previous_coordinate = current_coordinate; } - distance += coordinate_calculation::great_circle_distance(previous_coordinate, + distance += coordinate_calculation::haversine_distance(previous_coordinate, target_phantom.location); } return distance; diff --git a/tools/components.cpp b/tools/components.cpp index ca55b0ebc..db0e52685 100644 --- a/tools/components.cpp +++ b/tools/components.cpp @@ -204,7 +204,7 @@ int main(int argc, char *argv[]) if (source < target || SPECIAL_EDGEID == graph->FindEdge(target, source)) { total_network_length += - 100 * coordinate_calculation::euclidean_distance( + 100 * coordinate_calculation::great_circle_distance( coordinate_list[source].lat, coordinate_list[source].lon, coordinate_list[target].lat, coordinate_list[target].lon); diff --git a/unit_tests/data_structures/static_rtree.cpp b/unit_tests/data_structures/static_rtree.cpp index 10310c346..261b7f183 100644 --- a/unit_tests/data_structures/static_rtree.cpp +++ b/unit_tests/data_structures/static_rtree.cpp @@ -86,7 +86,7 @@ class LinearSearchNN { const FixedPointCoordinate &start = coords->at(e.u); const FixedPointCoordinate &end = coords->at(e.v); - float distance = coordinate_calculation::euclidean_distance( + float distance = coordinate_calculation::great_circle_distance( input_coordinate.lat, input_coordinate.lon, start.lat, start.lon); if (distance < min_dist) { @@ -94,7 +94,7 @@ class LinearSearchNN min_dist = distance; } - distance = coordinate_calculation::euclidean_distance( + distance = coordinate_calculation::great_circle_distance( input_coordinate.lat, input_coordinate.lon, end.lat, end.lon); if (distance < min_dist) { @@ -157,9 +157,9 @@ class LinearSearchNN result_phantom_node.location.lat = input_coordinate.lat; } - const float distance_1 = coordinate_calculation::euclidean_distance( + const float distance_1 = coordinate_calculation::great_circle_distance( coords->at(nearest_edge.u), result_phantom_node.location); - const float distance_2 = coordinate_calculation::euclidean_distance( + const float distance_2 = coordinate_calculation::great_circle_distance( coords->at(nearest_edge.u), coords->at(nearest_edge.v)); const float ratio = std::min(1.f, distance_1 / distance_2); @@ -301,10 +301,10 @@ void simple_verify_rtree(RTreeT &rtree, bool found_v = rtree.LocateClosestEndPointForCoordinate(pv, result_v, 1); BOOST_CHECK(found_u && found_v); float dist_u = - coordinate_calculation::euclidean_distance(result_u.lat, result_u.lon, pu.lat, pu.lon); + coordinate_calculation::great_circle_distance(result_u.lat, result_u.lon, pu.lat, pu.lon); BOOST_CHECK_LE(dist_u, std::numeric_limits::epsilon()); float dist_v = - coordinate_calculation::euclidean_distance(result_v.lat, result_v.lon, pv.lat, pv.lon); + coordinate_calculation::great_circle_distance(result_v.lat, result_v.lon, pv.lat, pv.lon); BOOST_CHECK_LE(dist_v, std::numeric_limits::epsilon()); } } @@ -465,30 +465,30 @@ void TestRectangle(double width, double height, double center_lat, double center /* Distance to line segments of rectangle */ BOOST_CHECK_EQUAL(rect.GetMinDist(north), - coordinate_calculation::euclidean_distance( + coordinate_calculation::great_circle_distance( north, FixedPointCoordinate(rect.max_lat, north.lon))); BOOST_CHECK_EQUAL(rect.GetMinDist(south), - coordinate_calculation::euclidean_distance( + coordinate_calculation::great_circle_distance( south, FixedPointCoordinate(rect.min_lat, south.lon))); BOOST_CHECK_EQUAL(rect.GetMinDist(west), - coordinate_calculation::euclidean_distance( + coordinate_calculation::great_circle_distance( west, FixedPointCoordinate(west.lat, rect.min_lon))); BOOST_CHECK_EQUAL(rect.GetMinDist(east), - coordinate_calculation::euclidean_distance( + coordinate_calculation::great_circle_distance( east, FixedPointCoordinate(east.lat, rect.max_lon))); /* Distance to corner points */ BOOST_CHECK_EQUAL(rect.GetMinDist(north_east), - coordinate_calculation::euclidean_distance( + coordinate_calculation::great_circle_distance( north_east, FixedPointCoordinate(rect.max_lat, rect.max_lon))); BOOST_CHECK_EQUAL(rect.GetMinDist(north_west), - coordinate_calculation::euclidean_distance( + coordinate_calculation::great_circle_distance( north_west, FixedPointCoordinate(rect.max_lat, rect.min_lon))); BOOST_CHECK_EQUAL(rect.GetMinDist(south_east), - coordinate_calculation::euclidean_distance( + coordinate_calculation::great_circle_distance( south_east, FixedPointCoordinate(rect.min_lat, rect.max_lon))); BOOST_CHECK_EQUAL(rect.GetMinDist(south_west), - coordinate_calculation::euclidean_distance( + coordinate_calculation::great_circle_distance( south_west, FixedPointCoordinate(rect.min_lat, rect.min_lon))); } diff --git a/util/matching_debug_info.hpp b/util/matching_debug_info.hpp index de48a84cf..850bcd2b0 100644 --- a/util/matching_debug_info.hpp +++ b/util/matching_debug_info.hpp @@ -82,7 +82,7 @@ struct MatchingDebugInfo const double emission_pr, const double transition_pr, const double network_distance, - const double great_circle_distance) + const double haversine_distance) { // json logger not enabled if (!logger) @@ -94,7 +94,7 @@ struct MatchingDebugInfo transistion.values["to"] = osrm::json::make_array(current_t, current_state); transistion.values["properties"] = osrm::json::make_array( osrm::json::clamp_float(prev_viterbi), osrm::json::clamp_float(emission_pr), - osrm::json::clamp_float(transition_pr), network_distance, great_circle_distance); + osrm::json::clamp_float(transition_pr), network_distance, haversine_distance); osrm::json::get(*object, "states", prev_t, prev_state, "transitions") .get>()