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

Add viaroute suport for new API

Browse Source
This commit is contained in:
Patrick Niklaus
2016-01-28 16:28:44 +01:00
parent 54ee76bcef
commit f3e72623e9
87 changed files with 3352 additions and 2099 deletions
Download Patch File Download Diff File Expand all files Collapse all files
unit_tests/engine/douglas_peucker.cpp
+35 -37
View File
@@ -1,5 +1,4 @@
#include "engine/douglas_peucker.hpp"
#include "engine/segment_information.hpp"
#include <boost/test/unit_test.hpp>
#include <boost/test/test_case_template.hpp>
@@ -13,13 +12,7 @@ BOOST_AUTO_TEST_SUITE(douglas_peucker_simplification)
using namespace osrm;
using namespace osrm::engine;
SegmentInformation getTestInfo(int lat, int lon, bool necessary)
{
return SegmentInformation(util::FixedPointCoordinate(lat, lon), 0, 0, 0,
extractor::TurnInstruction::HeadOn, necessary, false, 0);
}
BOOST_AUTO_TEST_CASE(all_necessary_test)
BOOST_AUTO_TEST_CASE(removed_middle_test)
{
/*
x
@@ -27,19 +20,23 @@ BOOST_AUTO_TEST_CASE(all_necessary_test)
x \
/ \
x x
/
*/
std::vector<SegmentInformation> info = {getTestInfo(5, 5, true),
getTestInfo(6, 6, true),
getTestInfo(10, 10, true),
getTestInfo(5, 15, true)};
for (unsigned z = 0; z < detail::DOUGLAS_PEUCKER_THRESHOLDS_SIZE; z++)
std::vector<util::FixedPointCoordinate> coordinates = {
util::FixedPointCoordinate(5 * COORDINATE_PRECISION, 5 * COORDINATE_PRECISION),
util::FixedPointCoordinate(6 * COORDINATE_PRECISION, 6 * COORDINATE_PRECISION),
util::FixedPointCoordinate(10 * COORDINATE_PRECISION, 10 * COORDINATE_PRECISION),
util::FixedPointCoordinate(5 * COORDINATE_PRECISION, 15 * COORDINATE_PRECISION)};
// FIXME this test fails for everything below z4 because the DP algorithms
// only used a naive distance measurement
//for (unsigned z = 0; z < detail::DOUGLAS_PEUCKER_THRESHOLDS_SIZE; z++)
for (unsigned z = 0; z < 2; z++)
{
douglasPeucker(info, z);
for (const auto &i : info)
{
BOOST_CHECK_EQUAL(i.necessary, true);
}
auto result = douglasPeucker(coordinates, z);
BOOST_CHECK_EQUAL(result.size(), 3);
BOOST_CHECK_EQUAL(result[0], coordinates[0]);
BOOST_CHECK_EQUAL(result[1], coordinates[2]);
BOOST_CHECK_EQUAL(result[2], coordinates[3]);
}
}
@@ -54,26 +51,27 @@ BOOST_AUTO_TEST_CASE(remove_second_node_test)
|
x
*/
std::vector<SegmentInformation> info = {
getTestInfo(5 * COORDINATE_PRECISION, 5 * COORDINATE_PRECISION, true),
getTestInfo(5 * COORDINATE_PRECISION,
5 * COORDINATE_PRECISION + detail::DOUGLAS_PEUCKER_THRESHOLDS[z], false),
getTestInfo(10 * COORDINATE_PRECISION, 10 * COORDINATE_PRECISION, false),
getTestInfo(10 * COORDINATE_PRECISION,
10 + COORDINATE_PRECISION + detail::DOUGLAS_PEUCKER_THRESHOLDS[z] * 2,
false),
getTestInfo(5 * COORDINATE_PRECISION, 15 * COORDINATE_PRECISION, false),
getTestInfo(5 * COORDINATE_PRECISION + detail::DOUGLAS_PEUCKER_THRESHOLDS[z],
15 * COORDINATE_PRECISION, true),
std::vector<util::FixedPointCoordinate> input = {
util::FixedPointCoordinate(5 * COORDINATE_PRECISION, 5 * COORDINATE_PRECISION),
util::FixedPointCoordinate(5 * COORDINATE_PRECISION,
5 * COORDINATE_PRECISION +
detail::DOUGLAS_PEUCKER_THRESHOLDS[z]),
util::FixedPointCoordinate(10 * COORDINATE_PRECISION, 10 * COORDINATE_PRECISION),
util::FixedPointCoordinate(10 * COORDINATE_PRECISION,
10 + COORDINATE_PRECISION +
detail::DOUGLAS_PEUCKER_THRESHOLDS[z] * 2),
util::FixedPointCoordinate(5 * COORDINATE_PRECISION, 15 * COORDINATE_PRECISION),
util::FixedPointCoordinate(5 * COORDINATE_PRECISION +
detail::DOUGLAS_PEUCKER_THRESHOLDS[z],
15 * COORDINATE_PRECISION),
};
BOOST_TEST_MESSAGE("Threshold (" << z << "): " << detail::DOUGLAS_PEUCKER_THRESHOLDS[z]);
douglasPeucker(info, z);
BOOST_CHECK_EQUAL(info[0].necessary, true);
BOOST_CHECK_EQUAL(info[1].necessary, false);
BOOST_CHECK_EQUAL(info[2].necessary, true);
BOOST_CHECK_EQUAL(info[3].necessary, true);
BOOST_CHECK_EQUAL(info[4].necessary, false);
BOOST_CHECK_EQUAL(info[5].necessary, true);
auto result = douglasPeucker(input, z);
BOOST_CHECK_EQUAL(result.size(), 4);
BOOST_CHECK_EQUAL(input[0], result[0]);
BOOST_CHECK_EQUAL(input[2], result[1]);
BOOST_CHECK_EQUAL(input[3], result[2]);
BOOST_CHECK_EQUAL(input[5], result[3]);
}
}
unit_tests/engine/geometry_string.cpp
+1 -1
View File
@@ -18,7 +18,7 @@ BOOST_AUTO_TEST_CASE(decode)
{
// Polyline string for the 5 coordinates
const std::string polyline = "_gjaR_gjaR_pR_ibE_pR_ibE_pR_ibE_pR_ibE";
const auto coords = polylineDecode(polyline);
const auto coords = decodePolyline(polyline);
// Test coordinates; these would be the coordinates we give the loc parameter,
// e.g. loc=10.00,10.0&loc=10.01,10.1...
unit_tests/server/route_parameters_parser.cpp
+168
View File
@@ -0,0 +1,168 @@
#include "server/api/route_parameters_parser.hpp"
#include <fstream>
namespace osrm
{
namespace engine
{
namespace api
{
std::ostream &operator<<(std::ostream &out, api::RouteParameters::GeometriesType geometries)
{
switch (geometries)
{
case api::RouteParameters::GeometriesType::GeoJSON:
out << "GeoJSON";
break;
case api::RouteParameters::GeometriesType::Polyline:
out << "Polyline";
break;
default:
BOOST_ASSERT_MSG(false, "GeometriesType not fully captured");
}
return out;
}
std::ostream &operator<<(std::ostream &out, api::RouteParameters::OverviewType overview)
{
switch (overview)
{
case api::RouteParameters::OverviewType::False:
out << "False";
break;
case api::RouteParameters::OverviewType::Full:
out << "Full";
break;
case api::RouteParameters::OverviewType::Simplified:
out << "Simplified";
break;
default:
BOOST_ASSERT_MSG(false, "OverviewType not fully captured");
}
return out;
}
std::ostream &operator<<(std::ostream &out, api::RouteParameters::Bearing bearing)
{
out << bearing.bearing << "," << bearing.range;
return out;
}
}
}
}
#include <boost/test/unit_test.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/optional/optional_io.hpp>
#define CHECK_EQUAL_RANGE(R1, R2) \
BOOST_CHECK_EQUAL_COLLECTIONS(R1.begin(), R1.end(), R2.begin(), R2.end());
BOOST_AUTO_TEST_SUITE(api_route_parameters_parser)
using namespace osrm;
using namespace osrm::server;
// returns distance to front
std::size_t testInvalidOptions(std::string options)
{
auto iter = options.begin();
auto result = api::parseRouteParameters(iter, options.end());
BOOST_CHECK(!result);
return std::distance(options.begin(), iter);
}
BOOST_AUTO_TEST_CASE(invalid_urls)
{
BOOST_CHECK_EQUAL(testInvalidOptions("overview=false&bla=foo"), 14UL);
BOOST_CHECK_EQUAL(testInvalidOptions("overview=false&bearings=foo"), 24UL);
BOOST_CHECK_EQUAL(testInvalidOptions("overview=false&uturns=foo"), 22UL);
BOOST_CHECK_EQUAL(testInvalidOptions("overview=false&radiuses=foo"), 24UL);
BOOST_CHECK_EQUAL(testInvalidOptions("overview=false&hints=foo"), 14UL);
BOOST_CHECK_EQUAL(testInvalidOptions("overview=false&geometries=foo"), 14UL);
BOOST_CHECK_EQUAL(testInvalidOptions("overview=false&overview=foo"), 14UL);
BOOST_CHECK_EQUAL(testInvalidOptions("overview=false&alternative=foo"), 14UL);
}
BOOST_AUTO_TEST_CASE(valid_urls)
{
engine::api::RouteParameters reference_1{};
auto result_1 = api::parseRouteParameters("");
BOOST_CHECK(result_1);
BOOST_CHECK_EQUAL(reference_1.steps, result_1->steps);
BOOST_CHECK_EQUAL(reference_1.alternative, result_1->alternative);
BOOST_CHECK_EQUAL(reference_1.geometries, result_1->geometries);
BOOST_CHECK_EQUAL(reference_1.overview, result_1->overview);
CHECK_EQUAL_RANGE(reference_1.uturns, result_1->uturns);
CHECK_EQUAL_RANGE(reference_1.bearings, result_1->bearings);
CHECK_EQUAL_RANGE(reference_1.radiuses, result_1->radiuses);
CHECK_EQUAL_RANGE(reference_1.coordinates, result_1->coordinates);
// bool steps = true;
// bool alternative = true;
// GeometriesType geometries = GeometriesType::Polyline;
// OverviewType overview = OverviewType::False;
// std::vector<boost::optional<bool>> uturns;
engine::api::RouteParameters reference_2{};
auto result_2 = api::parseRouteParameters(
"steps=true&alternative=true&geometries=polyline&overview=simplified");
BOOST_CHECK(result_2);
BOOST_CHECK_EQUAL(reference_2.steps, result_2->steps);
BOOST_CHECK_EQUAL(reference_2.alternative, result_2->alternative);
BOOST_CHECK_EQUAL(reference_2.geometries, result_2->geometries);
BOOST_CHECK_EQUAL(reference_2.overview, result_2->overview);
CHECK_EQUAL_RANGE(reference_2.uturns, result_2->uturns);
CHECK_EQUAL_RANGE(reference_2.bearings, result_2->bearings);
CHECK_EQUAL_RANGE(reference_2.radiuses, result_2->radiuses);
CHECK_EQUAL_RANGE(reference_2.coordinates, result_2->coordinates);
std::vector<boost::optional<bool>> uturns_3 = {true, false, boost::none};
engine::api::RouteParameters reference_3{
false, false, engine::api::RouteParameters::GeometriesType::GeoJSON,
engine::api::RouteParameters::OverviewType::False, uturns_3};
auto result_3 = api::parseRouteParameters(
"steps=false&alternative=false&geometries=geojson&overview=false&uturns=true;false;");
BOOST_CHECK(result_3);
BOOST_CHECK_EQUAL(reference_3.steps, result_3->steps);
BOOST_CHECK_EQUAL(reference_3.alternative, result_3->alternative);
BOOST_CHECK_EQUAL(reference_3.geometries, result_3->geometries);
BOOST_CHECK_EQUAL(reference_3.overview, result_3->overview);
CHECK_EQUAL_RANGE(reference_3.uturns, result_3->uturns);
CHECK_EQUAL_RANGE(reference_3.bearings, result_3->bearings);
CHECK_EQUAL_RANGE(reference_3.radiuses, result_3->radiuses);
CHECK_EQUAL_RANGE(reference_3.coordinates, result_3->coordinates);
std::vector<boost::optional<engine::Hint>> hints_4 = {
engine::Hint::FromBase64(
"rVghAzxMzABMAwAA5h4CAKMIAAAQAAAAGAAAAAYAAAAAAAAAch8BAJ4AAACpWCED_0vMAAEAAQGLSzmR"),
engine::Hint::FromBase64(
"_4ghA4JuzAD_IAAAo28BAOYAAAAzAAAAAgAAAEwAAAAAAAAAdIwAAJ4AAAAXiSEDfm7MAAEAAQGLSzmR"),
engine::Hint::FromBase64(
"03AhA0vnzAA_SAAA_____3wEAAAYAAAAQAAAAB4AAABAAAAAoUYBAJ4AAADlcCEDSefMAAMAAQGLSzmR")};
engine::api::RouteParameters reference_4{false,
true,
engine::api::RouteParameters::GeometriesType::Polyline,
engine::api::RouteParameters::OverviewType::Simplified,
std::vector<boost::optional<bool>>{},
std::vector<util::FixedPointCoordinate>{},
hints_4,
std::vector<boost::optional<double>>{},
std::vector<boost::optional<engine::api::BaseParameters::Bearing>>{}
};
auto result_4 = api::parseRouteParameters(
"steps=false&hints=rVghAzxMzABMAwAA5h4CAKMIAAAQAAAAGAAAAAYAAAAAAAAAch8BAJ4AAACpWCED_"
"0vMAAEAAQGLSzmR;_4ghA4JuzAD_"
"IAAAo28BAOYAAAAzAAAAAgAAAEwAAAAAAAAAdIwAAJ4AAAAXiSEDfm7MAAEAAQGLSzmR;03AhA0vnzAA_SAAA_____"
"3wEAAAYAAAAQAAAAB4AAABAAAAAoUYBAJ4AAADlcCEDSefMAAMAAQGLSzmR");
BOOST_CHECK(result_3);
BOOST_CHECK_EQUAL(reference_4.steps, result_4->steps);
BOOST_CHECK_EQUAL(reference_4.alternative, result_4->alternative);
BOOST_CHECK_EQUAL(reference_4.geometries, result_4->geometries);
BOOST_CHECK_EQUAL(reference_4.overview, result_4->overview);
CHECK_EQUAL_RANGE(reference_4.uturns, result_4->uturns);
CHECK_EQUAL_RANGE(reference_4.bearings, result_4->bearings);
CHECK_EQUAL_RANGE(reference_4.radiuses, result_4->radiuses);
CHECK_EQUAL_RANGE(reference_4.coordinates, result_4->coordinates);
}
BOOST_AUTO_TEST_SUITE_END()
unit_tests/server/url_parser.cpp
+110
View File
@@ -0,0 +1,110 @@
#include "server/api/url_parser.hpp"
#include <fstream>
// needed for BOOST_CHECK_EQUAL
namespace osrm
{
namespace server
{
namespace api
{
std::ostream& operator<<(std::ostream& out, const osrm::server::api::ParsedURL& url)
{
out << url.service << ", " << url.version << ", " << url.profile << ", ";
for (auto c : url.coordinates)
{
out << c << " ";
}
out << ", " << url.options;
return out;
}
}
}
}
#include <boost/test/unit_test.hpp>
#include <boost/test/test_tools.hpp>
#define CHECK_EQUAL_RANGE(R1, R2) \
BOOST_CHECK_EQUAL_COLLECTIONS(R1.begin(), R1.end(), R2.begin(), R2.end());
BOOST_AUTO_TEST_SUITE(api_url_parser)
using namespace osrm;
using namespace osrm::server;
// returns distance to front
std::size_t testInvalidURL(std::string url)
{
auto iter = url.begin();
auto result = api::parseURL(iter, url.end());
BOOST_CHECK(!result);
return std::distance(url.begin(), iter);
}
BOOST_AUTO_TEST_CASE(invalid_urls)
{
BOOST_CHECK_EQUAL(testInvalidURL("/route/"), 0UL);
BOOST_CHECK_EQUAL(testInvalidURL("/route/bla"), 0UL);
BOOST_CHECK_EQUAL(testInvalidURL("/route/1/1,2;3;4"), 0UL);
BOOST_CHECK_EQUAL(testInvalidURL("/route/v1/pro_file/1,2;3,4"), 0UL);
BOOST_CHECK_EQUAL(testInvalidURL("/route/v1/profile"), 0UL);
BOOST_CHECK_EQUAL(testInvalidURL("/route/v1/profile/"), 0UL);
}
BOOST_AUTO_TEST_CASE(valid_urls)
{
std::vector<util::FixedPointCoordinate> coords_1 = {
// lat,lon
util::FixedPointCoordinate(1 * COORDINATE_PRECISION, 0 * COORDINATE_PRECISION),
util::FixedPointCoordinate(3 * COORDINATE_PRECISION, 2 * COORDINATE_PRECISION),
util::FixedPointCoordinate(5 * COORDINATE_PRECISION, 4 * COORDINATE_PRECISION),
};
api::ParsedURL reference_1{"route", 1, "profile", coords_1, "options=value&foo=bar"};
auto result_1 = api::parseURL("/route/v1/profile/0,1;2,3;4,5?options=value&foo=bar");
BOOST_CHECK(result_1);
BOOST_CHECK_EQUAL(reference_1.service, result_1->service);
BOOST_CHECK_EQUAL(reference_1.version, result_1->version);
BOOST_CHECK_EQUAL(reference_1.profile, result_1->profile);
CHECK_EQUAL_RANGE(reference_1.coordinates, result_1->coordinates);
BOOST_CHECK_EQUAL(reference_1.options, result_1->options);
// no options
api::ParsedURL reference_2{"route", 1, "profile", coords_1, ""};
auto result_2 = api::parseURL("/route/v1/profile/0,1;2,3;4,5");
BOOST_CHECK(result_2);
BOOST_CHECK_EQUAL(reference_2.service, result_2->service);
BOOST_CHECK_EQUAL(reference_2.version, result_2->version);
BOOST_CHECK_EQUAL(reference_2.profile, result_2->profile);
CHECK_EQUAL_RANGE(reference_2.coordinates, result_2->coordinates);
BOOST_CHECK_EQUAL(reference_2.options, result_2->options);
// one coordinate
std::vector<util::FixedPointCoordinate> coords_3 = {
// lat,lon
util::FixedPointCoordinate(1 * COORDINATE_PRECISION, 0 * COORDINATE_PRECISION),
};
api::ParsedURL reference_3{"route", 1, "profile", coords_3, ""};
auto result_3 = api::parseURL("/route/v1/profile/0,1");
BOOST_CHECK(result_3);
BOOST_CHECK_EQUAL(reference_3.service, result_3->service);
BOOST_CHECK_EQUAL(reference_3.version, result_3->version);
BOOST_CHECK_EQUAL(reference_3.profile, result_3->profile);
CHECK_EQUAL_RANGE(reference_3.coordinates, result_3->coordinates);
BOOST_CHECK_EQUAL(reference_3.options, result_3->options);
// polyline
api::ParsedURL reference_5{"route", 1, "profile", coords_1, ""};
auto result_5 = api::parseURL("/route/v1/profile/polyline(_ibE?_seK_seK_seK_seK)?");
BOOST_CHECK(result_5);
BOOST_CHECK_EQUAL(reference_5.service, result_5->service);
BOOST_CHECK_EQUAL(reference_5.version, result_5->version);
BOOST_CHECK_EQUAL(reference_5.profile, result_5->profile);
CHECK_EQUAL_RANGE(reference_5.coordinates, result_5->coordinates);
BOOST_CHECK_EQUAL(reference_5.options, result_5->options);
}
BOOST_AUTO_TEST_SUITE_END()
unit_tests/server_tests.cpp
+7
View File
@@ -0,0 +1,7 @@
#define BOOST_TEST_MODULE server tests
#include <boost/test/unit_test.hpp>
/*
* This file will contain an automatically generated main function.
*/
unit_tests/util/tiles.cpp
+74
View File
@@ -0,0 +1,74 @@
#include "util/tiles.hpp"
using namespace osrm::util;
#include <boost/functional/hash.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/test/test_case_template.hpp>
#include <iostream>
BOOST_AUTO_TEST_SUITE(tiles_test)
using namespace osrm;
using namespace osrm::util;
BOOST_AUTO_TEST_CASE(point_to_tile_test)
{
tiles::Tile tile_1_reference{2306375680,1409941503,32};
tiles::Tile tile_2_reference{2308259840,1407668224,32};
tiles::Tile tile_3_reference{616562688,2805989376,32};
tiles::Tile tile_4_reference{1417674752,2084569088,32};
tiles::Tile tile_5_reference{616562688,2805989376,32};
tiles::Tile tile_6_reference{712654285,2671662374,32};
auto tile_1 = tiles::pointToTile(13.31817626953125,52.449314140869696);
auto tile_2 = tiles::pointToTile(13.476104736328125,52.56529070208021);
auto tile_3 = tiles::pointToTile(-128.32031249999997,-48.224672649565186);
auto tile_4 = tiles::pointToTile(-61.17187499999999,5.266007882805498);
auto tile_5 = tiles::pointToTile(-128.32031249999997,-48.224672649565186);
auto tile_6 = tiles::pointToTile(-120.266007882805532,-40.17187499999999);
BOOST_CHECK_EQUAL(tile_1.x, tile_1_reference.x);
BOOST_CHECK_EQUAL(tile_1.y, tile_1_reference.y);
BOOST_CHECK_EQUAL(tile_1.z, tile_1_reference.z);
BOOST_CHECK_EQUAL(tile_2.x, tile_2_reference.x);
BOOST_CHECK_EQUAL(tile_2.y, tile_2_reference.y);
BOOST_CHECK_EQUAL(tile_2.z, tile_2_reference.z);
BOOST_CHECK_EQUAL(tile_3.x, tile_3_reference.x);
BOOST_CHECK_EQUAL(tile_3.y, tile_3_reference.y);
BOOST_CHECK_EQUAL(tile_3.z, tile_3_reference.z);
BOOST_CHECK_EQUAL(tile_4.x, tile_4_reference.x);
BOOST_CHECK_EQUAL(tile_4.y, tile_4_reference.y);
BOOST_CHECK_EQUAL(tile_4.z, tile_4_reference.z);
BOOST_CHECK_EQUAL(tile_5.x, tile_5_reference.x);
BOOST_CHECK_EQUAL(tile_5.y, tile_5_reference.y);
BOOST_CHECK_EQUAL(tile_5.z, tile_5_reference.z);
BOOST_CHECK_EQUAL(tile_6.x, tile_6_reference.x);
BOOST_CHECK_EQUAL(tile_6.y, tile_6_reference.y);
BOOST_CHECK_EQUAL(tile_6.z, tile_6_reference.z);
}
// Verify that the bearing-bounds checking function behaves as expected
BOOST_AUTO_TEST_CASE(bounding_box_to_tile_test)
{
tiles::Tile tile_1_reference{17, 10, 5};
tiles::Tile tile_2_reference{0, 0, 0};
tiles::Tile tile_3_reference{0, 2, 2};
auto tile_1 = tiles::getBBMaxZoomTile(13.31817626953125, 52.449314140869696,
13.476104736328125, 52.56529070208021);
auto tile_2 = tiles::getBBMaxZoomTile(-128.32031249999997, -48.224672649565186,
-61.17187499999999, 5.266007882805498);
auto tile_3 = tiles::getBBMaxZoomTile(-128.32031249999997, -48.224672649565186,
-120.2660078828055, -40.17187499999999);
BOOST_CHECK_EQUAL(tile_1.x, tile_1_reference.x);
BOOST_CHECK_EQUAL(tile_1.y, tile_1_reference.y);
BOOST_CHECK_EQUAL(tile_1.z, tile_1_reference.z);
BOOST_CHECK_EQUAL(tile_2.x, tile_2_reference.x);
BOOST_CHECK_EQUAL(tile_2.y, tile_2_reference.y);
BOOST_CHECK_EQUAL(tile_2.z, tile_2_reference.z);
BOOST_CHECK_EQUAL(tile_3.x, tile_3_reference.x);
BOOST_CHECK_EQUAL(tile_3.y, tile_3_reference.y);
BOOST_CHECK_EQUAL(tile_3.z, tile_3_reference.z);
}
BOOST_AUTO_TEST_SUITE_END()