Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Rename great_circle_distance->haversine_distance, and euclidean_distance->great_circle_distance, because that's what they actually are.

Browse Source
This commit is contained in:
Daniel Patterson 2015-10-27 13:45:41 -07:00
parent 13ceeb191c
commit 8f3482561b
12 changed files with 73 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
algorithms/coordinate_calculation.cpp
View File

@ -49,7 +49,7 @@ constexpr static const float earth_radius = 6372797.560856f;
namespace coordinate_calculation namespace coordinate_calculation
{ {
double great_circle_distance(const int lat1, double haversine_distance(const int lat1,
const int lon1, const int lon1,
const int lat2, const int lat2,
const int lon2) const int lon2)
@ -77,21 +77,21 @@ double great_circle_distance(const int lat1,
return earth_radius * cHarv; return earth_radius * cHarv;
} }
double great_circle_distance(const FixedPointCoordinate &coordinate_1, double haversine_distance(const FixedPointCoordinate &coordinate_1,
const FixedPointCoordinate &coordinate_2)
{
return haversine_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
coordinate_2.lon);
}
float great_circle_distance(const FixedPointCoordinate &coordinate_1,
const FixedPointCoordinate &coordinate_2) const FixedPointCoordinate &coordinate_2)
{ {
return great_circle_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); coordinate_2.lon);
} }
float euclidean_distance(const FixedPointCoordinate &coordinate_1, float great_circle_distance(const int lat1,
const FixedPointCoordinate &coordinate_2)
{
return euclidean_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
coordinate_2.lon);
}
float euclidean_distance(const int lat1,
const int lon1, const int lon1,
const int lat2, const int lat2,
const int lon2) const int lon2)
@ -224,7 +224,7 @@ float perpendicular_distance_from_projected_coordinate(
BOOST_ASSERT(nearest_location.is_valid()); BOOST_ASSERT(nearest_location.is_valid());
const float approximate_distance = const float approximate_distance =
euclidean_distance(query_location, nearest_location); great_circle_distance(query_location, nearest_location);
BOOST_ASSERT(0.f <= approximate_distance); BOOST_ASSERT(0.f <= approximate_distance);
return approximate_distance; return approximate_distance;
} }

8
algorithms/coordinate_calculation.hpp
View File

@ -36,15 +36,15 @@ struct FixedPointCoordinate;
namespace coordinate_calculation namespace coordinate_calculation
{ {
double 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); const FixedPointCoordinate &second_coordinate);
float euclidean_distance(const FixedPointCoordinate &first_coordinate, float great_circle_distance(const FixedPointCoordinate &first_coordinate,
const FixedPointCoordinate &second_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); void lat_or_lon_to_string(const int value, std::string &output);

32
data_structures/rectangle.hpp
View File

@ -121,35 +121,35 @@ struct RectangleInt2D
switch (d) switch (d)
{ {
case NORTH: case NORTH:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(max_lat, location.lon)); location, FixedPointCoordinate(max_lat, location.lon));
break; break;
case SOUTH: case SOUTH:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(min_lat, location.lon)); location, FixedPointCoordinate(min_lat, location.lon));
break; break;
case WEST: case WEST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(location.lat, min_lon)); location, FixedPointCoordinate(location.lat, min_lon));
break; break;
case EAST: case EAST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(location.lat, max_lon)); location, FixedPointCoordinate(location.lat, max_lon));
break; break;
case NORTH_EAST: case NORTH_EAST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(max_lat, max_lon)); location, FixedPointCoordinate(max_lat, max_lon));
break; break;
case NORTH_WEST: case NORTH_WEST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(max_lat, min_lon)); location, FixedPointCoordinate(max_lat, min_lon));
break; break;
case SOUTH_EAST: case SOUTH_EAST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(min_lat, max_lon)); location, FixedPointCoordinate(min_lat, max_lon));
break; break;
case SOUTH_WEST: case SOUTH_WEST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(min_lat, min_lon)); location, FixedPointCoordinate(min_lat, min_lon));
break; break;
default: default:
@ -172,23 +172,23 @@ struct RectangleInt2D
min_max_dist = min_max_dist =
std::min(min_max_dist, std::min(min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, upper_left), std::max(coordinate_calculation::great_circle_distance(location, upper_left),
coordinate_calculation::euclidean_distance(location, upper_right))); coordinate_calculation::great_circle_distance(location, upper_right)));
min_max_dist = min_max_dist =
std::min(min_max_dist, std::min(min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, upper_right), std::max(coordinate_calculation::great_circle_distance(location, upper_right),
coordinate_calculation::euclidean_distance(location, lower_right))); coordinate_calculation::great_circle_distance(location, lower_right)));
min_max_dist = min_max_dist =
std::min(min_max_dist, std::min(min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, lower_right), std::max(coordinate_calculation::great_circle_distance(location, lower_right),
coordinate_calculation::euclidean_distance(location, lower_left))); coordinate_calculation::great_circle_distance(location, lower_left)));
min_max_dist = min_max_dist =
std::min(min_max_dist, std::min(min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, lower_left), std::max(coordinate_calculation::great_circle_distance(location, lower_left),
coordinate_calculation::euclidean_distance(location, upper_left))); coordinate_calculation::great_circle_distance(location, upper_left)));
return min_max_dist; return min_max_dist;
} }

40
data_structures/static_rtree.hpp
View File

@ -173,35 +173,35 @@ class StaticRTree
switch (d) switch (d)
{ {
case NORTH: case NORTH:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(max_lat, location.lon)); location, FixedPointCoordinate(max_lat, location.lon));
break; break;
case SOUTH: case SOUTH:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(min_lat, location.lon)); location, FixedPointCoordinate(min_lat, location.lon));
break; break;
case WEST: case WEST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(location.lat, min_lon)); location, FixedPointCoordinate(location.lat, min_lon));
break; break;
case EAST: case EAST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(location.lat, max_lon)); location, FixedPointCoordinate(location.lat, max_lon));
break; break;
case NORTH_EAST: case NORTH_EAST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(max_lat, max_lon)); location, FixedPointCoordinate(max_lat, max_lon));
break; break;
case NORTH_WEST: case NORTH_WEST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(max_lat, min_lon)); location, FixedPointCoordinate(max_lat, min_lon));
break; break;
case SOUTH_EAST: case SOUTH_EAST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(min_lat, max_lon)); location, FixedPointCoordinate(min_lat, max_lon));
break; break;
case SOUTH_WEST: case SOUTH_WEST:
min_dist = coordinate_calculation::euclidean_distance( min_dist = coordinate_calculation::great_circle_distance(
location, FixedPointCoordinate(min_lat, min_lon)); location, FixedPointCoordinate(min_lat, min_lon));
break; break;
default: default:
@ -224,23 +224,23 @@ class StaticRTree
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, upper_left), std::max(coordinate_calculation::great_circle_distance(location, upper_left),
coordinate_calculation::euclidean_distance(location, upper_right))); coordinate_calculation::great_circle_distance(location, upper_right)));
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, upper_right), std::max(coordinate_calculation::great_circle_distance(location, upper_right),
coordinate_calculation::euclidean_distance(location, lower_right))); coordinate_calculation::great_circle_distance(location, lower_right)));
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, lower_right), std::max(coordinate_calculation::great_circle_distance(location, lower_right),
coordinate_calculation::euclidean_distance(location, lower_left))); coordinate_calculation::great_circle_distance(location, lower_left)));
min_max_dist = std::min( min_max_dist = std::min(
min_max_dist, min_max_dist,
std::max(coordinate_calculation::euclidean_distance(location, lower_left), std::max(coordinate_calculation::great_circle_distance(location, lower_left),
coordinate_calculation::euclidean_distance(location, upper_left))); coordinate_calculation::great_circle_distance(location, upper_left)));
return min_max_dist; return min_max_dist;
} }
@ -608,7 +608,7 @@ class StaticRTree
continue; continue;
} }
float current_minimum_distance = coordinate_calculation::euclidean_distance( float current_minimum_distance = coordinate_calculation::great_circle_distance(
input_coordinate.lat, input_coordinate.lon, input_coordinate.lat, input_coordinate.lon,
m_coordinate_list->at(current_edge.u).lat, m_coordinate_list->at(current_edge.u).lat,
m_coordinate_list->at(current_edge.u).lon); m_coordinate_list->at(current_edge.u).lon);
@ -619,7 +619,7 @@ class StaticRTree
result_coordinate = m_coordinate_list->at(current_edge.u); 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, input_coordinate.lat, input_coordinate.lon,
m_coordinate_list->at(current_edge.v).lat, m_coordinate_list->at(current_edge.v).lat,
m_coordinate_list->at(current_edge.v).lon); m_coordinate_list->at(current_edge.v).lon);
@ -1098,9 +1098,9 @@ class StaticRTree
inline void SetForwardAndReverseWeightsOnPhantomNode(const EdgeDataT &nearest_edge, inline void SetForwardAndReverseWeightsOnPhantomNode(const EdgeDataT &nearest_edge,
PhantomNode &result_phantom_node) const 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); 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)); 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); const float ratio = std::min(1.f, distance_1 / distance_2);

2
descriptors/description_factory.cpp
View File

@ -127,7 +127,7 @@ void DescriptionFactory::Run(const unsigned zoom_level)
{ {
// move down names by one, q&d hack // move down names by one, q&d hack
path_description[i - 1].name_id = path_description[i].name_id; 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); path_description[i - 1].location, path_description[i].location);
} }

2
extractor/extraction_containers.cpp
View File

@ -306,7 +306,7 @@ void ExtractionContainers::PrepareEdges(lua_State *segment_state)
BOOST_ASSERT(edge_iterator->source_coordinate.lat != std::numeric_limits<int>::min()); BOOST_ASSERT(edge_iterator->source_coordinate.lat != std::numeric_limits<int>::min());
BOOST_ASSERT(edge_iterator->source_coordinate.lon != std::numeric_limits<int>::min()); BOOST_ASSERT(edge_iterator->source_coordinate.lon != std::numeric_limits<int>::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, edge_iterator->source_coordinate.lat, edge_iterator->source_coordinate.lon,
node_iterator->lat, node_iterator->lon); node_iterator->lat, node_iterator->lon);

4
plugins/match.hpp
View File

@ -100,7 +100,7 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
osrm::matching::CandidateLists &candidates_lists) osrm::matching::CandidateLists &candidates_lists)
{ {
double query_radius = 10 * gps_precision; 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.resize(input_coords.size());
sub_trace_lengths[0] = 0; sub_trace_lengths[0] = 0;
@ -109,7 +109,7 @@ template <class DataFacadeT> class MapMatchingPlugin : public BasePlugin
bool allow_uturn = false; bool allow_uturn = false;
if (0 < current_coordinate) 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] +=
sub_trace_lengths[current_coordinate - 1] + last_distance; sub_trace_lengths[current_coordinate - 1] + last_distance;

6
routing_algorithms/map_matching.hpp
View File

@ -217,7 +217,7 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
const auto &current_timestamps_list = candidates_list[t]; const auto &current_timestamps_list = candidates_list[t];
const auto &current_coordinate = trace_coordinates[t]; const auto &current_coordinate = trace_coordinates[t];
const auto great_circle_distance = coordinate_calculation::great_circle_distance(prev_coordinate, current_coordinate); const auto haversine_distance = coordinate_calculation::haversine_distance(prev_coordinate, current_coordinate);
// compute d_t for this timestamp and the next one // compute d_t for this timestamp and the next one
for (const auto s : osrm::irange<std::size_t>(0u, prev_viterbi.size())) for (const auto s : osrm::irange<std::size_t>(0u, prev_viterbi.size()))
@ -247,7 +247,7 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
forward_heap, reverse_heap, prev_unbroken_timestamps_list[s].first, forward_heap, reverse_heap, prev_unbroken_timestamps_list[s].first,
current_timestamps_list[s_prime].first); current_timestamps_list[s_prime].first);
const auto d_t = std::abs(network_distance - great_circle_distance); const auto d_t = std::abs(network_distance - haversine_distance);
// very low probability transition -> prune // very low probability transition -> prune
if (d_t >= max_distance_delta) if (d_t >= max_distance_delta)
@ -260,7 +260,7 @@ class MapMatching final : public BasicRoutingInterface<DataFacadeT, MapMatching<
matching_debug.add_transition_info(prev_unbroken_timestamp, t, s, s_prime, matching_debug.add_transition_info(prev_unbroken_timestamp, t, s, s_prime,
prev_viterbi[s], emission_pr, transition_pr, prev_viterbi[s], emission_pr, transition_pr,
network_distance, great_circle_distance); network_distance, haversine_distance);
if (new_value > current_viterbi[s_prime]) if (new_value > current_viterbi[s_prime])
{ {

4
routing_algorithms/routing_base.hpp
View File

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

2
tools/components.cpp
View File

@ -204,7 +204,7 @@ int main(int argc, char *argv[])
if (source < target || SPECIAL_EDGEID == graph->FindEdge(target, source)) if (source < target || SPECIAL_EDGEID == graph->FindEdge(target, source))
{ {
total_network_length += total_network_length +=
100 * coordinate_calculation::euclidean_distance( 100 * coordinate_calculation::great_circle_distance(
coordinate_list[source].lat, coordinate_list[source].lon, coordinate_list[source].lat, coordinate_list[source].lon,
coordinate_list[target].lat, coordinate_list[target].lon); coordinate_list[target].lat, coordinate_list[target].lon);

28
unit_tests/data_structures/static_rtree.cpp
View File

@ -86,7 +86,7 @@ class LinearSearchNN
{ {
const FixedPointCoordinate &start = coords->at(e.u); const FixedPointCoordinate &start = coords->at(e.u);
const FixedPointCoordinate &end = coords->at(e.v); 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); input_coordinate.lat, input_coordinate.lon, start.lat, start.lon);
if (distance < min_dist) if (distance < min_dist)
{ {
@ -94,7 +94,7 @@ class LinearSearchNN
min_dist = distance; min_dist = distance;
} }
distance = coordinate_calculation::euclidean_distance( distance = coordinate_calculation::great_circle_distance(
input_coordinate.lat, input_coordinate.lon, end.lat, end.lon); input_coordinate.lat, input_coordinate.lon, end.lat, end.lon);
if (distance < min_dist) if (distance < min_dist)
{ {
@ -157,9 +157,9 @@ class LinearSearchNN
result_phantom_node.location.lat = input_coordinate.lat; 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); 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)); coords->at(nearest_edge.u), coords->at(nearest_edge.v));
const float ratio = std::min(1.f, distance_1 / distance_2); 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); bool found_v = rtree.LocateClosestEndPointForCoordinate(pv, result_v, 1);
BOOST_CHECK(found_u && found_v); BOOST_CHECK(found_u && found_v);
float dist_u = 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<float>::epsilon()); BOOST_CHECK_LE(dist_u, std::numeric_limits<float>::epsilon());
float dist_v = 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<float>::epsilon()); BOOST_CHECK_LE(dist_v, std::numeric_limits<float>::epsilon());
} }
} }
@ -465,30 +465,30 @@ void TestRectangle(double width, double height, double center_lat, double center
/* Distance to line segments of rectangle */ /* Distance to line segments of rectangle */
BOOST_CHECK_EQUAL(rect.GetMinDist(north), BOOST_CHECK_EQUAL(rect.GetMinDist(north),
coordinate_calculation::euclidean_distance( coordinate_calculation::great_circle_distance(
north, FixedPointCoordinate(rect.max_lat, north.lon))); north, FixedPointCoordinate(rect.max_lat, north.lon)));
BOOST_CHECK_EQUAL(rect.GetMinDist(south), BOOST_CHECK_EQUAL(rect.GetMinDist(south),
coordinate_calculation::euclidean_distance( coordinate_calculation::great_circle_distance(
south, FixedPointCoordinate(rect.min_lat, south.lon))); south, FixedPointCoordinate(rect.min_lat, south.lon)));
BOOST_CHECK_EQUAL(rect.GetMinDist(west), BOOST_CHECK_EQUAL(rect.GetMinDist(west),
coordinate_calculation::euclidean_distance( coordinate_calculation::great_circle_distance(
west, FixedPointCoordinate(west.lat, rect.min_lon))); west, FixedPointCoordinate(west.lat, rect.min_lon)));
BOOST_CHECK_EQUAL(rect.GetMinDist(east), BOOST_CHECK_EQUAL(rect.GetMinDist(east),
coordinate_calculation::euclidean_distance( coordinate_calculation::great_circle_distance(
east, FixedPointCoordinate(east.lat, rect.max_lon))); east, FixedPointCoordinate(east.lat, rect.max_lon)));
/* Distance to corner points */ /* Distance to corner points */
BOOST_CHECK_EQUAL(rect.GetMinDist(north_east), 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))); north_east, FixedPointCoordinate(rect.max_lat, rect.max_lon)));
BOOST_CHECK_EQUAL(rect.GetMinDist(north_west), 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))); north_west, FixedPointCoordinate(rect.max_lat, rect.min_lon)));
BOOST_CHECK_EQUAL(rect.GetMinDist(south_east), 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))); south_east, FixedPointCoordinate(rect.min_lat, rect.max_lon)));
BOOST_CHECK_EQUAL(rect.GetMinDist(south_west), 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))); south_west, FixedPointCoordinate(rect.min_lat, rect.min_lon)));
} }

4
util/matching_debug_info.hpp
View File

@ -82,7 +82,7 @@ struct MatchingDebugInfo
const double emission_pr, const double emission_pr,
const double transition_pr, const double transition_pr,
const double network_distance, const double network_distance,
const double great_circle_distance) const double haversine_distance)
{ {
// json logger not enabled // json logger not enabled
if (!logger) if (!logger)
@ -94,7 +94,7 @@ struct MatchingDebugInfo
transistion.values["to"] = osrm::json::make_array(current_t, current_state); transistion.values["to"] = osrm::json::make_array(current_t, current_state);
transistion.values["properties"] = osrm::json::make_array( transistion.values["properties"] = osrm::json::make_array(
osrm::json::clamp_float(prev_viterbi), osrm::json::clamp_float(emission_pr), 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") osrm::json::get(*object, "states", prev_t, prev_state, "transitions")
.get<mapbox::util::recursive_wrapper<osrm::json::Array>>() .get<mapbox::util::recursive_wrapper<osrm::json::Array>>()