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

use new coordinate interface in unit tests

Browse Source
This commit is contained in:
Dennis Luxen 2015-01-22 16:58:45 +01:00
parent 90f17c2140
commit e80ca6553d
2 changed files with 17 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
unit_tests/data_structures/coordinate.cpp
View File

@ -40,12 +40,12 @@ BOOST_AUTO_TEST_CASE(regression_test_1347)
FixedPointCoordinate v(10.001 * COORDINATE_PRECISION, -100.002 * COORDINATE_PRECISION); FixedPointCoordinate v(10.001 * COORDINATE_PRECISION, -100.002 * COORDINATE_PRECISION);
FixedPointCoordinate q(10.002 * COORDINATE_PRECISION, -100.001 * COORDINATE_PRECISION); FixedPointCoordinate q(10.002 * COORDINATE_PRECISION, -100.001 * COORDINATE_PRECISION);
float d1 = coordinate_calculation::ComputePerpendicularDistance(u, v, q); float d1 = coordinate_calculation::perpendicular_distance(u, v, q);
float ratio; float ratio;
FixedPointCoordinate nearest_location; FixedPointCoordinate nearest_location;
float d2 = float d2 =
coordinate_calculation::ComputePerpendicularDistance(u, v, q, nearest_location, ratio); coordinate_calculation::perpendicular_distance(u, v, q, nearest_location, ratio);
BOOST_CHECK_LE(std::abs(d1 - d2), 0.01f); BOOST_CHECK_LE(std::abs(d1 - d2), 0.01f);
} }

30
unit_tests/data_structures/static_rtree.cpp
View File

@ -78,7 +78,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::approx_euclidean_distance( float distance = coordinate_calculation::euclidean_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)
{ {
@ -86,7 +86,7 @@ class LinearSearchNN
min_dist = distance; min_dist = distance;
} }
distance = coordinate_calculation::approx_euclidean_distance( distance = coordinate_calculation::euclidean_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)
{ {
@ -113,7 +113,7 @@ class LinearSearchNN
float current_ratio = 0.; float current_ratio = 0.;
FixedPointCoordinate nearest; FixedPointCoordinate nearest;
const float current_perpendicular_distance = const float current_perpendicular_distance =
coordinate_calculation::ComputePerpendicularDistance( coordinate_calculation::perpendicular_distance(
coords->at(e.u), coords->at(e.v), input_coordinate, nearest, current_ratio); coords->at(e.u), coords->at(e.v), input_coordinate, nearest, current_ratio);
if ((current_perpendicular_distance < min_dist) && if ((current_perpendicular_distance < min_dist) &&
@ -149,9 +149,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::approx_euclidean_distance( const float distance_1 = coordinate_calculation::euclidean_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::approx_euclidean_distance( const float distance_2 = coordinate_calculation::euclidean_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);
@ -286,10 +286,10 @@ void simple_verify_rtree(RTreeT &rtree,
bool found_u = rtree.LocateClosestEndPointForCoordinate(pu, result_u, 1); bool found_u = rtree.LocateClosestEndPointForCoordinate(pu, result_u, 1);
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 = coordinate_calculation::approx_euclidean_distance( float dist_u = coordinate_calculation::euclidean_distance(
result_u.lat, result_u.lon, pu.lat, pu.lon); 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 = coordinate_calculation::approx_euclidean_distance( float dist_v = coordinate_calculation::euclidean_distance(
result_v.lat, result_v.lon, pv.lat, pv.lon); 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());
} }
@ -450,30 +450,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::approx_euclidean_distance( coordinate_calculation::euclidean_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::approx_euclidean_distance( coordinate_calculation::euclidean_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::approx_euclidean_distance( coordinate_calculation::euclidean_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::approx_euclidean_distance( coordinate_calculation::euclidean_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::approx_euclidean_distance( coordinate_calculation::euclidean_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::approx_euclidean_distance( coordinate_calculation::euclidean_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::approx_euclidean_distance( coordinate_calculation::euclidean_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::approx_euclidean_distance( coordinate_calculation::euclidean_distance(
south_west, FixedPointCoordinate(rect.min_lat, rect.min_lon))); south_west, FixedPointCoordinate(rect.min_lat, rect.min_lon)));
} }