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

Use mmap instead of read - it's a lot faster here.

Browse Source 
Also clean up construction of STRONG_TYPEDEF so that it can be
packed properly in structs (this explains all the () -> {}) changes
here.
This commit is contained in:
Daniel Patterson
2016-06-23 22:01:37 -07:00
parent 5905708111
commit ec02cdc4cc
34 changed files with 463 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files
unit_tests/engine/douglas_peucker.cpp
+15 -15
View File
@@ -33,10 +33,10 @@ BOOST_AUTO_TEST_CASE(removed_middle_test)
x x
*/
std::vector<util::Coordinate> coordinates = {
util::Coordinate(util::FloatLongitude(5), util::FloatLatitude(5)),
util::Coordinate(util::FloatLongitude(12.5), util::FloatLatitude(12.6096298302)),
util::Coordinate(util::FloatLongitude(20), util::FloatLatitude(20)),
util::Coordinate(util::FloatLongitude(25), util::FloatLatitude(5))};
util::Coordinate{util::FloatLongitude{5}, util::FloatLatitude{5}},
util::Coordinate{util::FloatLongitude{12.5}, util::FloatLatitude{12.6096298302}},
util::Coordinate{util::FloatLongitude{20}, util::FloatLatitude{20}},
util::Coordinate{util::FloatLongitude{25}, util::FloatLatitude{5}}};
for (unsigned z = 0; z < detail::DOUGLAS_PEUCKER_THRESHOLDS_SIZE; z++)
{
@@ -58,10 +58,10 @@ BOOST_AUTO_TEST_CASE(removed_middle_test_zoom_sensitive)
x x
*/
std::vector<util::Coordinate> coordinates = {
util::Coordinate(util::FloatLongitude(5), util::FloatLatitude(5)),
util::Coordinate(util::FloatLongitude(6), util::FloatLatitude(6)),
util::Coordinate(util::FloatLongitude(20), util::FloatLatitude(20)),
util::Coordinate(util::FloatLongitude(25), util::FloatLatitude(5))};
util::Coordinate{util::FloatLongitude{5}, util::FloatLatitude{5}},
util::Coordinate{util::FloatLongitude{6}, util::FloatLatitude{6}},
util::Coordinate{util::FloatLongitude{20}, util::FloatLatitude{20}},
util::Coordinate{util::FloatLongitude{25}, util::FloatLatitude{5}}};
// Coordinate 6,6 should start getting included at Z9 and higher
// Note that 5,5->6,6->10,10 is *not* a straight line on the surface
@@ -98,13 +98,13 @@ BOOST_AUTO_TEST_CASE(remove_second_node_test)
x
*/
std::vector<util::Coordinate> input = {
util::Coordinate(util::FloatLongitude(5), util::FloatLatitude(5)),
util::Coordinate(util::FloatLongitude(5 + delta_pixel_to_delta_degree(2, z)),
util::FloatLatitude(5)),
util::Coordinate(util::FloatLongitude(10), util::FloatLatitude(10)),
util::Coordinate(util::FloatLongitude(5), util::FloatLatitude(15)),
util::Coordinate(util::FloatLongitude(5),
util::FloatLatitude(15 + delta_pixel_to_delta_degree(2, z)))};
util::Coordinate{util::FloatLongitude{5}, util::FloatLatitude{5}},
util::Coordinate{util::FloatLongitude{5 + delta_pixel_to_delta_degree(2, z)},
util::FloatLatitude{5}},
util::Coordinate{util::FloatLongitude{10}, util::FloatLatitude{10}},
util::Coordinate{util::FloatLongitude{5}, util::FloatLatitude{15}},
util::Coordinate{util::FloatLongitude{5},
util::FloatLatitude{15 + delta_pixel_to_delta_degree(2, z)}}};
BOOST_TEST_MESSAGE("Delta (" << z << "): " << delta_pixel_to_delta_degree(2, z));
auto result = douglasPeucker(input, z);
BOOST_CHECK_EQUAL(result.size(), 3);
unit_tests/engine/geometry_string.cpp
+5 -5
View File
@@ -22,11 +22,11 @@ BOOST_AUTO_TEST_CASE(decode)
// Test coordinates; these would be the coordinates we give the loc parameter,
// e.g. loc=10.00,10.0&loc=10.01,10.1...
util::Coordinate coord1(util::FloatLongitude(10.0), util::FloatLatitude(10.00));
util::Coordinate coord2(util::FloatLongitude(10.1), util::FloatLatitude(10.01));
util::Coordinate coord3(util::FloatLongitude(10.2), util::FloatLatitude(10.02));
util::Coordinate coord4(util::FloatLongitude(10.3), util::FloatLatitude(10.03));
util::Coordinate coord5(util::FloatLongitude(10.4), util::FloatLatitude(10.04));
util::Coordinate coord1(util::FloatLongitude{10.0}, util::FloatLatitude{10.00});
util::Coordinate coord2(util::FloatLongitude{10.1}, util::FloatLatitude{10.01});
util::Coordinate coord3(util::FloatLongitude{10.2}, util::FloatLatitude{10.02});
util::Coordinate coord4(util::FloatLongitude{10.3}, util::FloatLatitude{10.03});
util::Coordinate coord5(util::FloatLongitude{10.4}, util::FloatLatitude{10.04});
// Put the test coordinates into the vector for comparison
std::vector<util::Coordinate> cmp_coords = {coord1, coord2, coord3, coord4, coord5};
unit_tests/library/waypoint_check.hpp
+2 -2
View File
@@ -15,8 +15,8 @@ inline bool waypoint_check(json::Value waypoint)
}
const auto waypoint_object = waypoint.get<json::Object>();
const auto waypoint_location = waypoint_object.values.at("location").get<json::Array>().values;
util::FloatLongitude lon(waypoint_location[0].get<json::Number>().value);
util::FloatLatitude lat(waypoint_location[1].get<json::Number>().value);
util::FloatLongitude lon{waypoint_location[0].get<json::Number>().value};
util::FloatLatitude lat{waypoint_location[1].get<json::Number>().value};
util::Coordinate location_coordinate(lon, lat);
return location_coordinate.IsValid();
}
unit_tests/server/parameters_parser.cpp
+16 -16
View File
@@ -76,8 +76,8 @@ BOOST_AUTO_TEST_CASE(invalid_table_urls)
BOOST_AUTO_TEST_CASE(valid_route_urls)
{
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude(1), util::FloatLatitude(2)},
{util::FloatLongitude(3), util::FloatLatitude(4)}};
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude{1}, util::FloatLatitude{2}},
{util::FloatLongitude{3}, util::FloatLatitude{4}}};
RouteParameters reference_1{};
reference_1.coordinates = coords_1;
@@ -199,9 +199,9 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
CHECK_EQUAL_RANGE(reference_5.coordinates, result_5->coordinates);
CHECK_EQUAL_RANGE(reference_5.hints, result_5->hints);
std::vector<util::Coordinate> coords_2 = {{util::FloatLongitude(0), util::FloatLatitude(1)},
{util::FloatLongitude(2), util::FloatLatitude(3)},
{util::FloatLongitude(4), util::FloatLatitude(5)}};
std::vector<util::Coordinate> coords_2 = {{util::FloatLongitude{0}, util::FloatLatitude{1}},
{util::FloatLongitude{2}, util::FloatLatitude{3}},
{util::FloatLongitude{4}, util::FloatLatitude{5}}};
RouteParameters reference_6{};
reference_6.coordinates = coords_2;
@@ -250,10 +250,10 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
CHECK_EQUAL_RANGE(reference_9.radiuses, result_9->radiuses);
// Some Hint's are empty
std::vector<util::Coordinate> coords_3 = {{util::FloatLongitude(1), util::FloatLatitude(2)},
{util::FloatLongitude(3), util::FloatLatitude(4)},
{util::FloatLongitude(5), util::FloatLatitude(6)},
{util::FloatLongitude(7), util::FloatLatitude(8)}};
std::vector<util::Coordinate> coords_3 = {{util::FloatLongitude{1}, util::FloatLatitude{2}},
{util::FloatLongitude{3}, util::FloatLatitude{4}},
{util::FloatLongitude{5}, util::FloatLatitude{6}},
{util::FloatLongitude{7}, util::FloatLatitude{8}}};
std::vector<boost::optional<engine::Hint>> hints_10 = {
engine::Hint::FromBase64("DAIAgP___"
"38AAAAAAAAAAAIAAAAAAAAAEAAAAOgDAAD0AwAAGwAAAOUacQBQP5sCshpxAB0_"
@@ -293,8 +293,8 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
BOOST_AUTO_TEST_CASE(valid_table_urls)
{
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude(1), util::FloatLatitude(2)},
{util::FloatLongitude(3), util::FloatLatitude(4)}};
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude{1}, util::FloatLatitude{2}},
{util::FloatLongitude{3}, util::FloatLatitude{4}}};
TableParameters reference_1{};
reference_1.coordinates = coords_1;
@@ -329,8 +329,8 @@ BOOST_AUTO_TEST_CASE(valid_table_urls)
BOOST_AUTO_TEST_CASE(valid_match_urls)
{
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude(1), util::FloatLatitude(2)},
{util::FloatLongitude(3), util::FloatLatitude(4)}};
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude{1}, util::FloatLatitude{2}},
{util::FloatLongitude{3}, util::FloatLatitude{4}}};
MatchParameters reference_1{};
reference_1.coordinates = coords_1;
@@ -354,7 +354,7 @@ BOOST_AUTO_TEST_CASE(valid_match_urls)
BOOST_AUTO_TEST_CASE(valid_nearest_urls)
{
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude(1), util::FloatLatitude(2)}};
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude{1}, util::FloatLatitude{2}}};
NearestParameters reference_1{};
reference_1.coordinates = coords_1;
@@ -388,8 +388,8 @@ BOOST_AUTO_TEST_CASE(valid_tile_urls)
BOOST_AUTO_TEST_CASE(valid_trip_urls)
{
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude(1), util::FloatLatitude(2)},
{util::FloatLongitude(3), util::FloatLatitude(4)}};
std::vector<util::Coordinate> coords_1 = {{util::FloatLongitude{1}, util::FloatLatitude{2}},
{util::FloatLongitude{3}, util::FloatLatitude{4}}};
TripParameters reference_1{};
reference_1.coordinates = coords_1;
unit_tests/server/url_parser.cpp
+1 -1
View File
@@ -72,7 +72,7 @@ BOOST_AUTO_TEST_CASE(valid_urls)
// one coordinate
std::vector<util::Coordinate> coords_3 = {
util::Coordinate(util::FloatLongitude(0), util::FloatLatitude(1)),
util::Coordinate{util::FloatLongitude{0}, util::FloatLatitude{1}},
};
api::ParsedURL reference_3{"route", 1, "profile", "0,1", 18UL};
auto result_3 = api::parseURL("/route/v1/profile/0,1");
unit_tests/util/coordinate_calculation.cpp
+78 -78
View File
@@ -16,121 +16,121 @@ BOOST_AUTO_TEST_CASE(compute_angle)
{
// Simple cases
// North-South straight line
Coordinate first(FloatLongitude(1), FloatLatitude(-1));
Coordinate middle(FloatLongitude(1), FloatLatitude(0));
Coordinate end(FloatLongitude(1), FloatLatitude(1));
Coordinate first(FloatLongitude{1}, FloatLatitude{-1});
Coordinate middle(FloatLongitude{1}, FloatLatitude{0});
Coordinate end(FloatLongitude{1}, FloatLatitude{1});
auto angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 180);
// North-South-North u-turn
first = Coordinate(FloatLongitude(1), FloatLatitude(0));
middle = Coordinate(FloatLongitude(1), FloatLatitude(1));
end = Coordinate(FloatLongitude(1), FloatLatitude(0));
first = Coordinate(FloatLongitude{1}, FloatLatitude{0});
middle = Coordinate(FloatLongitude{1}, FloatLatitude{1});
end = Coordinate(FloatLongitude{1}, FloatLatitude{0});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 0);
// East-west straight lines are harder, *simple* coordinates only
// work at the equator. For other locations, we need to follow
// a rhumb line.
first = Coordinate(FloatLongitude(1), FloatLatitude(0));
middle = Coordinate(FloatLongitude(2), FloatLatitude(0));
end = Coordinate(FloatLongitude(3), FloatLatitude(0));
first = Coordinate(FloatLongitude{1}, FloatLatitude{0});
middle = Coordinate(FloatLongitude{2}, FloatLatitude{0});
end = Coordinate(FloatLongitude{3}, FloatLatitude{0});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 180);
// East-West-East u-turn
first = Coordinate(FloatLongitude(1), FloatLatitude(0));
middle = Coordinate(FloatLongitude(2), FloatLatitude(0));
end = Coordinate(FloatLongitude(1), FloatLatitude(0));
first = Coordinate(FloatLongitude{1}, FloatLatitude{0});
middle = Coordinate(FloatLongitude{2}, FloatLatitude{0});
end = Coordinate(FloatLongitude{1}, FloatLatitude{0});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 0);
// 90 degree left turn
first = Coordinate(FloatLongitude(1), FloatLatitude(1));
middle = Coordinate(FloatLongitude(0), FloatLatitude(1));
end = Coordinate(FloatLongitude(0), FloatLatitude(2));
first = Coordinate(FloatLongitude{1}, FloatLatitude{1});
middle = Coordinate(FloatLongitude{0}, FloatLatitude{1});
end = Coordinate(FloatLongitude{0}, FloatLatitude{2});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 90);
// 90 degree right turn
first = Coordinate(FloatLongitude(1), FloatLatitude(1));
middle = Coordinate(FloatLongitude(0), FloatLatitude(1));
end = Coordinate(FloatLongitude(0), FloatLatitude(0));
first = Coordinate(FloatLongitude{1}, FloatLatitude{1});
middle = Coordinate(FloatLongitude{0}, FloatLatitude{1});
end = Coordinate(FloatLongitude{0}, FloatLatitude{0});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 270);
// Weird cases
// Crossing both the meridians
first = Coordinate(FloatLongitude(-1), FloatLatitude(-1));
middle = Coordinate(FloatLongitude(0), FloatLatitude(1));
end = Coordinate(FloatLongitude(1), FloatLatitude(-1));
first = Coordinate(FloatLongitude{-1}, FloatLatitude{-1});
middle = Coordinate(FloatLongitude{0}, FloatLatitude{1});
end = Coordinate(FloatLongitude{1}, FloatLatitude{-1});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_CLOSE(angle, 53.1, 0.2);
// All coords in the same spot
first = Coordinate(FloatLongitude(-1), FloatLatitude(-1));
middle = Coordinate(FloatLongitude(-1), FloatLatitude(-1));
end = Coordinate(FloatLongitude(-1), FloatLatitude(-1));
first = Coordinate(FloatLongitude{-1}, FloatLatitude{-1});
middle = Coordinate(FloatLongitude{-1}, FloatLatitude{-1});
end = Coordinate(FloatLongitude{-1}, FloatLatitude{-1});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 180);
// First two coords in the same spot, then heading north-east
first = Coordinate(FloatLongitude(-1), FloatLatitude(-1));
middle = Coordinate(FloatLongitude(-1), FloatLatitude(-1));
end = Coordinate(FloatLongitude(1), FloatLatitude(1));
first = Coordinate(FloatLongitude{-1}, FloatLatitude{-1});
middle = Coordinate(FloatLongitude{-1}, FloatLatitude{-1});
end = Coordinate(FloatLongitude{1}, FloatLatitude{1});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 180);
// First two coords in the same spot, then heading west
first = Coordinate(FloatLongitude(1), FloatLatitude(1));
middle = Coordinate(FloatLongitude(1), FloatLatitude(1));
end = Coordinate(FloatLongitude(2), FloatLatitude(1));
first = Coordinate(FloatLongitude{1}, FloatLatitude{1});
middle = Coordinate(FloatLongitude{1}, FloatLatitude{1});
end = Coordinate(FloatLongitude{2}, FloatLatitude{1});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 180);
// First two coords in the same spot then heading north
first = Coordinate(FloatLongitude(1), FloatLatitude(1));
middle = Coordinate(FloatLongitude(1), FloatLatitude(1));
end = Coordinate(FloatLongitude(1), FloatLatitude(2));
first = Coordinate(FloatLongitude{1}, FloatLatitude{1});
middle = Coordinate(FloatLongitude{1}, FloatLatitude{1});
end = Coordinate(FloatLongitude{1}, FloatLatitude{2});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 180);
// Second two coords in the same spot
first = Coordinate(FloatLongitude(1), FloatLatitude(1));
middle = Coordinate(FloatLongitude(-1), FloatLatitude(-1));
end = Coordinate(FloatLongitude(-1), FloatLatitude(-1));
first = Coordinate(FloatLongitude{1}, FloatLatitude{1});
middle = Coordinate(FloatLongitude{-1}, FloatLatitude{-1});
end = Coordinate(FloatLongitude{-1}, FloatLatitude{-1});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 180);
// First and last coords on the same spot
first = Coordinate(FloatLongitude(1), FloatLatitude(1));
middle = Coordinate(FloatLongitude(-1), FloatLatitude(-1));
end = Coordinate(FloatLongitude(1), FloatLatitude(1));
first = Coordinate(FloatLongitude{1}, FloatLatitude{1});
middle = Coordinate(FloatLongitude{-1}, FloatLatitude{-1});
end = Coordinate(FloatLongitude{1}, FloatLatitude{1});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 0);
// Check the antimeridian
first = Coordinate(FloatLongitude(180), FloatLatitude(90));
middle = Coordinate(FloatLongitude(180), FloatLatitude(0));
end = Coordinate(FloatLongitude(180), FloatLatitude(-90));
first = Coordinate(FloatLongitude{180}, FloatLatitude{90});
middle = Coordinate(FloatLongitude{180}, FloatLatitude{0});
end = Coordinate(FloatLongitude{180}, FloatLatitude{-90});
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 180);
// Tiny changes below our calculation resolution
// This should be equivalent to having two points on the same
// spot.
first = Coordinate(FloatLongitude(0), FloatLatitude(0));
middle = Coordinate(FloatLongitude(1), FloatLatitude(0));
end = Coordinate(FloatLongitude(1 + std::numeric_limits<double>::epsilon()), FloatLatitude(0));
first = Coordinate{FloatLongitude{0}, FloatLatitude{0}};
middle = Coordinate{FloatLongitude{1}, FloatLatitude{0}};
end = Coordinate{FloatLongitude{1 + std::numeric_limits<double>::epsilon()}, FloatLatitude{0}};
angle = coordinate_calculation::computeAngle(first, middle, end);
BOOST_CHECK_EQUAL(angle, 180);
// Invalid values
/* TODO: Enable this when I figure out how to use BOOST_CHECK_THROW
* and not have the whole test case fail...
first = Coordinate(FloatLongitude(0), FloatLatitude(0));
middle = Coordinate(FloatLongitude(1), FloatLatitude(0));
end = Coordinate(FloatLongitude(std::numeric_limits<double>::max()), FloatLatitude(0));
first = Coordinate(FloatLongitude{0}, FloatLatitude{0});
middle = Coordinate(FloatLongitude{1}, FloatLatitude{0});
end = Coordinate(FloatLongitude(std::numeric_limits<double>::max()), FloatLatitude{0});
BOOST_CHECK_THROW( coordinate_calculation::computeAngle(first,middle,end),
boost::numeric::positive_overflow);
*/
@@ -139,9 +139,9 @@ BOOST_AUTO_TEST_CASE(compute_angle)
// Regression test for bug captured in #1347
BOOST_AUTO_TEST_CASE(regression_test_1347)
{
Coordinate u(FloatLongitude(-100), FloatLatitude(10));
Coordinate v(FloatLongitude(-100.002), FloatLatitude(10.001));
Coordinate q(FloatLongitude(-100.001), FloatLatitude(10.002));
Coordinate u(FloatLongitude{-100}, FloatLatitude{10});
Coordinate v(FloatLongitude{-100.002}, FloatLatitude{10.001});
Coordinate q(FloatLongitude{-100.001}, FloatLatitude{10.002});
double d1 = coordinate_calculation::perpendicularDistance(u, v, q);
@@ -179,10 +179,10 @@ BOOST_AUTO_TEST_CASE(regression_point_on_segment)
FloatCoordinate diff{target.lon - start.lon, target.lat - start.lat};
BOOST_CHECK_CLOSE(static_cast<double>(start.lon + FloatLongitude(ratio) * diff.lon),
BOOST_CHECK_CLOSE(static_cast<double>(start.lon + FloatLongitude{ratio} * diff.lon),
static_cast<double>(nearest.lon),
0.1);
BOOST_CHECK_CLOSE(static_cast<double>(start.lat + FloatLatitude(ratio) * diff.lat),
BOOST_CHECK_CLOSE(static_cast<double>(start.lat + FloatLatitude{ratio} * diff.lat),
static_cast<double>(nearest.lat),
0.1);
}
@@ -257,56 +257,56 @@ BOOST_AUTO_TEST_CASE(point_on_segment)
BOOST_AUTO_TEST_CASE(circleCenter)
{
Coordinate a(FloatLongitude(-100.), FloatLatitude(10.));
Coordinate b(FloatLongitude(-100.002), FloatLatitude(10.001));
Coordinate c(FloatLongitude(-100.001), FloatLatitude(10.002));
Coordinate a(FloatLongitude{-100.}, FloatLatitude{10.});
Coordinate b(FloatLongitude{-100.002}, FloatLatitude{10.001});
Coordinate c(FloatLongitude{-100.001}, FloatLatitude{10.002});
auto result = coordinate_calculation::circleCenter(a, b, c);
BOOST_CHECK(result);
BOOST_CHECK_EQUAL(*result, Coordinate(FloatLongitude(-100.000833), FloatLatitude(10.000833)));
BOOST_CHECK_EQUAL(*result, Coordinate(FloatLongitude{-100.000833}, FloatLatitude{10.000833}));
// Co-linear longitude
a = Coordinate(FloatLongitude(-100.), FloatLatitude(10.));
b = Coordinate(FloatLongitude(-100.001), FloatLatitude(10.001));
c = Coordinate(FloatLongitude(-100.001), FloatLatitude(10.002));
a = Coordinate(FloatLongitude{-100.}, FloatLatitude{10.});
b = Coordinate(FloatLongitude{-100.001}, FloatLatitude{10.001});
c = Coordinate(FloatLongitude{-100.001}, FloatLatitude{10.002});
result = coordinate_calculation::circleCenter(a, b, c);
BOOST_CHECK(result);
BOOST_CHECK_EQUAL(*result, Coordinate(FloatLongitude(-99.9995), FloatLatitude(10.0015)));
BOOST_CHECK_EQUAL(*result, Coordinate(FloatLongitude{-99.9995}, FloatLatitude{10.0015}));
// Co-linear longitude, impossible to calculate
a = Coordinate(FloatLongitude(-100.001), FloatLatitude(10.));
b = Coordinate(FloatLongitude(-100.001), FloatLatitude(10.001));
c = Coordinate(FloatLongitude(-100.001), FloatLatitude(10.002));
a = Coordinate(FloatLongitude{-100.001}, FloatLatitude{10.});
b = Coordinate(FloatLongitude{-100.001}, FloatLatitude{10.001});
c = Coordinate(FloatLongitude{-100.001}, FloatLatitude{10.002});
result = coordinate_calculation::circleCenter(a, b, c);
BOOST_CHECK(!result);
// Co-linear latitude, this is a real case that failed
a = Coordinate(FloatLongitude(-112.096234), FloatLatitude(41.147101));
b = Coordinate(FloatLongitude(-112.096606), FloatLatitude(41.147101));
c = Coordinate(FloatLongitude(-112.096419), FloatLatitude(41.147259));
a = Coordinate(FloatLongitude{-112.096234}, FloatLatitude{41.147101});
b = Coordinate(FloatLongitude{-112.096606}, FloatLatitude{41.147101});
c = Coordinate(FloatLongitude{-112.096419}, FloatLatitude{41.147259});
result = coordinate_calculation::circleCenter(a, b, c);
BOOST_CHECK(result);
BOOST_CHECK_EQUAL(*result, Coordinate(FloatLongitude(-112.09642), FloatLatitude(41.14707)));
BOOST_CHECK_EQUAL(*result, Coordinate(FloatLongitude{-112.09642}, FloatLatitude{41.14707}));
// Co-linear latitude, variation
a = Coordinate(FloatLongitude(-112.096234), FloatLatitude(41.147101));
b = Coordinate(FloatLongitude(-112.096606), FloatLatitude(41.147259));
c = Coordinate(FloatLongitude(-112.096419), FloatLatitude(41.147259));
a = Coordinate(FloatLongitude{-112.096234}, FloatLatitude{41.147101});
b = Coordinate(FloatLongitude{-112.096606}, FloatLatitude{41.147259});
c = Coordinate(FloatLongitude{-112.096419}, FloatLatitude{41.147259});
result = coordinate_calculation::circleCenter(a, b, c);
BOOST_CHECK(result);
BOOST_CHECK_EQUAL(*result, Coordinate(FloatLongitude(-112.096512), FloatLatitude(41.146962)));
BOOST_CHECK_EQUAL(*result, Coordinate(FloatLongitude{-112.096512}, FloatLatitude{41.146962}));
// Co-linear latitude, impossible to calculate
a = Coordinate(FloatLongitude(-112.096234), FloatLatitude(41.147259));
b = Coordinate(FloatLongitude(-112.096606), FloatLatitude(41.147259));
c = Coordinate(FloatLongitude(-112.096419), FloatLatitude(41.147259));
a = Coordinate(FloatLongitude{-112.096234}, FloatLatitude{41.147259});
b = Coordinate(FloatLongitude{-112.096606}, FloatLatitude{41.147259});
c = Coordinate(FloatLongitude{-112.096419}, FloatLatitude{41.147259});
result = coordinate_calculation::circleCenter(a, b, c);
BOOST_CHECK(!result);
// Out of bounds
a = Coordinate(FloatLongitude(-112.096234), FloatLatitude(41.147258));
b = Coordinate(FloatLongitude(-112.106606), FloatLatitude(41.147259));
c = Coordinate(FloatLongitude(-113.096419), FloatLatitude(41.147258));
a = Coordinate(FloatLongitude{-112.096234}, FloatLatitude{41.147258});
b = Coordinate(FloatLongitude{-112.106606}, FloatLatitude{41.147259});
c = Coordinate(FloatLongitude{-113.096419}, FloatLatitude{41.147258});
result = coordinate_calculation::circleCenter(a, b, c);
BOOST_CHECK(!result);
}
unit_tests/util/packed_vector.cpp
+1 -1
View File
@@ -19,7 +19,7 @@ BOOST_AUTO_TEST_CASE(insert_and_retrieve_packed_test)
for (std::size_t i = 0; i < num_test_cases; i++)
{
OSMNodeID r = static_cast<OSMNodeID>(rand() % 2147483647); // max 33-bit uint
OSMNodeID r {static_cast<std::uint64_t>(rand() % 2147483647)}; // max 33-bit uint
packed_ids.push_back(r);
original_ids.push_back(r);
unit_tests/util/rectangle.cpp
+36 -36
View File
@@ -27,22 +27,22 @@ BOOST_AUTO_TEST_CASE(get_min_dist_test)
// +- -80
// |
RectangleInt2D ne{
FloatLongitude(10), FloatLongitude(100), FloatLatitude(10), FloatLatitude(80)};
FloatLongitude{10}, FloatLongitude{100}, FloatLatitude{10}, FloatLatitude{80}};
RectangleInt2D nw{
FloatLongitude(-100), FloatLongitude(-10), FloatLatitude(10), FloatLatitude(80)};
FloatLongitude{-100}, FloatLongitude{-10}, FloatLatitude{10}, FloatLatitude{80}};
RectangleInt2D se{
FloatLongitude(10), FloatLongitude(100), FloatLatitude(-80), FloatLatitude(-10)};
FloatLongitude{10}, FloatLongitude{100}, FloatLatitude{-80}, FloatLatitude{-10}};
RectangleInt2D sw{
FloatLongitude(-100), FloatLongitude(-10), FloatLatitude(-80), FloatLatitude(-10)};
FloatLongitude{-100}, FloatLongitude{-10}, FloatLatitude{-80}, FloatLatitude{-10}};
Coordinate nw_sw{FloatLongitude(-100.1), FloatLatitude(9.9)};
Coordinate nw_se{FloatLongitude(-9.9), FloatLatitude(9.9)};
Coordinate nw_ne{FloatLongitude(-9.9), FloatLatitude(80.1)};
Coordinate nw_nw{FloatLongitude(-100.1), FloatLatitude(80.1)};
Coordinate nw_s{FloatLongitude(-55), FloatLatitude(9.9)};
Coordinate nw_e{FloatLongitude(-9.9), FloatLatitude(45.0)};
Coordinate nw_w{FloatLongitude(-100.1), FloatLatitude(45.0)};
Coordinate nw_n{FloatLongitude(-55), FloatLatitude(80.1)};
Coordinate nw_sw{FloatLongitude{-100.1}, FloatLatitude{9.9}};
Coordinate nw_se{FloatLongitude{-9.9}, FloatLatitude{9.9}};
Coordinate nw_ne{FloatLongitude{-9.9}, FloatLatitude{80.1}};
Coordinate nw_nw{FloatLongitude{-100.1}, FloatLatitude{80.1}};
Coordinate nw_s{FloatLongitude{-55}, FloatLatitude{9.9}};
Coordinate nw_e{FloatLongitude{-9.9}, FloatLatitude{45.0}};
Coordinate nw_w{FloatLongitude{-100.1}, FloatLatitude{45.0}};
Coordinate nw_n{FloatLongitude{-55}, FloatLatitude{80.1}};
BOOST_CHECK_CLOSE(
nw.GetMinSquaredDist(nw_sw), 0.02 * COORDINATE_PRECISION * COORDINATE_PRECISION, 0.1);
BOOST_CHECK_CLOSE(
@@ -60,14 +60,14 @@ BOOST_AUTO_TEST_CASE(get_min_dist_test)
BOOST_CHECK_CLOSE(
nw.GetMinSquaredDist(nw_n), 0.01 * COORDINATE_PRECISION * COORDINATE_PRECISION, 0.1);
Coordinate ne_sw{FloatLongitude(9.9), FloatLatitude(9.9)};
Coordinate ne_se{FloatLongitude(100.1), FloatLatitude(9.9)};
Coordinate ne_ne{FloatLongitude(100.1), FloatLatitude(80.1)};
Coordinate ne_nw{FloatLongitude(9.9), FloatLatitude(80.1)};
Coordinate ne_s{FloatLongitude(55), FloatLatitude(9.9)};
Coordinate ne_e{FloatLongitude(100.1), FloatLatitude(45.0)};
Coordinate ne_w{FloatLongitude(9.9), FloatLatitude(45.0)};
Coordinate ne_n{FloatLongitude(55), FloatLatitude(80.1)};
Coordinate ne_sw{FloatLongitude{9.9}, FloatLatitude{9.9}};
Coordinate ne_se{FloatLongitude{100.1}, FloatLatitude{9.9}};
Coordinate ne_ne{FloatLongitude{100.1}, FloatLatitude{80.1}};
Coordinate ne_nw{FloatLongitude{9.9}, FloatLatitude{80.1}};
Coordinate ne_s{FloatLongitude{55}, FloatLatitude{9.9}};
Coordinate ne_e{FloatLongitude{100.1}, FloatLatitude{45.0}};
Coordinate ne_w{FloatLongitude{9.9}, FloatLatitude{45.0}};
Coordinate ne_n{FloatLongitude{55}, FloatLatitude{80.1}};
BOOST_CHECK_CLOSE(
ne.GetMinSquaredDist(ne_sw), 0.02 * COORDINATE_PRECISION * COORDINATE_PRECISION, 0.1);
BOOST_CHECK_CLOSE(
@@ -85,14 +85,14 @@ BOOST_AUTO_TEST_CASE(get_min_dist_test)
BOOST_CHECK_CLOSE(
ne.GetMinSquaredDist(ne_n), 0.01 * COORDINATE_PRECISION * COORDINATE_PRECISION, 0.1);
Coordinate se_ne{FloatLongitude(100.1), FloatLatitude(-9.9)};
Coordinate se_nw{FloatLongitude(9.9), FloatLatitude(-9.9)};
Coordinate se_sw{FloatLongitude(9.9), FloatLatitude(-80.1)};
Coordinate se_se{FloatLongitude(100.1), FloatLatitude(-80.1)};
Coordinate se_n{FloatLongitude(55), FloatLatitude(-9.9)};
Coordinate se_w{FloatLongitude(9.9), FloatLatitude(-45.0)};
Coordinate se_e{FloatLongitude(100.1), FloatLatitude(-45.0)};
Coordinate se_s{FloatLongitude(55), FloatLatitude(-80.1)};
Coordinate se_ne{FloatLongitude{100.1}, FloatLatitude{-9.9}};
Coordinate se_nw{FloatLongitude{9.9}, FloatLatitude{-9.9}};
Coordinate se_sw{FloatLongitude{9.9}, FloatLatitude{-80.1}};
Coordinate se_se{FloatLongitude{100.1}, FloatLatitude{-80.1}};
Coordinate se_n{FloatLongitude{55}, FloatLatitude{-9.9}};
Coordinate se_w{FloatLongitude{9.9}, FloatLatitude{-45.0}};
Coordinate se_e{FloatLongitude{100.1}, FloatLatitude{-45.0}};
Coordinate se_s{FloatLongitude{55}, FloatLatitude{-80.1}};
BOOST_CHECK_CLOSE(
se.GetMinSquaredDist(se_sw), 0.02 * COORDINATE_PRECISION * COORDINATE_PRECISION, 0.1);
BOOST_CHECK_CLOSE(
@@ -110,14 +110,14 @@ BOOST_AUTO_TEST_CASE(get_min_dist_test)
BOOST_CHECK_CLOSE(
se.GetMinSquaredDist(se_n), 0.01 * COORDINATE_PRECISION * COORDINATE_PRECISION, 0.1);
Coordinate sw_ne{FloatLongitude(-9.9), FloatLatitude(-9.9)};
Coordinate sw_nw{FloatLongitude(-100.1), FloatLatitude(-9.9)};
Coordinate sw_sw{FloatLongitude(-100.1), FloatLatitude(-80.1)};
Coordinate sw_se{FloatLongitude(-9.9), FloatLatitude(-80.1)};
Coordinate sw_n{FloatLongitude(-55), FloatLatitude(-9.9)};
Coordinate sw_w{FloatLongitude(-100.1), FloatLatitude(-45.0)};
Coordinate sw_e{FloatLongitude(-9.9), FloatLatitude(-45.0)};
Coordinate sw_s{FloatLongitude(-55), FloatLatitude(-80.1)};
Coordinate sw_ne{FloatLongitude{-9.9}, FloatLatitude{-9.9}};
Coordinate sw_nw{FloatLongitude{-100.1}, FloatLatitude{-9.9}};
Coordinate sw_sw{FloatLongitude{-100.1}, FloatLatitude{-80.1}};
Coordinate sw_se{FloatLongitude{-9.9}, FloatLatitude{-80.1}};
Coordinate sw_n{FloatLongitude{-55}, FloatLatitude{-9.9}};
Coordinate sw_w{FloatLongitude{-100.1}, FloatLatitude{-45.0}};
Coordinate sw_e{FloatLongitude{-9.9}, FloatLatitude{-45.0}};
Coordinate sw_s{FloatLongitude{-55}, FloatLatitude{-80.1}};
BOOST_CHECK_CLOSE(
sw.GetMinSquaredDist(sw_sw), 0.02 * COORDINATE_PRECISION * COORDINATE_PRECISION, 0.1);
BOOST_CHECK_CLOSE(
unit_tests/util/static_rtree.cpp
+16 -16
View File
@@ -117,7 +117,7 @@ template <unsigned NUM_NODES, unsigned NUM_EDGES> struct RandomGraphFixture
{
int lon = lon_udist(g);
int lat = lat_udist(g);
coords.emplace_back(Coordinate(FixedLongitude(lon), FixedLatitude(lat)));
coords.emplace_back(Coordinate(FixedLongitude{lon}, FixedLatitude{lat}));
}
std::uniform_int_distribution<> edge_udist(0, coords.size() - 1);
@@ -216,7 +216,7 @@ void sampling_verify_rtree(RTreeT &rtree,
std::vector<Coordinate> queries;
for (unsigned i = 0; i < num_samples; i++)
{
queries.emplace_back(FixedLongitude(lon_udist(g)), FixedLatitude(lat_udist(g)));
queries.emplace_back(FixedLongitude{lon_udist(g)}, FixedLatitude{lat_udist(g)});
}
for (const auto &q : queries)
@@ -324,7 +324,7 @@ BOOST_AUTO_TEST_CASE(regression_test)
LinearSearchNN<TestData> lsnn(fixture.coords, fixture.edges);
// query a node just right of the center of the gap
Coordinate input(FloatLongitude(55.1), FloatLatitude(20.0));
Coordinate input(FloatLongitude{55.1}, FloatLatitude{20.0});
auto result_rtree = rtree.Nearest(input, 1);
auto result_ls = lsnn.Nearest(input, 1);
@@ -342,8 +342,8 @@ BOOST_AUTO_TEST_CASE(radius_regression_test)
using Edge = std::pair<unsigned, unsigned>;
GraphFixture fixture(
{
Coord(FloatLongitude(0.0), FloatLatitude(0.0)),
Coord(FloatLongitude(10.0), FloatLatitude(10.0)),
Coord(FloatLongitude{0.0}, FloatLatitude{0.0}),
Coord(FloatLongitude{10.0}, FloatLatitude{10.0}),
},
{Edge(0, 1), Edge(1, 0)});
@@ -355,7 +355,7 @@ BOOST_AUTO_TEST_CASE(radius_regression_test)
engine::GeospatialQuery<MiniStaticRTree, MockDataFacade> query(
rtree, fixture.coords, mockfacade);
Coordinate input(FloatLongitude(5.2), FloatLatitude(5.0));
Coordinate input(FloatLongitude{5.2}, FloatLatitude{5.0});
{
auto results = query.NearestPhantomNodesInRange(input, 0.01);
@@ -369,8 +369,8 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
using Edge = std::pair<unsigned, unsigned>;
GraphFixture fixture(
{
Coord(FloatLongitude(0.0), FloatLatitude(0.0)),
Coord(FloatLongitude(10.0), FloatLatitude(10.0)),
Coord(FloatLongitude{0.0}, FloatLatitude{0.0}),
Coord(FloatLongitude{10.0}, FloatLatitude{10.0}),
},
{Edge(0, 1), Edge(1, 0)});
@@ -382,7 +382,7 @@ BOOST_AUTO_TEST_CASE(bearing_tests)
engine::GeospatialQuery<MiniStaticRTree, MockDataFacade> query(
rtree, fixture.coords, mockfacade);
Coordinate input(FloatLongitude(5.1), FloatLatitude(5.0));
Coordinate input(FloatLongitude{5.1}, FloatLatitude{5.0});
{
auto results = query.NearestPhantomNodes(input, 5);
@@ -440,11 +440,11 @@ BOOST_AUTO_TEST_CASE(bbox_search_tests)
GraphFixture fixture(
{
Coord(FloatLongitude(0.0), FloatLatitude(0.0)),
Coord(FloatLongitude(1.0), FloatLatitude(1.0)),
Coord(FloatLongitude(2.0), FloatLatitude(2.0)),
Coord(FloatLongitude(3.0), FloatLatitude(3.0)),
Coord(FloatLongitude(4.0), FloatLatitude(4.0)),
Coord(FloatLongitude{0.0}, FloatLatitude{0.0}),
Coord(FloatLongitude{1.0}, FloatLatitude{1.0}),
Coord(FloatLongitude{2.0}, FloatLatitude{2.0}),
Coord(FloatLongitude{3.0}, FloatLatitude{3.0}),
Coord(FloatLongitude{4.0}, FloatLatitude{4.0}),
},
{Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(3, 4)});
@@ -458,14 +458,14 @@ BOOST_AUTO_TEST_CASE(bbox_search_tests)
{
RectangleInt2D bbox = {
FloatLongitude(0.5), FloatLongitude(1.5), FloatLatitude(0.5), FloatLatitude(1.5)};
FloatLongitude{0.5}, FloatLongitude{1.5}, FloatLatitude{0.5}, FloatLatitude{1.5}};
auto results = query.Search(bbox);
BOOST_CHECK_EQUAL(results.size(), 2);
}
{
RectangleInt2D bbox = {
FloatLongitude(1.5), FloatLongitude(3.5), FloatLatitude(1.5), FloatLatitude(3.5)};
FloatLongitude{1.5}, FloatLongitude{3.5}, FloatLatitude{1.5}, FloatLatitude{3.5}};
auto results = query.Search(bbox);
BOOST_CHECK_EQUAL(results.size(), 3);
}
unit_tests/util/web_mercator.cpp
+5 -5
View File
@@ -22,23 +22,23 @@ BOOST_AUTO_TEST_CASE(lon_to_pixel)
BOOST_AUTO_TEST_CASE(lat_to_pixel)
{
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude(43.733947)) *
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude{43.733947}) *
web_mercator::DEGREE_TO_PX,
5424361.75863,
0.1);
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude(43.733799)) *
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude{43.733799}) *
web_mercator::DEGREE_TO_PX,
5424338.95731,
0.1);
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude(43.733922)) *
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude{43.733922}) *
web_mercator::DEGREE_TO_PX,
5424357.90705,
0.1);
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude(43.733697)) *
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude{43.733697}) *
web_mercator::DEGREE_TO_PX,
5424323.24293,
0.1);
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude(43.733729)) *
BOOST_CHECK_CLOSE(web_mercator::latToY(util::FloatLatitude{43.733729}) *
web_mercator::DEGREE_TO_PX,
5424328.17293,
0.1);